2234 lines
65 KiB
Ruby
2234 lines
65 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
class User < ActiveRecord::Base
|
|
include Searchable
|
|
include Roleable
|
|
include HasCustomFields
|
|
include SecondFactorManager
|
|
include HasDestroyedWebHook
|
|
|
|
DEFAULT_FEATURED_BADGE_COUNT = 3
|
|
|
|
# not deleted on user delete
|
|
has_many :posts
|
|
has_many :topics
|
|
has_many :uploads
|
|
|
|
has_many :category_users, dependent: :destroy
|
|
has_many :tag_users, dependent: :destroy
|
|
has_many :user_api_keys, dependent: :destroy
|
|
has_many :topic_allowed_users, dependent: :destroy
|
|
has_many :user_archived_messages, dependent: :destroy
|
|
has_many :email_change_requests, dependent: :destroy
|
|
has_many :email_tokens, dependent: :destroy
|
|
has_many :topic_links, dependent: :destroy
|
|
has_many :user_uploads, dependent: :destroy
|
|
has_many :upload_references, as: :target, dependent: :destroy
|
|
has_many :user_emails, dependent: :destroy, autosave: true
|
|
has_many :user_associated_accounts, dependent: :destroy
|
|
has_many :oauth2_user_infos, dependent: :destroy
|
|
has_many :user_second_factors, dependent: :destroy
|
|
has_many :user_badges, -> { for_enabled_badges }, dependent: :destroy
|
|
has_many :user_auth_tokens, dependent: :destroy
|
|
has_many :group_users, dependent: :destroy
|
|
has_many :user_warnings, dependent: :destroy
|
|
has_many :api_keys, dependent: :destroy
|
|
has_many :push_subscriptions, dependent: :destroy
|
|
has_many :acting_group_histories,
|
|
dependent: :destroy,
|
|
foreign_key: :acting_user_id,
|
|
class_name: "GroupHistory"
|
|
has_many :targeted_group_histories,
|
|
dependent: :destroy,
|
|
foreign_key: :target_user_id,
|
|
class_name: "GroupHistory"
|
|
has_many :reviewable_scores, dependent: :destroy
|
|
has_many :invites, foreign_key: :invited_by_id, dependent: :destroy
|
|
has_many :user_custom_fields, dependent: :destroy
|
|
has_many :user_associated_groups, dependent: :destroy
|
|
has_many :pending_posts,
|
|
-> { merge(Reviewable.pending) },
|
|
class_name: "ReviewableQueuedPost",
|
|
foreign_key: :created_by_id
|
|
|
|
has_one :user_option, dependent: :destroy
|
|
has_one :user_avatar, dependent: :destroy
|
|
has_one :primary_email,
|
|
-> { where(primary: true) },
|
|
class_name: "UserEmail",
|
|
dependent: :destroy,
|
|
autosave: true,
|
|
validate: false
|
|
has_one :user_stat, dependent: :destroy
|
|
has_one :user_profile, dependent: :destroy, inverse_of: :user
|
|
has_one :single_sign_on_record, dependent: :destroy
|
|
has_one :anonymous_user_master, class_name: "AnonymousUser", dependent: :destroy
|
|
has_one :anonymous_user_shadow,
|
|
->(record) { where(active: true) },
|
|
foreign_key: :master_user_id,
|
|
class_name: "AnonymousUser",
|
|
dependent: :destroy
|
|
has_one :invited_user, dependent: :destroy
|
|
has_one :user_notification_schedule, dependent: :destroy
|
|
|
|
# delete all is faster but bypasses callbacks
|
|
has_many :bookmarks, dependent: :delete_all
|
|
has_many :notifications, dependent: :delete_all
|
|
has_many :topic_users, dependent: :delete_all
|
|
has_many :incoming_emails, dependent: :delete_all
|
|
has_many :user_visits, dependent: :delete_all
|
|
has_many :user_auth_token_logs, dependent: :delete_all
|
|
has_many :group_requests, dependent: :delete_all
|
|
has_many :muted_user_records, class_name: "MutedUser", dependent: :delete_all
|
|
has_many :ignored_user_records, class_name: "IgnoredUser", dependent: :delete_all
|
|
has_many :do_not_disturb_timings, dependent: :delete_all
|
|
has_one :user_status, dependent: :destroy
|
|
|
|
# dependent deleting handled via before_destroy (special cases)
|
|
has_many :user_actions
|
|
has_many :post_actions
|
|
has_many :post_timings
|
|
has_many :directory_items
|
|
has_many :email_logs
|
|
has_many :security_keys, -> { where(enabled: true) }, class_name: "UserSecurityKey"
|
|
|
|
has_many :badges, through: :user_badges
|
|
has_many :default_featured_user_badges,
|
|
-> {
|
|
max_featured_rank =
|
|
(
|
|
if SiteSetting.max_favorite_badges > 0
|
|
SiteSetting.max_favorite_badges + 1
|
|
else
|
|
DEFAULT_FEATURED_BADGE_COUNT
|
|
end
|
|
)
|
|
for_enabled_badges.grouped_with_count.where("featured_rank <= ?", max_featured_rank)
|
|
},
|
|
class_name: "UserBadge"
|
|
|
|
has_many :topics_allowed, through: :topic_allowed_users, source: :topic
|
|
has_many :groups, through: :group_users
|
|
has_many :secure_categories, -> { distinct }, through: :groups, source: :categories
|
|
has_many :associated_groups, through: :user_associated_groups, dependent: :destroy
|
|
|
|
# deleted in user_second_factors relationship
|
|
has_many :totps,
|
|
-> { where(method: UserSecondFactor.methods[:totp], enabled: true) },
|
|
class_name: "UserSecondFactor"
|
|
|
|
has_one :master_user, through: :anonymous_user_master
|
|
has_one :shadow_user, through: :anonymous_user_shadow, source: :user
|
|
|
|
has_one :profile_background_upload, through: :user_profile
|
|
has_one :card_background_upload, through: :user_profile
|
|
belongs_to :approved_by, class_name: "User"
|
|
belongs_to :primary_group, class_name: "Group"
|
|
belongs_to :flair_group, class_name: "Group"
|
|
|
|
has_many :muted_users, through: :muted_user_records
|
|
has_many :ignored_users, through: :ignored_user_records
|
|
|
|
belongs_to :uploaded_avatar, class_name: "Upload"
|
|
|
|
has_many :sidebar_section_links, dependent: :delete_all
|
|
has_many :category_sidebar_section_links,
|
|
-> { where(linkable_type: "Category") },
|
|
class_name: "SidebarSectionLink"
|
|
has_many :custom_sidebar_tags,
|
|
through: :sidebar_section_links,
|
|
source: :linkable,
|
|
source_type: "Tag"
|
|
|
|
delegate :last_sent_email_address, to: :email_logs
|
|
|
|
validates_presence_of :username
|
|
validate :username_validator, if: :will_save_change_to_username?
|
|
validate :password_validator
|
|
validate :name_validator, if: :will_save_change_to_name?
|
|
validates :name, user_full_name: true, if: :will_save_change_to_name?, length: { maximum: 255 }
|
|
validates :ip_address, allowed_ip_address: { on: :create, message: :signup_not_allowed }
|
|
validates :primary_email, presence: true
|
|
validates :validatable_user_fields_values, watched_words: true, unless: :custom_fields_clean?
|
|
validates_associated :primary_email,
|
|
message: ->(_, user_email) { user_email[:value]&.errors[:email]&.first }
|
|
|
|
after_initialize :add_trust_level
|
|
|
|
before_validation :set_skip_validate_email
|
|
|
|
after_create :create_email_token
|
|
after_create :create_user_stat
|
|
after_create :create_user_option
|
|
after_create :create_user_profile
|
|
after_create :set_random_avatar
|
|
after_create :ensure_in_trust_level_group
|
|
after_create :set_default_categories_preferences
|
|
after_create :set_default_tags_preferences
|
|
after_create :add_default_sidebar_section_links
|
|
|
|
after_update :update_default_sidebar_section_links, if: Proc.new { self.saved_change_to_admin? }
|
|
|
|
after_update :add_default_sidebar_section_links, if: Proc.new { self.saved_change_to_staged? }
|
|
|
|
after_update :trigger_user_updated_event,
|
|
if: Proc.new { self.human? && self.saved_change_to_uploaded_avatar_id? }
|
|
|
|
after_update :trigger_user_automatic_group_refresh, if: :saved_change_to_staged?
|
|
|
|
before_save :update_usernames
|
|
before_save :ensure_password_is_hashed
|
|
before_save :match_primary_group_changes
|
|
before_save :check_if_title_is_badged_granted
|
|
before_save :apply_watched_words, unless: :custom_fields_clean?
|
|
|
|
after_save :expire_tokens_if_password_changed
|
|
after_save :clear_global_notice_if_needed
|
|
after_save :refresh_avatar
|
|
after_save :badge_grant
|
|
after_save :expire_old_email_tokens
|
|
after_save :index_search
|
|
after_save :check_site_contact_username
|
|
|
|
after_save do
|
|
if saved_change_to_uploaded_avatar_id?
|
|
UploadReference.ensure_exist!(upload_ids: [self.uploaded_avatar_id], target: self)
|
|
end
|
|
end
|
|
|
|
after_commit :trigger_user_created_event, on: :create
|
|
after_commit :trigger_user_destroyed_event, on: :destroy
|
|
|
|
before_destroy do
|
|
# These tables don't have primary keys, so destroying them with activerecord is tricky:
|
|
PostTiming.where(user_id: self.id).delete_all
|
|
TopicViewItem.where(user_id: self.id).delete_all
|
|
UserAction.where(
|
|
"user_id = :user_id OR target_user_id = :user_id OR acting_user_id = :user_id",
|
|
user_id: self.id,
|
|
).delete_all
|
|
|
|
# we need to bypass the default scope here, which appears not bypassed for :delete_all
|
|
# however :destroy it is bypassed
|
|
PostAction.with_deleted.where(user_id: self.id).delete_all
|
|
|
|
# This is a perf optimisation to ensure we hit the index
|
|
# without this we need to scan a much larger number of rows
|
|
DirectoryItem
|
|
.where(user_id: self.id)
|
|
.where("period_type in (?)", DirectoryItem.period_types.values)
|
|
.delete_all
|
|
|
|
# our relationship filters on enabled, this makes sure everything is deleted
|
|
UserSecurityKey.where(user_id: self.id).delete_all
|
|
|
|
Developer.where(user_id: self.id).delete_all
|
|
DraftSequence.where(user_id: self.id).delete_all
|
|
GivenDailyLike.where(user_id: self.id).delete_all
|
|
MutedUser.where(user_id: self.id).or(MutedUser.where(muted_user_id: self.id)).delete_all
|
|
IgnoredUser.where(user_id: self.id).or(IgnoredUser.where(ignored_user_id: self.id)).delete_all
|
|
UserAvatar.where(user_id: self.id).delete_all
|
|
end
|
|
|
|
# Skip validating email, for example from a particular auth provider plugin
|
|
attr_accessor :skip_email_validation
|
|
|
|
# Whether we need to be sending a system message after creation
|
|
attr_accessor :send_welcome_message
|
|
|
|
# This is just used to pass some information into the serializer
|
|
attr_accessor :notification_channel_position
|
|
|
|
# set to true to optimize creation and save for imports
|
|
attr_accessor :import_mode
|
|
|
|
# Cache for user custom fields. Currently it is used to display quick search results
|
|
attr_accessor :custom_data
|
|
|
|
scope :with_email,
|
|
->(email) { joins(:user_emails).where("lower(user_emails.email) IN (?)", email) }
|
|
|
|
scope :with_primary_email,
|
|
->(email) {
|
|
joins(:user_emails).where(
|
|
"lower(user_emails.email) IN (?) AND user_emails.primary",
|
|
email,
|
|
)
|
|
}
|
|
|
|
scope :human_users, -> { where("users.id > 0") }
|
|
|
|
# excluding fake users like the system user or anonymous users
|
|
scope :real,
|
|
-> {
|
|
human_users.where(
|
|
"NOT EXISTS(
|
|
SELECT 1
|
|
FROM anonymous_users a
|
|
WHERE a.user_id = users.id
|
|
)",
|
|
)
|
|
}
|
|
|
|
# TODO-PERF: There is no indexes on any of these
|
|
# and NotifyMailingListSubscribers does a select-all-and-loop
|
|
# may want to create an index on (active, silence, suspended_till)?
|
|
scope :silenced, -> { where("silenced_till IS NOT NULL AND silenced_till > ?", Time.zone.now) }
|
|
scope :not_silenced, -> { where("silenced_till IS NULL OR silenced_till <= ?", Time.zone.now) }
|
|
scope :suspended, -> { where("suspended_till IS NOT NULL AND suspended_till > ?", Time.zone.now) }
|
|
scope :not_suspended, -> { where("suspended_till IS NULL OR suspended_till <= ?", Time.zone.now) }
|
|
scope :activated, -> { where(active: true) }
|
|
scope :not_staged, -> { where(staged: false) }
|
|
|
|
scope :filter_by_username,
|
|
->(filter) {
|
|
if filter.is_a?(Array)
|
|
where("username_lower ~* ?", "(#{filter.join("|")})")
|
|
else
|
|
where("username_lower ILIKE ?", "%#{filter}%")
|
|
end
|
|
}
|
|
|
|
scope :filter_by_username_or_email,
|
|
->(filter) {
|
|
if filter.is_a?(String) && filter =~ /.+@.+/
|
|
# probably an email so try the bypass
|
|
if user_id = UserEmail.where("lower(email) = ?", filter.downcase).pluck_first(:user_id)
|
|
return where("users.id = ?", user_id)
|
|
end
|
|
end
|
|
|
|
users = joins(:primary_email)
|
|
|
|
if filter.is_a?(Array)
|
|
users.where(
|
|
"username_lower ~* :filter OR lower(user_emails.email) SIMILAR TO :filter",
|
|
filter: "(#{filter.join("|")})",
|
|
)
|
|
else
|
|
users.where(
|
|
"username_lower ILIKE :filter OR lower(user_emails.email) ILIKE :filter",
|
|
filter: "%#{filter}%",
|
|
)
|
|
end
|
|
}
|
|
|
|
scope :watching_topic,
|
|
->(topic) {
|
|
joins(
|
|
DB.sql_fragment(
|
|
"LEFT JOIN category_users ON category_users.user_id = users.id AND category_users.category_id = :category_id",
|
|
category_id: topic.category_id,
|
|
),
|
|
)
|
|
.joins(
|
|
DB.sql_fragment(
|
|
"LEFT JOIN topic_users ON topic_users.user_id = users.id AND topic_users.topic_id = :topic_id",
|
|
topic_id: topic.id,
|
|
),
|
|
)
|
|
.joins(
|
|
"LEFT JOIN tag_users ON tag_users.user_id = users.id AND tag_users.tag_id IN (#{topic.tag_ids.join(",").presence || "NULL"})",
|
|
)
|
|
.where(
|
|
"category_users.notification_level > 0 OR topic_users.notification_level > 0 OR tag_users.notification_level > 0",
|
|
)
|
|
}
|
|
|
|
module NewTopicDuration
|
|
ALWAYS = -1
|
|
LAST_VISIT = -2
|
|
end
|
|
|
|
MAX_STAFF_DELETE_POST_COUNT ||= 5
|
|
|
|
def self.user_tips
|
|
@user_tips ||=
|
|
Enum.new(
|
|
first_notification: 1,
|
|
topic_timeline: 2,
|
|
post_menu: 3,
|
|
topic_notification_levels: 4,
|
|
suggested_topics: 5,
|
|
)
|
|
end
|
|
|
|
def visible_sidebar_tags(user_guardian = nil)
|
|
user_guardian ||= guardian
|
|
DiscourseTagging.filter_visible(custom_sidebar_tags, user_guardian)
|
|
end
|
|
|
|
def self.max_password_length
|
|
200
|
|
end
|
|
|
|
def self.username_length
|
|
SiteSetting.min_username_length.to_i..SiteSetting.max_username_length.to_i
|
|
end
|
|
|
|
def self.normalize_username(username)
|
|
username.to_s.unicode_normalize.downcase if username.present?
|
|
end
|
|
|
|
def self.username_available?(username, email = nil, allow_reserved_username: false)
|
|
lower = normalize_username(username)
|
|
return false if !allow_reserved_username && reserved_username?(lower)
|
|
return true if !username_exists?(lower)
|
|
|
|
# staged users can use the same username since they will take over the account
|
|
email.present? &&
|
|
User.joins(:user_emails).exists?(
|
|
staged: true,
|
|
username_lower: lower,
|
|
user_emails: {
|
|
primary: true,
|
|
email: email,
|
|
},
|
|
)
|
|
end
|
|
|
|
def self.reserved_username?(username)
|
|
username = normalize_username(username)
|
|
|
|
return true if SiteSetting.here_mention == username
|
|
|
|
SiteSetting
|
|
.reserved_usernames
|
|
.unicode_normalize
|
|
.split("|")
|
|
.any? { |reserved| username.match?(/^#{Regexp.escape(reserved).gsub('\*', ".*")}$/) }
|
|
end
|
|
|
|
def self.editable_user_custom_fields(by_staff: false)
|
|
fields = []
|
|
fields.push(*DiscoursePluginRegistry.self_editable_user_custom_fields)
|
|
fields.push(*DiscoursePluginRegistry.staff_editable_user_custom_fields) if by_staff
|
|
|
|
fields.uniq
|
|
end
|
|
|
|
def self.allowed_user_custom_fields(guardian)
|
|
fields = []
|
|
|
|
fields.push(*DiscoursePluginRegistry.public_user_custom_fields)
|
|
|
|
if SiteSetting.public_user_custom_fields.present?
|
|
fields.push(*SiteSetting.public_user_custom_fields.split("|"))
|
|
end
|
|
|
|
if guardian.is_staff?
|
|
if SiteSetting.staff_user_custom_fields.present?
|
|
fields.push(*SiteSetting.staff_user_custom_fields.split("|"))
|
|
end
|
|
|
|
fields.push(*DiscoursePluginRegistry.staff_user_custom_fields)
|
|
end
|
|
|
|
fields.uniq
|
|
end
|
|
|
|
def self.human_user_id?(user_id)
|
|
user_id > 0
|
|
end
|
|
|
|
def human?
|
|
User.human_user_id?(self.id)
|
|
end
|
|
|
|
def bot?
|
|
!self.human?
|
|
end
|
|
|
|
def effective_locale
|
|
if SiteSetting.allow_user_locale && self.locale.present?
|
|
self.locale
|
|
else
|
|
SiteSetting.default_locale
|
|
end
|
|
end
|
|
|
|
def bookmarks_of_type(type)
|
|
bookmarks.where(bookmarkable_type: type)
|
|
end
|
|
|
|
EMAIL = /([^@]+)@([^\.]+)/
|
|
FROM_STAGED = "from_staged"
|
|
|
|
def self.new_from_params(params)
|
|
user = User.new
|
|
user.name = params[:name]
|
|
user.email = params[:email]
|
|
user.password = params[:password]
|
|
user.username = params[:username]
|
|
user
|
|
end
|
|
|
|
def unstage!
|
|
if self.staged
|
|
ActiveRecord::Base.transaction do
|
|
self.staged = false
|
|
self.custom_fields[FROM_STAGED] = true
|
|
self.notifications.destroy_all
|
|
save!
|
|
end
|
|
|
|
DiscourseEvent.trigger(:user_unstaged, self)
|
|
end
|
|
end
|
|
|
|
def self.suggest_name(string)
|
|
return "" if string.blank?
|
|
(string[/\A[^@]+/].presence || string[/[^@]+\z/]).tr(".", " ").titleize
|
|
end
|
|
|
|
def self.find_by_username_or_email(username_or_email)
|
|
if username_or_email.include?("@")
|
|
find_by_email(username_or_email)
|
|
else
|
|
find_by_username(username_or_email)
|
|
end
|
|
end
|
|
|
|
def self.find_by_email(email, primary: false)
|
|
if primary
|
|
self.with_primary_email(Email.downcase(email)).first
|
|
else
|
|
self.with_email(Email.downcase(email)).first
|
|
end
|
|
end
|
|
|
|
def self.find_by_username(username)
|
|
find_by(username_lower: normalize_username(username))
|
|
end
|
|
|
|
def in_any_groups?(group_ids)
|
|
group_ids.include?(Group::AUTO_GROUPS[:everyone]) || (group_ids & belonging_to_group_ids).any?
|
|
end
|
|
|
|
def belonging_to_group_ids
|
|
@belonging_to_group_ids ||= group_users.pluck(:group_id)
|
|
end
|
|
|
|
def group_granted_trust_level
|
|
GroupUser.where(user_id: id).includes(:group).maximum("groups.grant_trust_level")
|
|
end
|
|
|
|
def visible_groups
|
|
groups.visible_groups(self)
|
|
end
|
|
|
|
def enqueue_welcome_message(message_type)
|
|
return unless SiteSetting.send_welcome_message?
|
|
Jobs.enqueue(:send_system_message, user_id: id, message_type: message_type)
|
|
end
|
|
|
|
def enqueue_member_welcome_message
|
|
return unless SiteSetting.send_tl1_welcome_message?
|
|
Jobs.enqueue(:send_system_message, user_id: id, message_type: "welcome_tl1_user")
|
|
end
|
|
|
|
def enqueue_tl2_promotion_message
|
|
return unless SiteSetting.send_tl2_promotion_message
|
|
Jobs.enqueue(:send_system_message, user_id: id, message_type: "tl2_promotion_message")
|
|
end
|
|
|
|
def enqueue_staff_welcome_message(role)
|
|
return unless staff?
|
|
return if role == :admin && User.real.where(admin: true).count == 1
|
|
|
|
Jobs.enqueue(
|
|
:send_system_message,
|
|
user_id: id,
|
|
message_type: "welcome_staff",
|
|
message_options: {
|
|
role: role.to_s,
|
|
},
|
|
)
|
|
end
|
|
|
|
def change_username(new_username, actor = nil)
|
|
UsernameChanger.change(self, new_username, actor)
|
|
end
|
|
|
|
def created_topic_count
|
|
stat.topic_count
|
|
end
|
|
|
|
alias_method :topic_count, :created_topic_count
|
|
|
|
# tricky, we need our bus to be subscribed from the right spot
|
|
def sync_notification_channel_position
|
|
@unread_notifications_by_type = nil
|
|
self.notification_channel_position = MessageBus.last_id("/notification/#{id}")
|
|
end
|
|
|
|
def invited_by
|
|
used_invite =
|
|
Invite.with_deleted.joins(:invited_users).where("invited_users.user_id = ?", self.id).first
|
|
used_invite.try(:invited_by)
|
|
end
|
|
|
|
def should_validate_email_address?
|
|
!skip_email_validation && !staged?
|
|
end
|
|
|
|
def self.email_hash(email)
|
|
Digest::MD5.hexdigest(email.strip.downcase)
|
|
end
|
|
|
|
def email_hash
|
|
User.email_hash(email)
|
|
end
|
|
|
|
def reload
|
|
@unread_notifications = nil
|
|
@all_unread_notifications_count = nil
|
|
@unread_total_notifications = nil
|
|
@unread_pms = nil
|
|
@unread_bookmarks = nil
|
|
@unread_high_prios = nil
|
|
@user_fields_cache = nil
|
|
@ignored_user_ids = nil
|
|
@muted_user_ids = nil
|
|
@belonging_to_group_ids = nil
|
|
super
|
|
end
|
|
|
|
def ignored_user_ids
|
|
@ignored_user_ids ||= ignored_users.pluck(:id)
|
|
end
|
|
|
|
def muted_user_ids
|
|
@muted_user_ids ||= muted_users.pluck(:id)
|
|
end
|
|
|
|
def unread_notifications_of_type(notification_type)
|
|
# perf critical, much more efficient than AR
|
|
sql = <<~SQL
|
|
SELECT COUNT(*)
|
|
FROM notifications n
|
|
LEFT JOIN topics t ON t.id = n.topic_id
|
|
WHERE t.deleted_at IS NULL
|
|
AND n.notification_type = :notification_type
|
|
AND n.user_id = :user_id
|
|
AND NOT read
|
|
SQL
|
|
|
|
# to avoid coalesce we do to_i
|
|
DB.query_single(sql, user_id: id, notification_type: notification_type)[0].to_i
|
|
end
|
|
|
|
def unread_notifications_of_priority(high_priority:)
|
|
# perf critical, much more efficient than AR
|
|
sql = <<~SQL
|
|
SELECT COUNT(*)
|
|
FROM notifications n
|
|
LEFT JOIN topics t ON t.id = n.topic_id
|
|
WHERE t.deleted_at IS NULL
|
|
AND n.high_priority = :high_priority
|
|
AND n.user_id = :user_id
|
|
AND NOT read
|
|
SQL
|
|
|
|
# to avoid coalesce we do to_i
|
|
DB.query_single(sql, user_id: id, high_priority: high_priority)[0].to_i
|
|
end
|
|
|
|
MAX_UNREAD_BACKLOG = 400
|
|
def grouped_unread_notifications
|
|
results = DB.query(<<~SQL, user_id: self.id, limit: MAX_UNREAD_BACKLOG)
|
|
SELECT X.notification_type AS type, COUNT(*) FROM (
|
|
SELECT n.notification_type
|
|
FROM notifications n
|
|
LEFT JOIN topics t ON t.id = n.topic_id
|
|
WHERE t.deleted_at IS NULL
|
|
AND n.user_id = :user_id
|
|
AND NOT n.read
|
|
LIMIT :limit
|
|
) AS X
|
|
GROUP BY X.notification_type
|
|
SQL
|
|
results.map! { |row| [row.type, row.count] }
|
|
results.to_h
|
|
end
|
|
|
|
###
|
|
# DEPRECATED: This is only maintained for backwards compat until v2.5. There
|
|
# may be inconsistencies with counts in the UI because of this, because unread
|
|
# high priority includes PMs AND bookmark reminders.
|
|
def unread_private_messages
|
|
@unread_pms ||= unread_high_priority_notifications
|
|
end
|
|
|
|
def unread_high_priority_notifications
|
|
@unread_high_prios ||= unread_notifications_of_priority(high_priority: true)
|
|
end
|
|
|
|
def new_personal_messages_notifications_count
|
|
args = {
|
|
user_id: self.id,
|
|
seen_notification_id: self.seen_notification_id,
|
|
private_message: Notification.types[:private_message],
|
|
}
|
|
|
|
DB.query_single(<<~SQL, args).first
|
|
SELECT COUNT(*)
|
|
FROM notifications
|
|
WHERE user_id = :user_id
|
|
AND id > :seen_notification_id
|
|
AND NOT read
|
|
AND notification_type = :private_message
|
|
SQL
|
|
end
|
|
|
|
# PERF: This safeguard is in place to avoid situations where
|
|
# a user with enormous amounts of unread data can issue extremely
|
|
# expensive queries
|
|
MAX_UNREAD_NOTIFICATIONS = 99
|
|
|
|
def self.max_unread_notifications
|
|
@max_unread_notifications ||= MAX_UNREAD_NOTIFICATIONS
|
|
end
|
|
|
|
def self.max_unread_notifications=(val)
|
|
@max_unread_notifications = val
|
|
end
|
|
|
|
def unread_notifications
|
|
@unread_notifications ||=
|
|
begin
|
|
# perf critical, much more efficient than AR
|
|
sql = <<~SQL
|
|
SELECT COUNT(*) FROM (
|
|
SELECT 1 FROM
|
|
notifications n
|
|
LEFT JOIN topics t ON t.id = n.topic_id
|
|
WHERE t.deleted_at IS NULL AND
|
|
n.high_priority = FALSE AND
|
|
n.user_id = :user_id AND
|
|
n.id > :seen_notification_id AND
|
|
NOT read
|
|
LIMIT :limit
|
|
) AS X
|
|
SQL
|
|
|
|
DB.query_single(
|
|
sql,
|
|
user_id: id,
|
|
seen_notification_id: seen_notification_id,
|
|
limit: User.max_unread_notifications,
|
|
)[
|
|
0
|
|
].to_i
|
|
end
|
|
end
|
|
|
|
def all_unread_notifications_count
|
|
@all_unread_notifications_count ||=
|
|
begin
|
|
sql = <<~SQL
|
|
SELECT COUNT(*) FROM (
|
|
SELECT 1 FROM
|
|
notifications n
|
|
LEFT JOIN topics t ON t.id = n.topic_id
|
|
WHERE t.deleted_at IS NULL AND
|
|
n.user_id = :user_id AND
|
|
n.id > :seen_notification_id AND
|
|
NOT read
|
|
LIMIT :limit
|
|
) AS X
|
|
SQL
|
|
|
|
DB.query_single(
|
|
sql,
|
|
user_id: id,
|
|
seen_notification_id: seen_notification_id,
|
|
limit: User.max_unread_notifications,
|
|
)[
|
|
0
|
|
].to_i
|
|
end
|
|
end
|
|
|
|
def total_unread_notifications
|
|
@unread_total_notifications ||= notifications.where("read = false").count
|
|
end
|
|
|
|
def reviewable_count
|
|
Reviewable.list_for(self, include_claimed_by_others: !redesigned_user_menu_enabled?).count
|
|
end
|
|
|
|
def saw_notification_id(notification_id)
|
|
Discourse.deprecate(<<~TEXT, since: "2.9", drop_from: "3.0")
|
|
User#saw_notification_id is deprecated. Please use User#bump_last_seen_notification! instead.
|
|
TEXT
|
|
if seen_notification_id.to_i < notification_id.to_i
|
|
update_columns(seen_notification_id: notification_id.to_i)
|
|
true
|
|
else
|
|
false
|
|
end
|
|
end
|
|
|
|
def bump_last_seen_notification!
|
|
query = self.notifications.visible
|
|
query = query.where("notifications.id > ?", seen_notification_id) if seen_notification_id
|
|
if max_notification_id = query.maximum(:id)
|
|
update!(seen_notification_id: max_notification_id)
|
|
true
|
|
else
|
|
false
|
|
end
|
|
end
|
|
|
|
def bump_last_seen_reviewable!
|
|
query = Reviewable.unseen_list_for(self, preload: false)
|
|
|
|
query = query.where("reviewables.id > ?", last_seen_reviewable_id) if last_seen_reviewable_id
|
|
max_reviewable_id = query.maximum(:id)
|
|
|
|
if max_reviewable_id
|
|
update!(last_seen_reviewable_id: max_reviewable_id)
|
|
publish_reviewable_counts
|
|
end
|
|
end
|
|
|
|
def publish_reviewable_counts(extra_data = nil)
|
|
data = {
|
|
reviewable_count: self.reviewable_count,
|
|
unseen_reviewable_count: Reviewable.unseen_reviewable_count(self),
|
|
}
|
|
data.merge!(extra_data) if extra_data.present?
|
|
MessageBus.publish("/reviewable_counts/#{self.id}", data, user_ids: [self.id])
|
|
end
|
|
|
|
TRACK_FIRST_NOTIFICATION_READ_DURATION = 1.week.to_i
|
|
|
|
def read_first_notification?
|
|
if (
|
|
trust_level > TrustLevel[1] ||
|
|
(
|
|
first_seen_at.present? &&
|
|
first_seen_at < TRACK_FIRST_NOTIFICATION_READ_DURATION.seconds.ago
|
|
) || user_option.skip_new_user_tips
|
|
)
|
|
return true
|
|
end
|
|
|
|
self.seen_notification_id == 0 ? false : true
|
|
end
|
|
|
|
def publish_notifications_state
|
|
return if !self.allow_live_notifications?
|
|
|
|
# publish last notification json with the message so we can apply an update
|
|
notification = notifications.visible.order("notifications.created_at desc").first
|
|
json = NotificationSerializer.new(notification).as_json if notification
|
|
|
|
sql = (<<~SQL)
|
|
SELECT * FROM (
|
|
SELECT n.id, n.read FROM notifications n
|
|
LEFT JOIN topics t ON n.topic_id = t.id
|
|
WHERE
|
|
t.deleted_at IS NULL AND
|
|
n.high_priority AND
|
|
n.user_id = :user_id AND
|
|
NOT read
|
|
ORDER BY n.id DESC
|
|
LIMIT 20
|
|
) AS x
|
|
UNION ALL
|
|
SELECT * FROM (
|
|
SELECT n.id, n.read FROM notifications n
|
|
LEFT JOIN topics t ON n.topic_id = t.id
|
|
WHERE
|
|
t.deleted_at IS NULL AND
|
|
(n.high_priority = FALSE OR read) AND
|
|
n.user_id = :user_id
|
|
ORDER BY n.id DESC
|
|
LIMIT 20
|
|
) AS y
|
|
SQL
|
|
|
|
recent = DB.query(sql, user_id: id).map! { |r| [r.id, r.read] }
|
|
|
|
payload = {
|
|
unread_notifications: unread_notifications,
|
|
unread_private_messages: unread_private_messages,
|
|
unread_high_priority_notifications: unread_high_priority_notifications,
|
|
read_first_notification: read_first_notification?,
|
|
last_notification: json,
|
|
recent: recent,
|
|
seen_notification_id: seen_notification_id,
|
|
}
|
|
|
|
if self.redesigned_user_menu_enabled?
|
|
payload[:all_unread_notifications_count] = all_unread_notifications_count
|
|
payload[:grouped_unread_notifications] = grouped_unread_notifications
|
|
payload[
|
|
:new_personal_messages_notifications_count
|
|
] = new_personal_messages_notifications_count
|
|
end
|
|
|
|
MessageBus.publish("/notification/#{id}", payload, user_ids: [id])
|
|
end
|
|
|
|
def publish_do_not_disturb(ends_at: nil)
|
|
MessageBus.publish("/do-not-disturb/#{id}", { ends_at: ends_at&.httpdate }, user_ids: [id])
|
|
end
|
|
|
|
def publish_user_status(status)
|
|
if status
|
|
payload = {
|
|
description: status.description,
|
|
emoji: status.emoji,
|
|
ends_at: status.ends_at&.iso8601,
|
|
}
|
|
else
|
|
payload = nil
|
|
end
|
|
|
|
MessageBus.publish(
|
|
"/user-status",
|
|
{ id => payload },
|
|
group_ids: [Group::AUTO_GROUPS[:trust_level_0]],
|
|
)
|
|
end
|
|
|
|
def password=(password)
|
|
# special case for passwordless accounts
|
|
@raw_password = password unless password.blank?
|
|
end
|
|
|
|
def password
|
|
"" # so that validator doesn't complain that a password attribute doesn't exist
|
|
end
|
|
|
|
# Indicate that this is NOT a passwordless account for the purposes of validation
|
|
def password_required!
|
|
@password_required = true
|
|
end
|
|
|
|
def password_required?
|
|
!!@password_required
|
|
end
|
|
|
|
def password_validation_required?
|
|
password_required? || @raw_password.present?
|
|
end
|
|
|
|
def has_password?
|
|
password_hash.present?
|
|
end
|
|
|
|
def password_validator
|
|
PasswordValidator.new(attributes: :password).validate_each(self, :password, @raw_password)
|
|
end
|
|
|
|
def confirm_password?(password)
|
|
return false unless password_hash && salt
|
|
self.password_hash == hash_password(password, salt)
|
|
end
|
|
|
|
def new_user_posting_on_first_day?
|
|
!staff? && trust_level < TrustLevel[2] &&
|
|
(
|
|
trust_level == TrustLevel[0] || self.first_post_created_at.nil? ||
|
|
self.first_post_created_at >= 24.hours.ago
|
|
)
|
|
end
|
|
|
|
def new_user?
|
|
(created_at >= 24.hours.ago || trust_level == TrustLevel[0]) && trust_level < TrustLevel[2] &&
|
|
!staff?
|
|
end
|
|
|
|
def seen_before?
|
|
last_seen_at.present?
|
|
end
|
|
|
|
def seen_since?(datetime)
|
|
seen_before? && last_seen_at >= datetime
|
|
end
|
|
|
|
def create_visit_record!(date, opts = {})
|
|
user_stat.update_column(:days_visited, user_stat.days_visited + 1)
|
|
user_visits.create!(
|
|
visited_at: date,
|
|
posts_read: opts[:posts_read] || 0,
|
|
mobile: opts[:mobile] || false,
|
|
)
|
|
end
|
|
|
|
def visit_record_for(date)
|
|
user_visits.find_by(visited_at: date)
|
|
end
|
|
|
|
def update_visit_record!(date)
|
|
create_visit_record!(date) unless visit_record_for(date)
|
|
end
|
|
|
|
def update_timezone_if_missing(timezone)
|
|
return if timezone.blank? || !TimezoneValidator.valid?(timezone)
|
|
|
|
# we only want to update the user's timezone if they have not set it themselves
|
|
UserOption.where(user_id: self.id, timezone: nil).update_all(timezone: timezone)
|
|
end
|
|
|
|
def update_posts_read!(num_posts, opts = {})
|
|
now = opts[:at] || Time.zone.now
|
|
_retry = opts[:retry] || false
|
|
|
|
if user_visit = visit_record_for(now.to_date)
|
|
user_visit.posts_read += num_posts
|
|
user_visit.mobile = true if opts[:mobile]
|
|
user_visit.save
|
|
user_visit
|
|
else
|
|
begin
|
|
create_visit_record!(now.to_date, posts_read: num_posts, mobile: opts.fetch(:mobile, false))
|
|
rescue ActiveRecord::RecordNotUnique
|
|
if !_retry
|
|
update_posts_read!(num_posts, opts.merge(retry: true))
|
|
else
|
|
raise
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.update_ip_address!(user_id, new_ip:, old_ip:)
|
|
unless old_ip == new_ip || new_ip.blank?
|
|
DB.exec(<<~SQL, user_id: user_id, ip_address: new_ip)
|
|
UPDATE users
|
|
SET ip_address = :ip_address
|
|
WHERE id = :user_id
|
|
SQL
|
|
|
|
if SiteSetting.keep_old_ip_address_count > 0
|
|
DB.exec(<<~SQL, user_id: user_id, ip_address: new_ip, current_timestamp: Time.zone.now)
|
|
INSERT INTO user_ip_address_histories (user_id, ip_address, created_at, updated_at)
|
|
VALUES (:user_id, :ip_address, :current_timestamp, :current_timestamp)
|
|
ON CONFLICT (user_id, ip_address)
|
|
DO
|
|
UPDATE SET updated_at = :current_timestamp
|
|
SQL
|
|
|
|
DB.exec(<<~SQL, user_id: user_id, offset: SiteSetting.keep_old_ip_address_count)
|
|
DELETE FROM user_ip_address_histories
|
|
WHERE id IN (
|
|
SELECT
|
|
id
|
|
FROM user_ip_address_histories
|
|
WHERE user_id = :user_id
|
|
ORDER BY updated_at DESC
|
|
OFFSET :offset
|
|
)
|
|
SQL
|
|
end
|
|
end
|
|
end
|
|
|
|
def update_ip_address!(new_ip_address)
|
|
User.update_ip_address!(id, new_ip: new_ip_address, old_ip: ip_address)
|
|
end
|
|
|
|
def self.last_seen_redis_key(user_id, now)
|
|
now_date = now.to_date
|
|
"user:#{user_id}:#{now_date}"
|
|
end
|
|
|
|
def last_seen_redis_key(now)
|
|
User.last_seen_redis_key(id, now)
|
|
end
|
|
|
|
def clear_last_seen_cache!(now = Time.zone.now)
|
|
Discourse.redis.del(last_seen_redis_key(now))
|
|
end
|
|
|
|
def self.should_update_last_seen?(user_id, now = Time.zone.now)
|
|
return true if SiteSetting.active_user_rate_limit_secs <= 0
|
|
|
|
Discourse.redis.set(
|
|
last_seen_redis_key(user_id, now),
|
|
"1",
|
|
nx: true,
|
|
ex: SiteSetting.active_user_rate_limit_secs,
|
|
)
|
|
end
|
|
|
|
def update_last_seen!(now = Time.zone.now, force: false)
|
|
if !force
|
|
return if !User.should_update_last_seen?(self.id, now)
|
|
end
|
|
|
|
update_previous_visit(now)
|
|
# using update_column to avoid the AR transaction
|
|
update_column(:last_seen_at, now)
|
|
update_column(:first_seen_at, now) unless self.first_seen_at
|
|
|
|
DiscourseEvent.trigger(:user_seen, self)
|
|
end
|
|
|
|
def self.gravatar_template(email)
|
|
"//#{SiteSetting.gravatar_base_url}/avatar/#{self.email_hash(email)}.png?s={size}&r=pg&d=identicon"
|
|
end
|
|
|
|
# Don't pass this up to the client - it's meant for server side use
|
|
# This is used in
|
|
# - self oneboxes in open graph data
|
|
# - emails
|
|
def small_avatar_url
|
|
avatar_template_url.gsub("{size}", "45")
|
|
end
|
|
|
|
def avatar_template_url
|
|
UrlHelper.schemaless UrlHelper.absolute avatar_template
|
|
end
|
|
|
|
def self.username_hash(username)
|
|
username
|
|
.each_char
|
|
.reduce(0) do |result, char|
|
|
[((result << 5) - result) + char.ord].pack("L").unpack("l").first
|
|
end
|
|
.abs
|
|
end
|
|
|
|
def self.default_template(username)
|
|
if SiteSetting.default_avatars.present?
|
|
urls = SiteSetting.default_avatars.split("\n")
|
|
return urls[username_hash(username) % urls.size] if urls.present?
|
|
end
|
|
|
|
system_avatar_template(username)
|
|
end
|
|
|
|
def self.avatar_template(username, uploaded_avatar_id)
|
|
username ||= ""
|
|
return default_template(username) if !uploaded_avatar_id
|
|
hostname = RailsMultisite::ConnectionManagement.current_hostname
|
|
UserAvatar.local_avatar_template(hostname, username.downcase, uploaded_avatar_id)
|
|
end
|
|
|
|
def self.system_avatar_template(username)
|
|
normalized_username = normalize_username(username)
|
|
|
|
# TODO it may be worth caching this in a distributed cache, should be benched
|
|
if SiteSetting.external_system_avatars_enabled
|
|
url = SiteSetting.external_system_avatars_url.dup
|
|
url = +"#{Discourse.base_path}#{url}" unless url =~ %r{^https?://}
|
|
url.gsub! "{color}", letter_avatar_color(normalized_username)
|
|
url.gsub! "{username}", UrlHelper.encode_component(username)
|
|
url.gsub! "{first_letter}",
|
|
UrlHelper.encode_component(normalized_username.grapheme_clusters.first)
|
|
url.gsub! "{hostname}", Discourse.current_hostname
|
|
url
|
|
else
|
|
"#{Discourse.base_path}/letter_avatar/#{normalized_username}/{size}/#{LetterAvatar.version}.png"
|
|
end
|
|
end
|
|
|
|
def self.letter_avatar_color(username)
|
|
username ||= ""
|
|
if SiteSetting.restrict_letter_avatar_colors.present?
|
|
hex_length = 6
|
|
colors = SiteSetting.restrict_letter_avatar_colors
|
|
length = colors.count("|") + 1
|
|
num = color_index(username, length)
|
|
index = (num * hex_length) + num
|
|
colors[index, hex_length]
|
|
else
|
|
color = LetterAvatar::COLORS[color_index(username, LetterAvatar::COLORS.length)]
|
|
color.map { |c| c.to_s(16).rjust(2, "0") }.join
|
|
end
|
|
end
|
|
|
|
def self.color_index(username, length)
|
|
Digest::MD5.hexdigest(username)[0...15].to_i(16) % length
|
|
end
|
|
|
|
def is_system_user?
|
|
id == Discourse::SYSTEM_USER_ID
|
|
end
|
|
|
|
def avatar_template
|
|
use_small_logo =
|
|
is_system_user? && SiteSetting.logo_small && SiteSetting.use_site_small_logo_as_system_avatar
|
|
|
|
if use_small_logo
|
|
Discourse.store.cdn_url(SiteSetting.logo_small.url)
|
|
else
|
|
self.class.avatar_template(username, uploaded_avatar_id)
|
|
end
|
|
end
|
|
|
|
# The following count methods are somewhat slow - definitely don't use them in a loop.
|
|
# They might need to be denormalized
|
|
def like_count
|
|
UserAction.where(user_id: id, action_type: UserAction::WAS_LIKED).count
|
|
end
|
|
|
|
def like_given_count
|
|
UserAction.where(user_id: id, action_type: UserAction::LIKE).count
|
|
end
|
|
|
|
def post_count
|
|
stat.post_count
|
|
end
|
|
|
|
def post_edits_count
|
|
stat.post_edits_count
|
|
end
|
|
|
|
def increment_post_edits_count
|
|
stat.increment!(:post_edits_count)
|
|
end
|
|
|
|
def flags_given_count
|
|
PostAction.where(
|
|
user_id: id,
|
|
post_action_type_id: PostActionType.flag_types_without_custom.values,
|
|
).count
|
|
end
|
|
|
|
def warnings_received_count
|
|
user_warnings.count
|
|
end
|
|
|
|
def flags_received_count
|
|
posts
|
|
.includes(:post_actions)
|
|
.where("post_actions.post_action_type_id" => PostActionType.flag_types_without_custom.values)
|
|
.count
|
|
end
|
|
|
|
def private_topics_count
|
|
topics_allowed.where(archetype: Archetype.private_message).count
|
|
end
|
|
|
|
def posted_too_much_in_topic?(topic_id)
|
|
# Does not apply to staff and non-new members...
|
|
return false if staff? || (trust_level != TrustLevel[0])
|
|
# ... your own topics or in private messages
|
|
topic = Topic.where(id: topic_id).first
|
|
return false if topic.try(:private_message?) || (topic.try(:user_id) == self.id)
|
|
|
|
last_action_in_topic = UserAction.last_action_in_topic(id, topic_id)
|
|
since_reply = Post.where(user_id: id, topic_id: topic_id)
|
|
since_reply = since_reply.where("id > ?", last_action_in_topic) if last_action_in_topic
|
|
|
|
(since_reply.count >= SiteSetting.newuser_max_replies_per_topic)
|
|
end
|
|
|
|
def delete_posts_in_batches(guardian, batch_size = 20)
|
|
raise Discourse::InvalidAccess unless guardian.can_delete_all_posts? self
|
|
|
|
Reviewable.where(created_by_id: id).delete_all
|
|
|
|
posts
|
|
.order("post_number desc")
|
|
.limit(batch_size)
|
|
.each { |p| PostDestroyer.new(guardian.user, p).destroy }
|
|
end
|
|
|
|
def suspended?
|
|
!!(suspended_till && suspended_till > Time.zone.now)
|
|
end
|
|
|
|
def silenced?
|
|
!!(silenced_till && silenced_till > Time.zone.now)
|
|
end
|
|
|
|
def silenced_record
|
|
UserHistory.for(self, :silence_user).order("id DESC").first
|
|
end
|
|
|
|
def silence_reason
|
|
silenced_record.try(:details) if silenced?
|
|
end
|
|
|
|
def silenced_at
|
|
silenced_record.try(:created_at) if silenced?
|
|
end
|
|
|
|
def silenced_forever?
|
|
silenced_till > 100.years.from_now
|
|
end
|
|
|
|
def suspend_record
|
|
UserHistory.for(self, :suspend_user).order("id DESC").first
|
|
end
|
|
|
|
def full_suspend_reason
|
|
return suspend_record.try(:details) if suspended?
|
|
end
|
|
|
|
def suspend_reason
|
|
if details = full_suspend_reason
|
|
return details.split("\n")[0]
|
|
end
|
|
|
|
nil
|
|
end
|
|
|
|
def suspended_message
|
|
return nil unless suspended?
|
|
|
|
message = "login.suspended"
|
|
if suspend_reason
|
|
if suspended_forever?
|
|
message = "login.suspended_with_reason_forever"
|
|
else
|
|
message = "login.suspended_with_reason"
|
|
end
|
|
end
|
|
|
|
I18n.t(
|
|
message,
|
|
date: I18n.l(suspended_till, format: :date_only),
|
|
reason: Rack::Utils.escape_html(suspend_reason),
|
|
)
|
|
end
|
|
|
|
def suspended_forever?
|
|
suspended_till > 100.years.from_now
|
|
end
|
|
|
|
# Use this helper to determine if the user has a particular trust level.
|
|
# Takes into account admin, etc.
|
|
def has_trust_level?(level)
|
|
raise InvalidTrustLevel.new("Invalid trust level #{level}") unless TrustLevel.valid?(level)
|
|
|
|
admin? || moderator? || staged? || TrustLevel.compare(trust_level, level)
|
|
end
|
|
|
|
def has_trust_level_or_staff?(level)
|
|
return admin? if level.to_s == "admin"
|
|
return staff? if level.to_s == "staff"
|
|
has_trust_level?(level.to_i)
|
|
end
|
|
|
|
# a touch faster than automatic
|
|
def admin?
|
|
admin
|
|
end
|
|
|
|
def guardian
|
|
Guardian.new(self)
|
|
end
|
|
|
|
def username_format_validator
|
|
UsernameValidator.perform_validation(self, "username")
|
|
end
|
|
|
|
def email_confirmed?
|
|
email_tokens.where(email: email, confirmed: true).present? || email_tokens.empty? ||
|
|
single_sign_on_record&.external_email&.downcase == email
|
|
end
|
|
|
|
def activate
|
|
email_token = self.email_tokens.create!(email: self.email, scope: EmailToken.scopes[:signup])
|
|
EmailToken.confirm(email_token.token, scope: EmailToken.scopes[:signup])
|
|
reload
|
|
end
|
|
|
|
def deactivate(performed_by)
|
|
self.update!(active: false)
|
|
|
|
if reviewable = ReviewableUser.pending.find_by(target: self)
|
|
reviewable.perform(performed_by, :delete_user)
|
|
end
|
|
end
|
|
|
|
def change_trust_level!(level, opts = nil)
|
|
Promotion.new(self).change_trust_level!(level, opts)
|
|
end
|
|
|
|
def readable_name
|
|
name.present? && name != username ? "#{name} (#{username})" : username
|
|
end
|
|
|
|
def badge_count
|
|
user_stat&.distinct_badge_count
|
|
end
|
|
|
|
def featured_user_badges(limit = nil)
|
|
if limit.nil?
|
|
default_featured_user_badges
|
|
else
|
|
user_badges.grouped_with_count.where("featured_rank <= ?", limit)
|
|
end
|
|
end
|
|
|
|
def self.count_by_signup_date(start_date = nil, end_date = nil, group_id = nil)
|
|
result = self
|
|
|
|
if start_date && end_date
|
|
result = result.group("date(users.created_at)")
|
|
result = result.where("users.created_at >= ? AND users.created_at <= ?", start_date, end_date)
|
|
result = result.order("date(users.created_at)")
|
|
end
|
|
|
|
if group_id
|
|
result = result.joins("INNER JOIN group_users ON group_users.user_id = users.id")
|
|
result = result.where("group_users.group_id = ?", group_id)
|
|
end
|
|
|
|
result.count
|
|
end
|
|
|
|
def self.count_by_first_post(start_date = nil, end_date = nil)
|
|
result = joins("INNER JOIN user_stats AS us ON us.user_id = users.id")
|
|
|
|
if start_date && end_date
|
|
result = result.group("date(us.first_post_created_at)")
|
|
result =
|
|
result.where(
|
|
"us.first_post_created_at > ? AND us.first_post_created_at < ?",
|
|
start_date,
|
|
end_date,
|
|
)
|
|
result = result.order("date(us.first_post_created_at)")
|
|
end
|
|
|
|
result.count
|
|
end
|
|
|
|
def secure_category_ids
|
|
cats =
|
|
if self.admin? && !SiteSetting.suppress_secured_categories_from_admin
|
|
Category.unscoped.where(read_restricted: true)
|
|
else
|
|
secure_categories.references(:categories)
|
|
end
|
|
|
|
cats.pluck("categories.id").sort
|
|
end
|
|
|
|
def topic_create_allowed_category_ids
|
|
Category.topic_create_allowed(self.id).select(:id)
|
|
end
|
|
|
|
# Flag all posts from a user as spam
|
|
def flag_linked_posts_as_spam
|
|
results = []
|
|
|
|
disagreed_flag_post_ids =
|
|
PostAction
|
|
.where(post_action_type_id: PostActionType.types[:spam])
|
|
.where.not(disagreed_at: nil)
|
|
.pluck(:post_id)
|
|
|
|
topic_links
|
|
.includes(:post)
|
|
.where.not(post_id: disagreed_flag_post_ids)
|
|
.each do |tl|
|
|
message =
|
|
I18n.t(
|
|
"flag_reason.spam_hosts",
|
|
base_path: Discourse.base_path,
|
|
locale: SiteSetting.default_locale,
|
|
)
|
|
results << PostActionCreator.create(Discourse.system_user, tl.post, :spam, message: message)
|
|
end
|
|
|
|
results
|
|
end
|
|
|
|
def has_uploaded_avatar
|
|
uploaded_avatar.present?
|
|
end
|
|
|
|
def find_email
|
|
if last_sent_email_address.present? &&
|
|
EmailAddressValidator.valid_value?(last_sent_email_address)
|
|
last_sent_email_address
|
|
else
|
|
email
|
|
end
|
|
end
|
|
|
|
def tl3_requirements
|
|
@lq ||= TrustLevel3Requirements.new(self)
|
|
end
|
|
|
|
def on_tl3_grace_period?
|
|
return true if SiteSetting.tl3_promotion_min_duration.to_i.days.ago.year < 2013
|
|
|
|
UserHistory
|
|
.for(self, :auto_trust_level_change)
|
|
.where("created_at >= ?", SiteSetting.tl3_promotion_min_duration.to_i.days.ago)
|
|
.where(previous_value: TrustLevel[2].to_s)
|
|
.where(new_value: TrustLevel[3].to_s)
|
|
.exists?
|
|
end
|
|
|
|
def refresh_avatar
|
|
return if @import_mode
|
|
|
|
avatar = user_avatar || create_user_avatar
|
|
|
|
if self.primary_email.present? && SiteSetting.automatically_download_gravatars? &&
|
|
!avatar.last_gravatar_download_attempt
|
|
Jobs.cancel_scheduled_job(:update_gravatar, user_id: self.id, avatar_id: avatar.id)
|
|
Jobs.enqueue_in(1.second, :update_gravatar, user_id: self.id, avatar_id: avatar.id)
|
|
end
|
|
|
|
# mark all the user's quoted posts as "needing a rebake"
|
|
Post.rebake_all_quoted_posts(self.id) if self.will_save_change_to_uploaded_avatar_id?
|
|
end
|
|
|
|
def first_post_created_at
|
|
user_stat.try(:first_post_created_at)
|
|
end
|
|
|
|
def associated_accounts
|
|
result = []
|
|
|
|
Discourse.authenticators.each do |authenticator|
|
|
account_description = authenticator.description_for_user(self)
|
|
unless account_description.empty?
|
|
result << { name: authenticator.name, description: account_description }
|
|
end
|
|
end
|
|
|
|
result
|
|
end
|
|
|
|
USER_FIELD_PREFIX ||= "user_field_"
|
|
|
|
def user_fields(field_ids = nil)
|
|
field_ids = (@all_user_field_ids ||= UserField.pluck(:id)) if field_ids.nil?
|
|
|
|
@user_fields_cache ||= {}
|
|
|
|
# Memoize based on requested fields
|
|
@user_fields_cache[field_ids.join(":")] ||= {}.tap do |hash|
|
|
field_ids.each do |fid|
|
|
# The hash keys are strings for backwards compatibility
|
|
hash[fid.to_s] = custom_fields["#{USER_FIELD_PREFIX}#{fid}"]
|
|
end
|
|
end
|
|
end
|
|
|
|
def validatable_user_fields_values
|
|
validatable_user_fields.values.join(" ")
|
|
end
|
|
|
|
def set_user_field(field_id, value)
|
|
custom_fields["#{USER_FIELD_PREFIX}#{field_id}"] = value
|
|
end
|
|
|
|
def apply_watched_words
|
|
validatable_user_fields.each do |id, value|
|
|
set_user_field(id, WordWatcher.apply_to_text(value))
|
|
end
|
|
end
|
|
|
|
def validatable_user_fields
|
|
# ignore multiselect fields since they are admin-set and thus not user generated content
|
|
@public_user_field_ids ||=
|
|
UserField.public_fields.where.not(field_type: "multiselect").pluck(:id)
|
|
|
|
user_fields(@public_user_field_ids)
|
|
end
|
|
|
|
def number_of_deleted_posts
|
|
Post.with_deleted.where(user_id: self.id).where.not(deleted_at: nil).count
|
|
end
|
|
|
|
def number_of_flagged_posts
|
|
ReviewableFlaggedPost.where(target_created_by: self.id).count
|
|
end
|
|
|
|
def number_of_rejected_posts
|
|
ReviewableQueuedPost.rejected.where(created_by_id: self.id).count
|
|
end
|
|
|
|
def number_of_flags_given
|
|
PostAction
|
|
.where(user_id: self.id)
|
|
.where(disagreed_at: nil)
|
|
.where(post_action_type_id: PostActionType.notify_flag_type_ids)
|
|
.count
|
|
end
|
|
|
|
def number_of_suspensions
|
|
UserHistory.for(self, :suspend_user).count
|
|
end
|
|
|
|
def create_user_profile
|
|
UserProfile.create!(user_id: id)
|
|
end
|
|
|
|
def set_random_avatar
|
|
if SiteSetting.selectable_avatars_mode != "disabled"
|
|
if upload = SiteSetting.selectable_avatars.sample
|
|
update_column(:uploaded_avatar_id, upload.id)
|
|
UserAvatar.create!(user_id: id, custom_upload_id: upload.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
def anonymous?
|
|
SiteSetting.allow_anonymous_posting && trust_level >= 1 && !!anonymous_user_master
|
|
end
|
|
|
|
def is_singular_admin?
|
|
User.where(admin: true).where.not(id: id).human_users.blank?
|
|
end
|
|
|
|
def logged_out
|
|
MessageBus.publish "/logout/#{self.id}", self.id, user_ids: [self.id]
|
|
DiscourseEvent.trigger(:user_logged_out, self)
|
|
end
|
|
|
|
def logged_in
|
|
DiscourseEvent.trigger(:user_logged_in, self)
|
|
|
|
DiscourseEvent.trigger(:user_first_logged_in, self) if !self.seen_before?
|
|
end
|
|
|
|
def set_automatic_groups
|
|
return if !active || staged || !email_confirmed?
|
|
|
|
Group
|
|
.where(automatic: false)
|
|
.where("LENGTH(COALESCE(automatic_membership_email_domains, '')) > 0")
|
|
.each do |group|
|
|
domains = group.automatic_membership_email_domains.gsub(".", '\.')
|
|
|
|
if email =~ Regexp.new("@(#{domains})$", true) && !group.users.include?(self)
|
|
group.add(self)
|
|
GroupActionLogger.new(Discourse.system_user, group).log_add_user_to_group(self)
|
|
end
|
|
end
|
|
|
|
@belonging_to_group_ids = nil
|
|
end
|
|
|
|
def email
|
|
primary_email&.email
|
|
end
|
|
|
|
# Shortcut to set the primary email of the user.
|
|
# Automatically removes any identical secondary emails.
|
|
def email=(new_email)
|
|
if primary_email
|
|
primary_email.email = new_email
|
|
else
|
|
build_primary_email email: new_email, skip_validate_email: !should_validate_email_address?
|
|
end
|
|
|
|
if secondary_match =
|
|
user_emails.detect { |ue|
|
|
!ue.primary && Email.downcase(ue.email) == Email.downcase(new_email)
|
|
}
|
|
secondary_match.mark_for_destruction
|
|
primary_email.skip_validate_unique_email = true
|
|
end
|
|
|
|
new_email
|
|
end
|
|
|
|
def emails
|
|
self.user_emails.order("user_emails.primary DESC NULLS LAST").pluck(:email)
|
|
end
|
|
|
|
def secondary_emails
|
|
self.user_emails.secondary.pluck(:email)
|
|
end
|
|
|
|
def unconfirmed_emails
|
|
self
|
|
.email_change_requests
|
|
.where.not(change_state: EmailChangeRequest.states[:complete])
|
|
.pluck(:new_email)
|
|
end
|
|
|
|
RECENT_TIME_READ_THRESHOLD ||= 60.days
|
|
|
|
def self.preload_recent_time_read(users)
|
|
times =
|
|
UserVisit
|
|
.where(user_id: users.map(&:id))
|
|
.where("visited_at >= ?", RECENT_TIME_READ_THRESHOLD.ago)
|
|
.group(:user_id)
|
|
.sum(:time_read)
|
|
users.each { |u| u.preload_recent_time_read(times[u.id] || 0) }
|
|
end
|
|
|
|
def preload_recent_time_read(time)
|
|
@recent_time_read = time
|
|
end
|
|
|
|
def recent_time_read
|
|
@recent_time_read ||=
|
|
self.user_visits.where("visited_at >= ?", RECENT_TIME_READ_THRESHOLD.ago).sum(:time_read)
|
|
end
|
|
|
|
def from_staged?
|
|
custom_fields[User::FROM_STAGED]
|
|
end
|
|
|
|
def mature_staged?
|
|
from_staged? && self.created_at && self.created_at < 1.day.ago
|
|
end
|
|
|
|
def next_best_title
|
|
group_titles_query = groups.where("groups.title <> ''")
|
|
group_titles_query =
|
|
group_titles_query.order("groups.id = #{primary_group_id} DESC") if primary_group_id
|
|
group_titles_query = group_titles_query.order("groups.primary_group DESC").limit(1)
|
|
|
|
if next_best_group_title = group_titles_query.pluck_first(:title)
|
|
return next_best_group_title
|
|
end
|
|
|
|
next_best_badge_title = badges.where(allow_title: true).pluck_first(:name)
|
|
next_best_badge_title ? Badge.display_name(next_best_badge_title) : nil
|
|
end
|
|
|
|
def create_reviewable
|
|
return unless SiteSetting.must_approve_users? || SiteSetting.invite_only?
|
|
return if approved?
|
|
|
|
Jobs.enqueue(:create_user_reviewable, user_id: self.id)
|
|
end
|
|
|
|
def has_more_posts_than?(max_post_count)
|
|
return true if user_stat && (user_stat.topic_count + user_stat.post_count) > max_post_count
|
|
return true if max_post_count < 0
|
|
|
|
DB.query_single(<<~SQL, user_id: self.id).first > max_post_count
|
|
SELECT COUNT(1)
|
|
FROM (
|
|
SELECT 1
|
|
FROM posts p
|
|
JOIN topics t ON (p.topic_id = t.id)
|
|
WHERE p.user_id = :user_id AND
|
|
p.deleted_at IS NULL AND
|
|
t.deleted_at IS NULL AND
|
|
(
|
|
t.archetype <> 'private_message' OR
|
|
EXISTS(
|
|
SELECT 1
|
|
FROM topic_allowed_users a
|
|
WHERE a.topic_id = t.id AND a.user_id > 0 AND a.user_id <> :user_id
|
|
) OR
|
|
EXISTS(
|
|
SELECT 1
|
|
FROM topic_allowed_groups g
|
|
WHERE g.topic_id = p.topic_id
|
|
)
|
|
)
|
|
LIMIT #{max_post_count + 1}
|
|
) x
|
|
SQL
|
|
end
|
|
|
|
def create_or_fetch_secure_identifier
|
|
return secure_identifier if secure_identifier.present?
|
|
new_secure_identifier = SecureRandom.hex(20)
|
|
self.update(secure_identifier: new_secure_identifier)
|
|
new_secure_identifier
|
|
end
|
|
|
|
def second_factor_security_key_credential_ids
|
|
security_keys
|
|
.select(:credential_id)
|
|
.where(factor_type: UserSecurityKey.factor_types[:second_factor])
|
|
.pluck(:credential_id)
|
|
end
|
|
|
|
def encoded_username(lower: false)
|
|
UrlHelper.encode_component(lower ? username_lower : username)
|
|
end
|
|
|
|
def do_not_disturb?
|
|
active_do_not_disturb_timings.exists?
|
|
end
|
|
|
|
def active_do_not_disturb_timings
|
|
now = Time.zone.now
|
|
do_not_disturb_timings.where("starts_at <= ? AND ends_at > ?", now, now)
|
|
end
|
|
|
|
def do_not_disturb_until
|
|
active_do_not_disturb_timings.maximum(:ends_at)
|
|
end
|
|
|
|
def shelved_notifications
|
|
ShelvedNotification.joins(:notification).where("notifications.user_id = ?", self.id)
|
|
end
|
|
|
|
def allow_live_notifications?
|
|
seen_since?(30.days.ago)
|
|
end
|
|
|
|
def username_equals_to?(another_username)
|
|
username_lower == User.normalize_username(another_username)
|
|
end
|
|
|
|
def full_url
|
|
"#{Discourse.base_url}/u/#{encoded_username}"
|
|
end
|
|
|
|
def display_name
|
|
if SiteSetting.prioritize_username_in_ux?
|
|
username
|
|
else
|
|
name.presence || username
|
|
end
|
|
end
|
|
|
|
def clear_status!
|
|
user_status.destroy! if user_status
|
|
publish_user_status(nil)
|
|
end
|
|
|
|
def set_status!(description, emoji, ends_at = nil)
|
|
status = { description: description, emoji: emoji, set_at: Time.zone.now, ends_at: ends_at }
|
|
|
|
if user_status
|
|
user_status.update!(status)
|
|
else
|
|
self.user_status = UserStatus.create!(status)
|
|
end
|
|
|
|
publish_user_status(user_status)
|
|
end
|
|
|
|
def has_status?
|
|
user_status && !user_status.expired?
|
|
end
|
|
|
|
def redesigned_user_menu_enabled?
|
|
!SiteSetting.legacy_navigation_menu?
|
|
end
|
|
|
|
protected
|
|
|
|
def badge_grant
|
|
BadgeGranter.queue_badge_grant(Badge::Trigger::UserChange, user: self)
|
|
end
|
|
|
|
def expire_old_email_tokens
|
|
if saved_change_to_password_hash? && !saved_change_to_id?
|
|
email_tokens.where("not expired").update_all(expired: true)
|
|
end
|
|
end
|
|
|
|
def index_search
|
|
# force is needed as user custom fields are updated using SQL and after_save callback is not triggered
|
|
SearchIndexer.index(self, force: true)
|
|
end
|
|
|
|
def clear_global_notice_if_needed
|
|
return if id < 0
|
|
|
|
if admin && SiteSetting.has_login_hint
|
|
SiteSetting.has_login_hint = false
|
|
SiteSetting.global_notice = ""
|
|
end
|
|
end
|
|
|
|
def ensure_in_trust_level_group
|
|
Group.user_trust_level_change!(id, trust_level)
|
|
end
|
|
|
|
def create_user_stat
|
|
UserStat.create!(new_since: Time.zone.now, user_id: id)
|
|
end
|
|
|
|
def create_user_option
|
|
UserOption.create!(user_id: id)
|
|
end
|
|
|
|
def create_email_token
|
|
email_tokens.create!(email: email, scope: EmailToken.scopes[:signup])
|
|
end
|
|
|
|
def ensure_password_is_hashed
|
|
if @raw_password
|
|
self.salt = SecureRandom.hex(16)
|
|
self.password_hash = hash_password(@raw_password, salt)
|
|
end
|
|
end
|
|
|
|
def expire_tokens_if_password_changed
|
|
# NOTE: setting raw password is the only valid way of changing a password
|
|
# the password field in the DB is actually hashed, nobody should be amending direct
|
|
if @raw_password
|
|
# Association in model may be out-of-sync
|
|
UserAuthToken.where(user_id: id).destroy_all
|
|
# We should not carry this around after save
|
|
@raw_password = nil
|
|
@password_required = false
|
|
end
|
|
end
|
|
|
|
def hash_password(password, salt)
|
|
raise StandardError.new("password is too long") if password.size > User.max_password_length
|
|
Pbkdf2.hash_password(
|
|
password,
|
|
salt,
|
|
Rails.configuration.pbkdf2_iterations,
|
|
Rails.configuration.pbkdf2_algorithm,
|
|
)
|
|
end
|
|
|
|
def add_trust_level
|
|
# there is a possibility we did not load trust level column, skip it
|
|
return unless has_attribute? :trust_level
|
|
self.trust_level ||= SiteSetting.default_trust_level
|
|
end
|
|
|
|
def update_usernames
|
|
self.username.unicode_normalize!
|
|
self.username_lower = username.downcase
|
|
end
|
|
|
|
USERNAME_EXISTS_SQL = <<~SQL
|
|
(SELECT users.id AS id, true as is_user FROM users
|
|
WHERE users.username_lower = :username)
|
|
|
|
UNION ALL
|
|
|
|
(SELECT groups.id, false as is_user FROM groups
|
|
WHERE lower(groups.name) = :username)
|
|
SQL
|
|
|
|
def self.username_exists?(username)
|
|
username = normalize_username(username)
|
|
DB.exec(User::USERNAME_EXISTS_SQL, username: username) > 0
|
|
end
|
|
|
|
def username_validator
|
|
username_format_validator ||
|
|
begin
|
|
if will_save_change_to_username?
|
|
existing =
|
|
DB.query(USERNAME_EXISTS_SQL, username: self.class.normalize_username(username))
|
|
|
|
user_id = existing.select { |u| u.is_user }.first&.id
|
|
same_user = user_id && user_id == self.id
|
|
|
|
errors.add(:username, I18n.t(:"user.username.unique")) if existing.present? && !same_user
|
|
|
|
if confirm_password?(username) || confirm_password?(username.downcase)
|
|
errors.add(:username, :same_as_password)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def name_validator
|
|
if name.present?
|
|
name_pw = name[0...User.max_password_length]
|
|
if confirm_password?(name_pw) || confirm_password?(name_pw.downcase)
|
|
errors.add(:name, :same_as_password)
|
|
end
|
|
end
|
|
end
|
|
|
|
def set_default_categories_preferences
|
|
return if self.staged?
|
|
|
|
values = []
|
|
|
|
# The following site settings are used to pre-populate default category
|
|
# tracking settings for a user:
|
|
#
|
|
# * default_categories_watching
|
|
# * default_categories_tracking
|
|
# * default_categories_watching_first_post
|
|
# * default_categories_normal
|
|
# * default_categories_muted
|
|
%w[watching watching_first_post tracking normal muted].each do |setting|
|
|
category_ids = SiteSetting.get("default_categories_#{setting}").split("|").map(&:to_i)
|
|
category_ids.each do |category_id|
|
|
next if category_id == 0
|
|
values << {
|
|
user_id: self.id,
|
|
category_id: category_id,
|
|
notification_level: CategoryUser.notification_levels[setting.to_sym],
|
|
}
|
|
end
|
|
end
|
|
|
|
CategoryUser.insert_all!(values) if values.present?
|
|
end
|
|
|
|
def set_default_tags_preferences
|
|
return if self.staged?
|
|
|
|
values = []
|
|
|
|
# The following site settings are used to pre-populate default tag
|
|
# tracking settings for a user:
|
|
#
|
|
# * default_tags_watching
|
|
# * default_tags_tracking
|
|
# * default_tags_watching_first_post
|
|
# * default_tags_muted
|
|
%w[watching watching_first_post tracking muted].each do |setting|
|
|
tag_names = SiteSetting.get("default_tags_#{setting}").split("|")
|
|
now = Time.zone.now
|
|
|
|
Tag
|
|
.where(name: tag_names)
|
|
.pluck(:id)
|
|
.each do |tag_id|
|
|
values << {
|
|
user_id: self.id,
|
|
tag_id: tag_id,
|
|
notification_level: TagUser.notification_levels[setting.to_sym],
|
|
created_at: now,
|
|
updated_at: now,
|
|
}
|
|
end
|
|
end
|
|
|
|
TagUser.insert_all!(values) if values.present?
|
|
end
|
|
|
|
def self.purge_unactivated
|
|
return [] if SiteSetting.purge_unactivated_users_grace_period_days <= 0
|
|
|
|
destroyer = UserDestroyer.new(Discourse.system_user)
|
|
|
|
User
|
|
.where(active: false)
|
|
.where("created_at < ?", SiteSetting.purge_unactivated_users_grace_period_days.days.ago)
|
|
.where("NOT admin AND NOT moderator")
|
|
.where(
|
|
"NOT EXISTS
|
|
(SELECT 1 FROM topic_allowed_users tu JOIN topics t ON t.id = tu.topic_id AND t.user_id > 0 WHERE tu.user_id = users.id LIMIT 1)
|
|
",
|
|
)
|
|
.where(
|
|
"NOT EXISTS
|
|
(SELECT 1 FROM posts p WHERE p.user_id = users.id LIMIT 1)
|
|
",
|
|
)
|
|
.limit(200)
|
|
.find_each do |user|
|
|
begin
|
|
destroyer.destroy(user, context: I18n.t(:purge_reason))
|
|
rescue Discourse::InvalidAccess
|
|
# keep going
|
|
end
|
|
end
|
|
end
|
|
|
|
def match_primary_group_changes
|
|
return unless primary_group_id_changed?
|
|
|
|
if title == Group.where(id: primary_group_id_was).pluck_first(:title)
|
|
self.title = primary_group&.title
|
|
end
|
|
|
|
self.flair_group_id = primary_group&.id if flair_group_id == primary_group_id_was
|
|
end
|
|
|
|
def self.first_login_admin_id
|
|
User
|
|
.where(admin: true)
|
|
.human_users
|
|
.joins(:user_auth_tokens)
|
|
.order("user_auth_tokens.created_at")
|
|
.pluck_first(:id)
|
|
end
|
|
|
|
private
|
|
|
|
def set_default_sidebar_section_links(update: false)
|
|
return if SiteSetting.legacy_navigation_menu?
|
|
return if staged? || bot?
|
|
|
|
if SiteSetting.default_sidebar_categories.present?
|
|
categories_to_update = SiteSetting.default_sidebar_categories.split("|")
|
|
|
|
if update
|
|
filtered_default_category_ids =
|
|
Category.secured(self.guardian).where(id: categories_to_update).pluck(:id)
|
|
existing_category_ids =
|
|
SidebarSectionLink.where(user: self, linkable_type: "Category").pluck(:linkable_id)
|
|
|
|
categories_to_update =
|
|
existing_category_ids + (filtered_default_category_ids & self.secure_category_ids)
|
|
end
|
|
|
|
SidebarSectionLinksUpdater.update_category_section_links(
|
|
self,
|
|
category_ids: categories_to_update,
|
|
)
|
|
end
|
|
|
|
if SiteSetting.tagging_enabled && SiteSetting.default_sidebar_tags.present?
|
|
tags_to_update = SiteSetting.default_sidebar_tags.split("|")
|
|
|
|
if update
|
|
default_tag_ids = Tag.where(name: tags_to_update).pluck(:id)
|
|
filtered_default_tags =
|
|
DiscourseTagging
|
|
.filter_visible(Tag, self.guardian)
|
|
.where(id: default_tag_ids)
|
|
.pluck(:name)
|
|
|
|
existing_tag_ids =
|
|
SidebarSectionLink.where(user: self, linkable_type: "Tag").pluck(:linkable_id)
|
|
existing_tags =
|
|
DiscourseTagging
|
|
.filter_visible(Tag, self.guardian)
|
|
.where(id: existing_tag_ids)
|
|
.pluck(:name)
|
|
|
|
tags_to_update = existing_tags + (filtered_default_tags & DiscourseTagging.hidden_tag_names)
|
|
end
|
|
|
|
SidebarSectionLinksUpdater.update_tag_section_links(self, tag_names: tags_to_update)
|
|
end
|
|
end
|
|
|
|
def add_default_sidebar_section_links
|
|
set_default_sidebar_section_links
|
|
end
|
|
|
|
def update_default_sidebar_section_links
|
|
set_default_sidebar_section_links(update: true)
|
|
end
|
|
|
|
def stat
|
|
user_stat || create_user_stat
|
|
end
|
|
|
|
def trigger_user_automatic_group_refresh
|
|
Group.user_trust_level_change!(id, trust_level) if !staged
|
|
true
|
|
end
|
|
|
|
def trigger_user_updated_event
|
|
DiscourseEvent.trigger(:user_updated, self)
|
|
true
|
|
end
|
|
|
|
def check_if_title_is_badged_granted
|
|
if title_changed? && !new_record? && user_profile
|
|
badge_matching_title =
|
|
title &&
|
|
badges.find do |badge|
|
|
badge.allow_title? && (badge.display_name == title || badge.name == title)
|
|
end
|
|
user_profile.update(
|
|
badge_granted_title: badge_matching_title.present?,
|
|
granted_title_badge_id: badge_matching_title&.id,
|
|
)
|
|
end
|
|
end
|
|
|
|
def previous_visit_at_update_required?(timestamp)
|
|
seen_before? && (last_seen_at < (timestamp - SiteSetting.previous_visit_timeout_hours.hours))
|
|
end
|
|
|
|
def update_previous_visit(timestamp)
|
|
update_visit_record!(timestamp.to_date)
|
|
update_column(:previous_visit_at, last_seen_at) if previous_visit_at_update_required?(timestamp)
|
|
end
|
|
|
|
def trigger_user_created_event
|
|
DiscourseEvent.trigger(:user_created, self)
|
|
true
|
|
end
|
|
|
|
def trigger_user_destroyed_event
|
|
DiscourseEvent.trigger(:user_destroyed, self)
|
|
true
|
|
end
|
|
|
|
def set_skip_validate_email
|
|
self.primary_email.skip_validate_email = !should_validate_email_address? if self.primary_email
|
|
|
|
true
|
|
end
|
|
|
|
def check_site_contact_username
|
|
if (saved_change_to_admin? || saved_change_to_moderator?) &&
|
|
self.username == SiteSetting.site_contact_username && !staff?
|
|
SiteSetting.set_and_log(:site_contact_username, SiteSetting.defaults[:site_contact_username])
|
|
end
|
|
end
|
|
|
|
def self.ensure_consistency!
|
|
DB.exec <<~SQL
|
|
UPDATE users
|
|
SET uploaded_avatar_id = NULL
|
|
WHERE uploaded_avatar_id IN (
|
|
SELECT u1.uploaded_avatar_id FROM users u1
|
|
LEFT JOIN uploads up
|
|
ON u1.uploaded_avatar_id = up.id
|
|
WHERE u1.uploaded_avatar_id IS NOT NULL AND
|
|
up.id IS NULL
|
|
)
|
|
SQL
|
|
end
|
|
end
|
|
|
|
# == Schema Information
|
|
#
|
|
# Table name: users
|
|
#
|
|
# id :integer not null, primary key
|
|
# username :string(60) not null
|
|
# created_at :datetime not null
|
|
# updated_at :datetime not null
|
|
# name :string
|
|
# seen_notification_id :integer default(0), not null
|
|
# last_posted_at :datetime
|
|
# password_hash :string(64)
|
|
# salt :string(32)
|
|
# active :boolean default(FALSE), not null
|
|
# username_lower :string(60) not null
|
|
# last_seen_at :datetime
|
|
# admin :boolean default(FALSE), not null
|
|
# last_emailed_at :datetime
|
|
# trust_level :integer not null
|
|
# approved :boolean default(FALSE), not null
|
|
# approved_by_id :integer
|
|
# approved_at :datetime
|
|
# previous_visit_at :datetime
|
|
# suspended_at :datetime
|
|
# suspended_till :datetime
|
|
# date_of_birth :date
|
|
# views :integer default(0), not null
|
|
# flag_level :integer default(0), not null
|
|
# ip_address :inet
|
|
# moderator :boolean default(FALSE)
|
|
# title :string
|
|
# uploaded_avatar_id :integer
|
|
# locale :string(10)
|
|
# primary_group_id :integer
|
|
# registration_ip_address :inet
|
|
# staged :boolean default(FALSE), not null
|
|
# first_seen_at :datetime
|
|
# silenced_till :datetime
|
|
# group_locked_trust_level :integer
|
|
# manual_locked_trust_level :integer
|
|
# secure_identifier :string
|
|
# flair_group_id :integer
|
|
# last_seen_reviewable_id :integer
|
|
#
|
|
# Indexes
|
|
#
|
|
# idx_users_admin (id) WHERE admin
|
|
# idx_users_moderator (id) WHERE moderator
|
|
# index_users_on_last_posted_at (last_posted_at)
|
|
# index_users_on_last_seen_at (last_seen_at)
|
|
# index_users_on_secure_identifier (secure_identifier) UNIQUE
|
|
# index_users_on_uploaded_avatar_id (uploaded_avatar_id)
|
|
# index_users_on_username (username) UNIQUE
|
|
# index_users_on_username_lower (username_lower) UNIQUE
|
|
#
|