discourse/app/models/group.rb

510 lines
16 KiB
Ruby
Raw Normal View History

class Group < ActiveRecord::Base
include HasCustomFields
has_many :category_groups, dependent: :destroy
has_many :group_users, dependent: :destroy
has_many :group_mentions, dependent: :destroy
has_many :group_archived_messages, dependent: :destroy
has_many :categories, through: :category_groups
has_many :users, through: :group_users
2016-06-15 13:49:57 -04:00
has_and_belongs_to_many :web_hooks
2015-12-07 06:39:28 -05:00
before_save :downcase_incoming_email
after_save :destroy_deletions
after_save :automatic_group_membership
after_save :update_primary_group
after_save :update_title
after_save :expire_cache
after_destroy :expire_cache
def expire_cache
ApplicationSerializer.expire_cache_fragment!("group_names")
end
validate :name_format_validator
validates_uniqueness_of :name, case_sensitive: false
validate :automatic_membership_email_domains_format_validator
2015-12-07 06:39:28 -05:00
validate :incoming_email_validator
validates :flair_url, url: true, if: Proc.new { |g| g.flair_url && g.flair_url[0,3] != 'fa-' }
2013-05-06 00:49:56 -04:00
AUTO_GROUPS = {
:everyone => 0,
2013-05-06 00:49:56 -04:00
:admins => 1,
:moderators => 2,
:staff => 3,
:trust_level_0 => 10,
2013-05-06 00:49:56 -04:00
:trust_level_1 => 11,
:trust_level_2 => 12,
:trust_level_3 => 13,
2014-07-09 22:17:13 -04:00
:trust_level_4 => 14
2013-05-06 00:49:56 -04:00
}
2014-07-09 22:17:13 -04:00
AUTO_GROUP_IDS = Hash[*AUTO_GROUPS.to_a.flatten.reverse]
STAFF_GROUPS = [:admins, :moderators, :staff]
2014-01-07 11:47:01 -05:00
ALIAS_LEVELS = {
:nobody => 0,
:only_admins => 1,
:mods_and_admins => 2,
:members_mods_and_admins => 3,
:everyone => 99
}
validates :alias_level, inclusion: { in: ALIAS_LEVELS.values}
2014-01-07 11:47:01 -05:00
scope :mentionable, lambda {|user|
levels = [ALIAS_LEVELS[:everyone]]
if user && user.admin?
levels = [ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:only_admins],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins]]
elsif user && user.moderator?
levels = [ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins]]
end
where("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)
)", levels: levels, user_id: user && user.id )
}
2015-12-07 06:39:28 -05:00
def downcase_incoming_email
self.incoming_email = (incoming_email || "").strip.downcase.presence
end
def incoming_email_validator
return if self.automatic || self.incoming_email.blank?
incoming_email.split("|").each do |email|
escaped = Rack::Utils.escape_html(email)
if !Email.is_valid?(email)
self.errors.add(:base, I18n.t('groups.errors.invalid_incoming_email', email: escaped))
elsif group = Group.where.not(id: self.id).find_by_email(email)
self.errors.add(:base, I18n.t('groups.errors.email_already_used_in_group', email: escaped, group_name: Rack::Utils.escape_html(group.name)))
elsif category = Category.find_by_email(email)
self.errors.add(:base, I18n.t('groups.errors.email_already_used_in_category', email: escaped, category_name: Rack::Utils.escape_html(category.name)))
end
2015-12-07 06:39:28 -05:00
end
end
def posts_for(guardian, before_post_id=nil)
user_ids = group_users.map { |gu| gu.user_id }
result = Post.includes(:user, :topic, topic: :category)
.references(:posts, :topics, :category)
.where(user_id: user_ids)
.where('topics.archetype <> ?', Archetype.private_message)
.where(post_type: Post.types[:regular])
result = guardian.filter_allowed_categories(result)
result = result.where('posts.id < ?', before_post_id) if before_post_id
result.order('posts.created_at desc')
end
def messages_for(guardian, before_post_id=nil)
result = Post.includes(:user, :topic, topic: :category)
.references(:posts, :topics, :category)
.where('topics.archetype = ?', Archetype.private_message)
.where(post_type: Post.types[:regular])
.where('topics.id IN (SELECT topic_id FROM topic_allowed_groups WHERE group_id = ?)', self.id)
result = guardian.filter_allowed_categories(result)
result = result.where('posts.id < ?', before_post_id) if before_post_id
result.order('posts.created_at desc')
end
def mentioned_posts_for(guardian, before_post_id=nil)
result = Post.joins(:group_mentions)
.includes(:user, :topic, topic: :category)
.references(:posts, :topics, :category)
.where('topics.archetype <> ?', Archetype.private_message)
.where(post_type: Post.types[:regular])
2015-12-02 00:16:19 -05:00
.where('group_mentions.group_id = ?', self.id)
result = guardian.filter_allowed_categories(result)
result = result.where('posts.id < ?', before_post_id) if before_post_id
result.order('posts.created_at desc')
end
2013-05-06 00:49:56 -04:00
def self.trust_group_ids
(10..19).to_a
end
def self.refresh_automatic_group!(name)
return unless id = AUTO_GROUPS[name]
2013-05-06 00:49:56 -04:00
unless group = self.lookup_group(name)
group = Group.new(name: name.to_s, automatic: true)
2013-05-06 00:49:56 -04:00
group.id = id
group.save!
end
# don't allow shoddy localization to break this
localized_name = I18n.t("groups.default_names.#{name}")
validator = UsernameValidator.new(localized_name)
group.name = validator.valid_format? ? localized_name : name
# the everyone group is special, it can include non-users so there is no
# way to have the membership in a table
if name == :everyone
2016-10-23 22:03:22 -04:00
group.visible = false
group.save!
return group
end
# Remove people from groups they don't belong in.
#
# BEWARE: any of these subqueries could match ALL the user records,
# so they can't be used in IN clauses.
remove_user_subquery = case name
when :admins
"SELECT u.id FROM users u WHERE NOT u.admin"
when :moderators
"SELECT u.id FROM users u WHERE NOT u.moderator"
when :staff
"SELECT u.id FROM users u WHERE NOT u.admin AND NOT u.moderator"
when :trust_level_0, :trust_level_1, :trust_level_2, :trust_level_3, :trust_level_4
"SELECT u.id FROM users u WHERE u.trust_level < #{id - 10}"
end
remove_ids = exec_sql("SELECT gu.id id
FROM group_users gu,
(#{remove_user_subquery}) u
WHERE gu.group_id = #{group.id}
AND gu.user_id = u.id").map {|x| x['id']}
if remove_ids.length > 0
remove_ids.each_slice(100) do |ids|
GroupUser.where(id: ids).delete_all
end
end
# Add people to groups
2013-05-06 00:49:56 -04:00
real_ids = case name
when :admins
"SELECT u.id FROM users u WHERE u.admin"
2013-05-06 00:49:56 -04:00
when :moderators
"SELECT u.id FROM users u WHERE u.moderator"
2013-05-06 00:49:56 -04:00
when :staff
"SELECT u.id FROM users u WHERE u.moderator OR u.admin"
2014-07-09 22:17:13 -04:00
when :trust_level_1, :trust_level_2, :trust_level_3, :trust_level_4
"SELECT u.id FROM users u WHERE u.trust_level >= #{id-10}"
when :trust_level_0
"SELECT u.id FROM users u"
2013-05-06 00:49:56 -04:00
end
2013-05-16 19:03:30 -04:00
missing_users = GroupUser
.joins("RIGHT JOIN (#{real_ids}) X ON X.id = user_id AND group_id = #{group.id}")
2013-05-06 00:49:56 -04:00
.where("user_id IS NULL")
.select("X.id")
missing_users.each do |u|
group.group_users.build(user_id: u.id)
end
group.save!
2013-05-08 01:20:38 -04:00
# we want to ensure consistency
Group.reset_counters(group.id, :group_users)
group
2013-05-06 00:49:56 -04:00
end
def self.ensure_consistency!
2016-04-04 17:41:49 -04:00
reset_all_counters!
refresh_automatic_groups!
end
2016-04-04 17:41:49 -04:00
def self.reset_all_counters!
Group.pluck(:id).each do |group_id|
Group.reset_counters(group_id, :group_users)
end
end
2013-05-06 00:49:56 -04:00
def self.refresh_automatic_groups!(*args)
2013-05-08 01:20:38 -04:00
if args.length == 0
args = AUTO_GROUPS.keys
2013-05-08 01:20:38 -04:00
end
2013-05-06 00:49:56 -04:00
args.each do |group|
refresh_automatic_group!(group)
end
end
def self.ensure_automatic_groups!
AUTO_GROUPS.each_key do |name|
refresh_automatic_group!(name) unless lookup_group(name)
end
end
2013-05-06 00:49:56 -04:00
def self.[](name)
2013-05-16 19:03:30 -04:00
lookup_group(name) || refresh_automatic_group!(name)
end
2013-05-06 00:49:56 -04:00
def self.search_group(name)
Group.where(visible: true).where("name ILIKE :term_like", term_like: "#{name}%")
end
def self.lookup_group(name)
2013-11-22 13:18:45 -05:00
if id = AUTO_GROUPS[name]
Group.find_by(id: id)
else
unless group = Group.find_by(name: name)
2013-11-22 13:18:45 -05:00
raise ArgumentError, "unknown group"
end
group
end
2013-05-06 00:49:56 -04:00
end
def self.lookup_group_ids(opts)
if group_ids = opts[:group_ids]
group_ids = group_ids.split(",").map(&:to_i)
group_ids = Group.where(id: group_ids).pluck(:id)
end
group_ids ||= []
if group_names = opts[:group_names]
group_names = group_names.split(",")
if group_names.present?
group_ids += Group.where(name: group_names).pluck(:id)
end
end
group_ids
end
def self.desired_trust_level_groups(trust_level)
trust_group_ids.keep_if do |id|
id == AUTO_GROUPS[:trust_level_0] || (trust_level + 10) >= id
end
end
2013-05-06 00:49:56 -04:00
def self.user_trust_level_change!(user_id, trust_level)
desired = desired_trust_level_groups(trust_level)
undesired = trust_group_ids - desired
2013-05-06 00:49:56 -04:00
GroupUser.where(group_id: undesired, user_id: user_id).delete_all
2013-05-06 00:49:56 -04:00
desired.each do |id|
if group = find_by(id: id)
unless GroupUser.where(group_id: id, user_id: user_id).exists?
group.group_users.create!(user_id: user_id)
end
else
name = AUTO_GROUP_IDS[trust_level]
refresh_automatic_group!(name)
end
2013-05-06 00:49:56 -04:00
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 = []
2014-03-27 03:00:23 -04:00
group_users.each 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
2014-08-18 07:04:08 -04:00
def remove(user)
self.group_users.where(user: user).each(&:destroy)
user.update_columns(primary_group_id: nil) if user.primary_group_id == self.id
end
def add_owner(user)
if group_user = self.group_users.find_by(user: user)
group_user.update_attributes!(owner: true) if !group_user.owner
else
GroupUser.create!(user: user, group: self, owner: true)
end
end
def self.find_by_email(email)
self.where("string_to_array(incoming_email, '|') @> ARRAY[?]", Email.downcase(email)).first
end
def bulk_add(user_ids)
if user_ids.present?
Group.exec_sql("INSERT INTO group_users
(group_id, user_id, created_at, updated_at)
SELECT #{self.id},
u.id,
CURRENT_TIMESTAMP,
CURRENT_TIMESTAMP
FROM users AS u
WHERE u.id IN (#{user_ids.join(', ')})
AND NOT EXISTS(SELECT 1 FROM group_users AS gu
WHERE gu.user_id = u.id AND
gu.group_id = #{self.id})")
if self.primary_group?
User.where(id: user_ids).update_all(primary_group_id: self.id)
end
if self.title.present?
User.where(id: user_ids).update_all(title: self.title)
end
end
true
end
def staff?
STAFF_GROUPS.include?(self.name.to_sym)
end
protected
2014-08-18 07:04:08 -04:00
def name_format_validator
UsernameValidator.perform_validation(self, 'name')
end
def automatic_membership_email_domains_format_validator
return if self.automatic_membership_email_domains.blank?
domains = self.automatic_membership_email_domains.split("|")
domains.each do |domain|
domain.sub!(/^https?:\/\//, '')
domain.sub!(/\/.*$/, '')
2016-04-08 12:11:58 -04:00
self.errors.add :base, (I18n.t('groups.errors.invalid_domain', domain: domain)) unless domain =~ /\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,24}(:[0-9]{1,5})?(\/.*)?\Z/i
end
self.automatic_membership_email_domains = domains.join("|")
end
2014-08-18 07:04:08 -04:00
# hack around AR
def destroy_deletions
if @deletions
@deletions.each do |gu|
gu.destroy
User.where('id = ? AND primary_group_id = ?', gu.user_id, gu.group_id).update_all 'primary_group_id = NULL'
end
end
2014-08-18 07:04:08 -04:00
@deletions = nil
end
def automatic_group_membership
if self.automatic_membership_retroactive
Jobs.enqueue(:automatic_group_membership, group_id: self.id)
end
end
def update_title
return if new_record? && !self.title.present?
if self.title_changed?
sql = <<SQL
UPDATE users SET title = :title
WHERE (title = :title_was OR
title = '' OR
title IS NULL) AND
COALESCE(title,'') <> COALESCE(:title,'') AND
id IN (
SELECT user_id
FROM group_users
WHERE group_id = :id
)
SQL
self.class.exec_sql(sql,
title: title,
title_was: title_was,
id: id
)
end
end
def update_primary_group
return if new_record? && !self.primary_group?
if self.primary_group_changed?
sql = <<SQL
UPDATE users
/*set*/
/*where*/
SQL
builder = SqlBuilder.new(sql)
builder.where("
id IN (
SELECT user_id
FROM group_users
WHERE group_id = :id
)", id: id)
if primary_group
builder.set("primary_group_id = :id")
else
builder.set("primary_group_id = NULL")
builder.where("primary_group_id = :id")
end
builder.exec
end
end
end
# == Schema Information
#
# Table name: groups
#
2015-02-03 23:09:00 -05:00
# id :integer not null, primary key
2016-02-22 18:33:53 -05:00
# name :string not null
2015-02-03 23:09:00 -05:00
# 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)
# visible :boolean default(TRUE), not null
# automatic_membership_email_domains :text
# automatic_membership_retroactive :boolean default(FALSE)
2015-09-17 20:41:10 -04:00
# primary_group :boolean default(FALSE), not null
2016-02-22 18:33:53 -05:00
# title :string
# grant_trust_level :integer
2016-01-11 01:30:56 -05:00
# incoming_email :string
# has_messages :boolean default(FALSE), not null
2016-10-31 05:32:11 -04:00
# flair_url :string
# flair_bg_color :string
# flair_color :string
#
# Indexes
#
2016-01-11 01:30:56 -05:00
# index_groups_on_incoming_email (incoming_email) UNIQUE
# index_groups_on_name (name) UNIQUE
#