Class: Group
Defined Under Namespace
Classes: GroupPmUserLimitExceededError
Constant Summary
collapse
- AUTO_GROUPS =
{
everyone: 0,
admins: 1,
moderators: 2,
staff: 3,
trust_level_0: 10,
trust_level_1: 11,
trust_level_2: 12,
trust_level_3: 13,
trust_level_4: 14,
}
- AUTO_GROUP_IDS =
- STAFF_GROUPS =
%i[admins moderators staff]
- AUTO_GROUPS_ADD =
"add"
- AUTO_GROUPS_REMOVE =
"remove"
- IMAP_SETTING_ATTRIBUTES =
%w[
imap_server
imap_port
imap_ssl
imap_mailbox_name
email_username
email_password
]
- SMTP_SETTING_ATTRIBUTES =
%w[
imap_server
imap_port
imap_ssl
email_username
email_password
email_from_alias
]
- ALIAS_LEVELS =
{
nobody: 0,
only_admins: 1,
mods_and_admins: 2,
members_mods_and_admins: 3,
owners_mods_and_admins: 4,
everyone: 99,
}
- VALID_DOMAIN_REGEX =
/\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,24}(:[0-9]{1,5})?(\/.*)?\Z/i
- PUBLISH_CATEGORIES_LIMIT =
10
HasCustomFields::CUSTOM_FIELDS_MAX_ITEMS, HasCustomFields::DEFAULT_FIELD_DESCRIPTOR
Instance Attribute Summary
#preloaded_custom_fields
Class Method Summary
collapse
-
.[](name) ⇒ Object
-
.alias_levels(user) ⇒ Object
-
.auto_groups_between(lower, upper) ⇒ Object
-
.builtin ⇒ Object
-
.desired_trust_level_groups(trust_level) ⇒ Object
-
.ensure_automatic_groups! ⇒ Object
-
.ensure_consistency! ⇒ Object
-
.find_by_email(email) ⇒ Object
-
.group_id_from_param(group_param) ⇒ Object
given something that might be a group name, id, or record, return the group id.
-
.lookup_group(name) ⇒ Object
-
.lookup_groups(group_ids: [], group_names: []) ⇒ Object
-
.member_of(groups, user) ⇒ Object
-
.mentionable_sql_clause(include_public: true) ⇒ Object
-
.owner_of(groups, user) ⇒ Object
-
.refresh_automatic_group!(name) ⇒ Object
-
.refresh_automatic_groups!(*args) ⇒ Object
-
.refresh_has_messages! ⇒ Object
-
.reset_all_counters! ⇒ Object
-
.reset_user_count(group) ⇒ Object
-
.search_groups(name, groups: nil, custom_scope: {}, sort: :none) ⇒ Object
-
.set_category_and_tag_default_notification_levels!(user, group_name) ⇒ Object
-
.smtp_ssl_modes ⇒ Object
-
.trust_group_ids ⇒ Object
-
.user_trust_level_change!(user_id, trust_level) ⇒ Object
-
.visibility_levels ⇒ Object
Instance Method Summary
collapse
Methods included from GlobalPath
#cdn_path, #cdn_relative_path, #full_cdn_url, #path, #upload_cdn_path
#enqueue_destroyed_web_hook
#clear_custom_fields, #create_singular, #custom_field_preloaded?, #custom_fields, #custom_fields=, #custom_fields_clean?, #custom_fields_fk, #custom_fields_preloaded?, #on_custom_fields_change, #reload, #save_custom_fields, #set_preloaded_custom_fields, #upsert_custom_fields
Class Method Details
.[](name) ⇒ Object
673
674
675
|
# File 'app/models/group.rb', line 673
def self.[](name)
lookup_group(name) || refresh_automatic_group!(name)
end
|
.alias_levels(user) ⇒ Object
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
|
# File 'app/models/group.rb', line 318
def self.alias_levels(user)
if user&.admin?
[
ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:only_admins],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins],
ALIAS_LEVELS[:owners_mods_and_admins],
]
elsif user&.moderator?
[
ALIAS_LEVELS[:everyone],
ALIAS_LEVELS[:mods_and_admins],
ALIAS_LEVELS[:members_mods_and_admins],
ALIAS_LEVELS[:owners_mods_and_admins],
]
else
[ALIAS_LEVELS[:everyone]]
end
end
|
.auto_groups_between(lower, upper) ⇒ Object
147
148
149
150
151
152
153
154
|
# File 'app/models/group.rb', line 147
def self.auto_groups_between(lower, upper)
lower_group = Group::AUTO_GROUPS[lower.to_sym]
upper_group = Group::AUTO_GROUPS[upper.to_sym]
return [] if lower_group.blank? || upper_group.blank?
(lower_group..upper_group).to_a & AUTO_GROUPS.values
end
|
.builtin ⇒ Object
758
759
760
|
# File 'app/models/group.rb', line 758
def self.builtin
Enum.new(:moderators, :admins, :trust_level_1, :trust_level_2)
end
|
.desired_trust_level_groups(trust_level) ⇒ Object
726
727
728
|
# File 'app/models/group.rb', line 726
def self.desired_trust_level_groups(trust_level)
trust_group_ids.keep_if { |id| id == AUTO_GROUPS[:trust_level_0] || (trust_level + 10) >= id }
end
|
.ensure_automatic_groups! ⇒ Object
669
670
671
|
# File 'app/models/group.rb', line 669
def self.ensure_automatic_groups!
AUTO_GROUPS.each_key { |name| refresh_automatic_group!(name) unless lookup_group(name) }
end
|
.ensure_consistency! ⇒ Object
612
613
614
615
616
|
# File 'app/models/group.rb', line 612
def self.ensure_consistency!
reset_all_counters!
refresh_automatic_groups!
refresh_has_messages!
end
|
.find_by_email(email) ⇒ Object
861
862
863
864
865
866
867
868
|
# File 'app/models/group.rb', line 861
def self.find_by_email(email)
self.where(
"email_username = :email OR
string_to_array(incoming_email, '|') @> ARRAY[:email] OR
email_from_alias = :email",
email: Email.downcase(email),
).first
end
|
.group_id_from_param(group_param) ⇒ Object
given something that might be a group name, id, or record, return the group id
750
751
752
753
754
755
756
|
# File 'app/models/group.rb', line 750
def self.group_id_from_param(group_param)
return group_param.id if group_param.is_a?(Group)
return group_param if group_param.is_a?(Integer)
Group[group_param.to_sym].id
end
|
.lookup_group(name) ⇒ Object
700
701
702
703
704
705
706
707
708
709
|
# File 'app/models/group.rb', line 700
def self.lookup_group(name)
if id = AUTO_GROUPS[name]
Group.find_by(id: id)
else
unless group = Group.find_by(name: name)
raise ArgumentError, "unknown group"
end
group
end
end
|
.lookup_groups(group_ids: [], group_names: []) ⇒ Object
711
712
713
714
715
716
717
718
719
720
721
722
723
724
|
# File 'app/models/group.rb', line 711
def self.lookup_groups(group_ids: [], group_names: [])
if group_ids.present?
group_ids = group_ids.to_s.split(",") if !group_ids.is_a?(Array)
group_ids.map!(&:to_i)
groups = Group.where(id: group_ids) if group_ids.present?
end
if group_names.present?
group_names = group_names.split(",")
groups = (groups || Group).where(name: group_names) if group_names.present?
end
groups || []
end
|
.member_of(groups, user) ⇒ Object
956
957
958
959
960
961
|
# File 'app/models/group.rb', line 956
def self.member_of(groups, user)
groups.joins("LEFT JOIN group_users gu ON gu.group_id = groups.id ").where(
"gu.user_id = ?",
user.id,
)
end
|
.mentionable_sql_clause(include_public: true) ⇒ Object
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
# File 'app/models/group.rb', line 299
def self.mentionable_sql_clause(include_public: true)
clause = +<<~SQL
groups.mentionable_level in (:levels)
OR (
groups.mentionable_level = #{ALIAS_LEVELS[:members_mods_and_admins]}
AND groups.id in (
SELECT group_id FROM group_users WHERE user_id = :user_id)
) OR (
groups.mentionable_level = #{ALIAS_LEVELS[:owners_mods_and_admins]}
AND groups.id in (
SELECT group_id FROM group_users WHERE user_id = :user_id AND owner IS TRUE)
)
SQL
clause << "OR visibility_level = #{Group.visibility_levels[:public]}" if include_public
clause
end
|
.owner_of(groups, user) ⇒ Object
963
964
965
|
# File 'app/models/group.rb', line 963
def self.owner_of(groups, user)
self.member_of(groups, user).where("gu.owner")
end
|
.refresh_automatic_group!(name) ⇒ Object
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
|
# File 'app/models/group.rb', line 505
def self.refresh_automatic_group!(name)
return unless id = AUTO_GROUPS[name]
unless group = self.lookup_group(name)
group = Group.new(name: name.to_s, automatic: true)
if AUTO_GROUPS[:moderators] == id
group.default_notification_level = 2
group.messageable_level = ALIAS_LEVELS[:everyone]
end
group.id = id
group.save!
end
localized_name = I18n.t("groups.default_names.#{name}", locale: SiteSetting.default_locale)
validator = UsernameValidator.new(localized_name)
group.name = localized_name if validator.valid_format? && !User.username_exists?(localized_name)
case name
when :everyone
group.visibility_level = Group.visibility_levels[:staff]
group.save!
return group
when :moderators
group.update!(messageable_level: ALIAS_LEVELS[:everyone])
end
if group.visibility_level == Group.visibility_levels[:public]
group.update!(visibility_level: Group.visibility_levels[:logged_on_users])
end
remove_subquery =
case name
when :admins
"SELECT id FROM users WHERE NOT admin OR staged"
when :moderators
"SELECT id FROM users WHERE NOT moderator OR staged"
when :staff
"SELECT id FROM users WHERE (NOT admin AND NOT moderator) OR staged"
when :trust_level_0, :trust_level_1, :trust_level_2, :trust_level_3, :trust_level_4
"SELECT id FROM users WHERE trust_level < #{id - 10} OR staged"
end
removed_user_ids = DB.query_single <<-SQL
DELETE FROM group_users
USING (#{remove_subquery}) X
WHERE group_id = #{group.id}
AND user_id = X.id
RETURNING group_users.user_id
SQL
if removed_user_ids.present?
Jobs.enqueue(
:publish_group_membership_updates,
user_ids: removed_user_ids,
group_id: group.id,
type: AUTO_GROUPS_REMOVE,
)
end
insert_subquery =
case name
when :admins
"SELECT id FROM users WHERE admin AND NOT staged"
when :moderators
"SELECT id FROM users WHERE moderator AND NOT staged"
when :staff
"SELECT id FROM users WHERE (moderator OR admin) AND NOT staged"
when :trust_level_1, :trust_level_2, :trust_level_3, :trust_level_4
"SELECT id FROM users WHERE trust_level >= #{id - 10} AND NOT staged"
when :trust_level_0
"SELECT id FROM users WHERE NOT staged"
end
added_user_ids = DB.query_single <<-SQL
INSERT INTO group_users (group_id, user_id, created_at, updated_at)
SELECT #{group.id}, X.id, now(), now()
FROM group_users
RIGHT JOIN (#{insert_subquery}) X ON X.id = user_id AND group_id = #{group.id}
WHERE user_id IS NULL
RETURNING group_users.user_id
SQL
group.save!
if added_user_ids.present?
Jobs.enqueue(
:publish_group_membership_updates,
user_ids: added_user_ids,
group_id: group.id,
type: AUTO_GROUPS_ADD,
)
end
Group.reset_user_count(group)
group
end
|
.refresh_automatic_groups!(*args) ⇒ Object
652
653
654
655
|
# File 'app/models/group.rb', line 652
def self.refresh_automatic_groups!(*args)
args = AUTO_GROUPS.keys if args.empty?
args.each { |group| refresh_automatic_group!(group) }
end
|
.refresh_has_messages! ⇒ Object
657
658
659
660
661
662
663
664
665
666
667
|
# File 'app/models/group.rb', line 657
def self.refresh_has_messages!
DB.exec <<-SQL
UPDATE groups g SET has_messages = false
WHERE NOT EXISTS (SELECT tg.id
FROM topic_allowed_groups tg
INNER JOIN topics t ON t.id = tg.topic_id
WHERE tg.group_id = g.id
AND t.deleted_at IS NULL)
AND g.has_messages = true
SQL
end
|
.reset_all_counters! ⇒ Object
622
623
624
|
# File 'app/models/group.rb', line 622
def self.reset_all_counters!
reset_groups_user_count!
end
|
.reset_user_count(group) ⇒ Object
618
619
620
|
# File 'app/models/group.rb', line 618
def self.reset_user_count(group)
reset_groups_user_count!(only_group_ids: [group.id])
end
|
.search_groups(name, groups: nil, custom_scope: {}, sort: :none) ⇒ Object
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
|
# File 'app/models/group.rb', line 677
def self.search_groups(name, groups: nil, custom_scope: {}, sort: :none)
groups ||= Group
relation =
groups.where(
"groups.name ILIKE :term_like OR groups.full_name ILIKE :term_like",
term_like: "%#{name}%",
)
if sort == :auto
prefix = "#{name.gsub("_", "\\_")}%"
relation =
relation.reorder(
DB.sql_fragment(
"CASE WHEN groups.name ILIKE :like OR groups.full_name ILIKE :like THEN 0 ELSE 1 END ASC, groups.name ASC",
like: prefix,
),
)
end
relation
end
|
.set_category_and_tag_default_notification_levels!(user, group_name) ⇒ Object
498
499
500
501
502
503
|
# File 'app/models/group.rb', line 498
def self.set_category_and_tag_default_notification_levels!(user, group_name)
if group = lookup_group(group_name)
GroupUser.set_category_notifications(group, user)
GroupUser.set_tag_notifications(group, user)
end
end
|
.smtp_ssl_modes ⇒ Object
143
144
145
|
# File 'app/models/group.rb', line 143
def self.smtp_ssl_modes
@visibility_levels = Enum.new(none: 0, ssl_tls: 1, starttls: 2)
end
|
.trust_group_ids ⇒ Object
456
457
458
|
# File 'app/models/group.rb', line 456
def self.trust_group_ids
Group.auto_groups_between(:trust_level_0, :trust_level_4).to_a
end
|
.user_trust_level_change!(user_id, trust_level) ⇒ Object
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
|
# File 'app/models/group.rb', line 730
def self.user_trust_level_change!(user_id, trust_level)
desired = desired_trust_level_groups(trust_level)
undesired = trust_group_ids - desired
GroupUser.where(group_id: undesired, user_id: user_id).delete_all
desired.each do |id|
if group = find_by(id: id)
unless GroupUser.where(group_id: id, user_id: user_id).exists?
group_user = group.group_users.create!(user_id: user_id)
group.trigger_user_added_event(group_user.user, true)
end
else
name = AUTO_GROUP_IDS[trust_level]
refresh_automatic_group!(name)
end
end
end
|
.visibility_levels ⇒ Object
139
140
141
|
# File 'app/models/group.rb', line 139
def self.visibility_levels
@visibility_levels = Enum.new(public: 0, logged_on_users: 1, members: 2, staff: 3, owners: 4)
end
|
Instance Method Details
#add(user, notify: false, automatic: false) ⇒ Object
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
|
# File 'app/models/group.rb', line 792
def add(user, notify: false, automatic: false)
return self if self.users.include?(user)
self.users.push(user)
if notify
Notification.create!(
notification_type: Notification.types[:membership_request_accepted],
user_id: user.id,
data: { group_id: id, group_name: name }.to_json,
)
end
if self.categories.count < PUBLISH_CATEGORIES_LIMIT
MessageBus.publish(
"/categories",
{ categories: ActiveModel::ArraySerializer.new(self.categories).as_json },
user_ids: [user.id],
)
else
Discourse.request_refresh!(user_ids: [user.id])
end
trigger_user_added_event(user, automatic)
self
end
|
#add_automatically(user, subject: nil) ⇒ Object
938
939
940
941
942
943
|
# File 'app/models/group.rb', line 938
def add_automatically(user, subject: nil)
if users.exclude?(user) && add(user)
logger = GroupActionLogger.new(Discourse.system_user, self)
logger.log_add_user_to_group(user, subject)
end
end
|
#add_owner(user) ⇒ Object
853
854
855
856
857
858
859
|
# File 'app/models/group.rb', line 853
def add_owner(user)
if group_user = self.group_users.find_by(user: user)
group_user.update!(owner: true) if !group_user.owner
else
self.group_users.create!(user: user, owner: true)
end
end
|
#bulk_add(user_ids) ⇒ Object
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
|
# File 'app/models/group.rb', line 870
def bulk_add(user_ids)
return if user_ids.blank?
Group.transaction do
sql = <<~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)
AND NOT EXISTS (
SELECT 1 FROM group_users AS gu
WHERE gu.user_id = u.id AND
gu.group_id = :group_id
)
SQL
DB.exec(sql, group_id: self.id, user_ids: user_ids)
user_attributes = {}
user_attributes[:primary_group_id] = self.id if self.primary_group?
user_attributes[:title] = self.title if self.title.present?
User.where(id: user_ids).update_all(user_attributes) if user_attributes.present?
recalculate_user_count
end
if self.grant_trust_level.present?
Jobs.enqueue(:bulk_grant_trust_level, user_ids: user_ids, trust_level: self.grant_trust_level)
end
self
end
|
#bulk_remove(user_ids) ⇒ Object
912
913
914
915
916
917
918
919
920
921
922
923
924
|
# File 'app/models/group.rb', line 912
def bulk_remove(user_ids)
Group.transaction do
group_users_to_be_destroyed = group_users.includes(:user).where(user_id: user_ids).destroy_all
group_users_to_be_destroyed.each do |group_user|
trigger_user_removed_event(group_user.user)
enqueue_user_removed_from_group_webhook_events(group_user)
end
end
recalculate_user_count
true
end
|
#cache_group_users_for_destroyed_event ⇒ Object
967
968
969
|
# File 'app/models/group.rb', line 967
def cache_group_users_for_destroyed_event
@cached_group_user_ids = group_users.pluck(:user_id)
end
|
#cook_bio ⇒ Object
347
348
349
350
351
352
353
|
# File 'app/models/group.rb', line 347
def cook_bio
if self.bio_raw.present?
self.bio_cooked = PrettyText.cook(self.bio_raw)
else
self.bio_cooked = nil
end
end
|
#downcase_incoming_email ⇒ Object
343
344
345
|
# File 'app/models/group.rb', line 343
def downcase_incoming_email
self.incoming_email = (incoming_email || "").strip.downcase.presence
end
|
#email_username_domain ⇒ Object
1062
1063
1064
|
# File 'app/models/group.rb', line 1062
def email_username_domain
email_username.split("@").last
end
|
#email_username_regex ⇒ Object
1070
1071
1072
1073
1074
1075
1076
|
# File 'app/models/group.rb', line 1070
def email_username_regex
user = email_username_user
domain = email_username_domain
if user.present? && domain.present?
/\A#{Regexp.escape(user)}(\+[^@]*)?@#{Regexp.escape(domain)}\z/i
end
end
|
#email_username_user ⇒ Object
1066
1067
1068
|
# File 'app/models/group.rb', line 1066
def email_username_user
email_username.split("@").first
end
|
#enqueue_user_removed_from_group_webhook_events(group_user) ⇒ Object
#expire_imap_mailbox_cache ⇒ Object
77
78
79
|
# File 'app/models/group.rb', line 77
def expire_imap_mailbox_cache
Discourse.cache.delete("group_imap_mailboxes_#{self.id}")
end
|
#flair_type ⇒ Object
983
984
985
986
987
988
989
|
# File 'app/models/group.rb', line 983
def flair_type
if flair_icon.present?
:icon
elsif flair_upload.present?
:image
end
end
|
#flair_url ⇒ Object
991
992
993
994
995
996
997
|
# File 'app/models/group.rb', line 991
def flair_url
if flair_type == :icon
flair_icon
elsif flair_type == :image
upload_cdn_path(flair_upload.url)
end
end
|
#imap_config ⇒ Object
1052
1053
1054
1055
1056
1057
1058
1059
1060
|
# File 'app/models/group.rb', line 1052
def imap_config
{
server: self.imap_server,
port: self.imap_port,
ssl: self.imap_ssl,
username: self.email_username,
password: self.email_password,
}
end
|
#imap_mailboxes ⇒ Object
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
|
# File 'app/models/group.rb', line 1025
def imap_mailboxes
return [] if !self.imap_enabled || !SiteSetting.enable_imap
Discourse
.cache
.fetch("group_imap_mailboxes_#{self.id}", expires_in: 30.minutes) do
Rails.logger.info("[IMAP] Refreshing mailboxes list for group #{self.name}")
mailboxes = []
begin
imap_provider = Imap::Providers::Detector.init_with_detected_provider(self.imap_config)
imap_provider.connect!
mailboxes = imap_provider.filter_mailboxes(imap_provider.list_mailboxes_with_attributes)
imap_provider.disconnect!
update_columns(imap_last_error: nil)
rescue => ex
Rails.logger.warn(
"[IMAP] Mailbox refresh failed for group #{self.name} with error: #{ex}",
)
update_columns(imap_last_error: ex.message)
end
mailboxes
end
end
|
#incoming_email_validator ⇒ Object
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
|
# File 'app/models/group.rb', line 382
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
end
end
|
#mentioned_posts_for(guardian, opts = nil) ⇒ Object
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
|
# File 'app/models/group.rb', line 435
def mentioned_posts_for(guardian, opts = nil)
opts ||= {}
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])
.where("group_mentions.group_id = ?", self.id)
if opts[:category_id].present?
result = result.where("topics.category_id = ?", opts[:category_id].to_i)
end
result = guardian.filter_allowed_categories(result)
result = result.where("posts.id < ?", opts[:before_post_id].to_i) if opts[:before_post_id]
result = result.where("posts.created_at < ?", opts[:before].to_datetime) if opts[:before]
result.order("posts.created_at desc")
end
|
#message_count ⇒ Object
1091
1092
1093
1094
|
# File 'app/models/group.rb', line 1091
def message_count
return 0 unless self.has_messages
TopicAllowedGroup.where(group_id: self.id).joins(:topic).count
end
|
#name_full_preferred ⇒ Object
1087
1088
1089
|
# File 'app/models/group.rb', line 1087
def name_full_preferred
self.full_name.presence || self.name
end
|
#notify_added_to_group(user, owner: false) ⇒ Object
1078
1079
1080
1081
1082
1083
1084
1085
|
# File 'app/models/group.rb', line 1078
def notify_added_to_group(user, owner: false)
SystemMessage.create_from_system_user(
user,
owner ? :user_added_to_group_as_owner : :user_added_to_group_as_member,
group_name: name_full_preferred,
group_path: "/g/#{self.name}",
)
end
|
#posts_for(guardian, opts = nil) ⇒ Object
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
|
# File 'app/models/group.rb', line 413
def posts_for(guardian, opts = nil)
opts ||= {}
result =
Post
.joins(:topic, user: :groups, topic: :category)
.preload(:topic, user: :groups, topic: :category)
.references(:posts, :topics, :category)
.where(groups: { id: id })
.where("topics.archetype <> ?", Archetype.private_message)
.where("topics.visible")
.where(post_type: [Post.types[:regular], Post.types[:moderator_action]])
if opts[:category_id].present?
result = result.where("topics.category_id = ?", opts[:category_id].to_i)
end
result = guardian.filter_allowed_categories(result)
result = result.where("posts.id < ?", opts[:before_post_id].to_i) if opts[:before_post_id]
result = result.where("posts.created_at < ?", opts[:before].to_datetime) if opts[:before]
result.order("posts.created_at desc")
end
|
#recalculate_user_count ⇒ Object
926
927
928
929
930
931
932
933
934
935
936
|
# File 'app/models/group.rb', line 926
def recalculate_user_count
DB.exec <<~SQL
UPDATE groups g
SET user_count =
(SELECT COUNT(gu.user_id)
FROM group_users gu
WHERE gu.group_id = g.id
AND gu.user_id > 0)
WHERE g.id = #{self.id};
SQL
end
|
#record_email_setting_changes!(user) ⇒ Object
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
|
# File 'app/models/group.rb', line 355
def record_email_setting_changes!(user)
if (self.previous_changes.keys & IMAP_SETTING_ATTRIBUTES).any?
self.imap_updated_at = Time.zone.now
self.imap_updated_by_id = user.id
end
if (self.previous_changes.keys & SMTP_SETTING_ATTRIBUTES).any?
self.smtp_updated_at = Time.zone.now
self.smtp_updated_by_id = user.id
end
self.smtp_enabled = [
self.smtp_port,
self.smtp_server,
self.email_password,
self.email_username,
].all?(&:present?)
self.imap_enabled = [
self.imap_port,
self.imap_server,
self.email_password,
self.email_username,
].all?(&:present?)
self.save
end
|
#remove(user) ⇒ Object
820
821
822
823
824
825
826
827
828
829
|
# File 'app/models/group.rb', line 820
def remove(user)
group_user = self.group_users.find_by(user: user)
return false if group_user.blank?
group_user.destroy
trigger_user_removed_event(user)
enqueue_user_removed_from_group_webhook_events(group_user)
true
end
|
#remove_automatically(user, subject: nil) ⇒ Object
945
946
947
948
949
950
|
# File 'app/models/group.rb', line 945
def remove_automatically(user, subject: nil)
if users.include?(user) && remove(user)
logger = GroupActionLogger.new(Discourse.system_user, self)
logger.log_remove_user_from_group(user, subject)
end
end
|
#set_default_notifications ⇒ Object
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
|
# File 'app/models/group.rb', line 1011
def set_default_notifications
if @category_notifications
@category_notifications.each do |level, category_ids|
GroupCategoryNotificationDefault.batch_set(self, level, category_ids)
end
end
if @tag_notifications
@tag_notifications.each do |level, tag_names|
GroupTagNotificationDefault.batch_set(self, level, tag_names)
end
end
end
|
#set_message_default_notification_levels!(topic, ignore_existing: false) ⇒ Object
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
|
# File 'app/models/group.rb', line 463
def set_message_default_notification_levels!(topic, ignore_existing: false)
if user_count > SiteSetting.group_pm_user_limit
raise GroupPmUserLimitExceededError,
I18n.t(
"groups.errors.default_notification_level_users_limit",
count: SiteSetting.group_pm_user_limit,
group_name: name,
)
end
group_users
.pluck(:user_id, :notification_level)
.each do |user_id, notification_level|
next if user_id == Discourse::SYSTEM_USER_ID
next if user_id == topic.user_id
next if ignore_existing && TopicUser.where(user_id: user_id, topic_id: topic.id).exists?
action =
case notification_level
when TopicUser.notification_levels[:tracking]
"track!"
when TopicUser.notification_levels[:regular]
"regular!"
when TopicUser.notification_levels[:muted]
"mute!"
when TopicUser.notification_levels[:watching]
"watch!"
else
"track!"
end
topic.notifier.public_send(action, user_id)
end
end
|
#smtp_from_address ⇒ Object
339
340
341
|
# File 'app/models/group.rb', line 339
def smtp_from_address
self.email_from_alias.present? ? self.email_from_alias : self.email_username
end
|
#staff? ⇒ Boolean
952
953
954
|
# File 'app/models/group.rb', line 952
def staff?
STAFF_GROUPS.include?(self.name.to_sym)
end
|
#trigger_group_destroyed_event ⇒ Object
978
979
980
981
|
# File 'app/models/group.rb', line 978
def trigger_group_destroyed_event
DiscourseEvent.trigger(:group_destroyed, self, @cached_group_user_ids)
true
end
|
#trigger_user_added_event(user, automatic) ⇒ Object
845
846
847
|
# File 'app/models/group.rb', line 845
def trigger_user_added_event(user, automatic)
DiscourseEvent.trigger(:user_added_to_group, user, self, automatic: automatic)
end
|
#trigger_user_removed_event(user) ⇒ Object
849
850
851
|
# File 'app/models/group.rb', line 849
def trigger_user_removed_event(user)
DiscourseEvent.trigger(:user_removed_from_group, user, self)
end
|
#usernames ⇒ Object
786
787
788
|
# File 'app/models/group.rb', line 786
def usernames
users.pluck(:username).join(",")
end
|
#usernames=(val) ⇒ Object
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
|
# File 'app/models/group.rb', line 762
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.each { |gu| @deletions << gu if deletions.include?(gu.user_id) }
additions.each { |a| group_users.build(user_id: map[a]) }
end
|