debian-mirror-gitlab/app/models/user.rb

884 lines
26 KiB
Ruby
Raw Normal View History

2014-09-02 18:07:02 +05:30
require 'carrierwave/orm/activerecord'
class User < ActiveRecord::Base
2015-04-26 12:48:37 +05:30
extend Gitlab::ConfigHelper
2015-09-11 14:41:01 +05:30
include Gitlab::ConfigHelper
2015-04-26 12:48:37 +05:30
include Gitlab::CurrentSettings
2015-09-11 14:41:01 +05:30
include Referable
include Sortable
2015-10-24 18:46:33 +05:30
include CaseSensitivity
2015-12-23 02:04:40 +05:30
include TokenAuthenticatable
DEFAULT_NOTIFICATION_LEVEL = :participating
2015-12-23 02:04:40 +05:30
add_authentication_token_field :authentication_token
2014-09-02 18:07:02 +05:30
default_value_for :admin, false
2016-06-02 11:05:42 +05:30
default_value_for :external, false
2014-09-02 18:07:02 +05:30
default_value_for :can_create_group, gitlab_config.default_can_create_group
default_value_for :can_create_team, false
default_value_for :hide_no_ssh_key, false
2015-04-26 12:48:37 +05:30
default_value_for :hide_no_password, false
2014-09-02 18:07:02 +05:30
default_value_for :theme_id, gitlab_config.default_theme
attr_encrypted :otp_secret,
key: Gitlab::Application.config.secret_key_base,
mode: :per_attribute_iv_and_salt,
algorithm: 'aes-256-cbc'
2015-09-11 14:41:01 +05:30
devise :two_factor_authenticatable,
2016-06-02 11:05:42 +05:30
otp_secret_encryption_key: Gitlab::Application.config.secret_key_base
2015-09-11 14:41:01 +05:30
devise :two_factor_backupable, otp_number_of_backup_codes: 10
serialize :otp_backup_codes, JSON
devise :lockable, :recoverable, :rememberable, :trackable,
2015-09-11 14:41:01 +05:30
:validatable, :omniauthable, :confirmable, :registerable
2014-09-02 18:07:02 +05:30
attr_accessor :force_random_password
# Virtual attribute for authenticating by either username or email
attr_accessor :login
#
# Relations
#
# Namespace for personal projects
has_one :namespace, -> { where type: nil }, dependent: :destroy, foreign_key: :owner_id, class_name: "Namespace"
# Profile
has_many :keys, dependent: :destroy
has_many :emails, dependent: :destroy
2016-06-22 15:30:34 +05:30
has_many :personal_access_tokens, dependent: :destroy
2015-09-25 12:07:36 +05:30
has_many :identities, dependent: :destroy, autosave: true
has_many :u2f_registrations, dependent: :destroy
2014-09-02 18:07:02 +05:30
# Groups
2015-04-26 12:48:37 +05:30
has_many :members, dependent: :destroy
has_many :group_members, dependent: :destroy, source: 'GroupMember'
2015-04-26 12:48:37 +05:30
has_many :groups, through: :group_members
has_many :owned_groups, -> { where members: { access_level: Gitlab::Access::OWNER } }, through: :group_members, source: :group
has_many :masters_groups, -> { where members: { access_level: Gitlab::Access::MASTER } }, through: :group_members, source: :group
2014-09-02 18:07:02 +05:30
# Projects
has_many :groups_projects, through: :groups, source: :projects
has_many :personal_projects, through: :namespace, source: :projects
has_many :project_members, dependent: :destroy, class_name: 'ProjectMember'
2015-04-26 12:48:37 +05:30
has_many :projects, through: :project_members
2014-09-02 18:07:02 +05:30
has_many :created_projects, foreign_key: :creator_id, class_name: 'Project'
has_many :users_star_projects, dependent: :destroy
has_many :starred_projects, through: :users_star_projects, source: :project
has_many :snippets, dependent: :destroy, foreign_key: :author_id, class_name: "Snippet"
has_many :issues, dependent: :destroy, foreign_key: :author_id
has_many :notes, dependent: :destroy, foreign_key: :author_id
has_many :merge_requests, dependent: :destroy, foreign_key: :author_id
has_many :events, dependent: :destroy, foreign_key: :author_id, class_name: "Event"
2015-04-26 12:48:37 +05:30
has_many :subscriptions, dependent: :destroy
2014-09-02 18:07:02 +05:30
has_many :recent_events, -> { order "id DESC" }, foreign_key: :author_id, class_name: "Event"
has_many :assigned_issues, dependent: :destroy, foreign_key: :assignee_id, class_name: "Issue"
has_many :assigned_merge_requests, dependent: :destroy, foreign_key: :assignee_id, class_name: "MergeRequest"
2015-04-26 12:48:37 +05:30
has_many :oauth_applications, class_name: 'Doorkeeper::Application', as: :owner, dependent: :destroy
2015-10-24 18:46:33 +05:30
has_one :abuse_report, dependent: :destroy
2016-04-02 18:10:28 +05:30
has_many :spam_logs, dependent: :destroy
2015-12-23 02:04:40 +05:30
has_many :builds, dependent: :nullify, class_name: 'Ci::Build'
2016-04-02 18:10:28 +05:30
has_many :todos, dependent: :destroy
2016-06-02 11:05:42 +05:30
has_many :notification_settings, dependent: :destroy
has_many :award_emoji, as: :awardable, dependent: :destroy
2014-09-02 18:07:02 +05:30
#
# Validations
#
validates :name, presence: true
2016-04-02 18:10:28 +05:30
validates :notification_email, presence: true, email: true
validates :public_email, presence: true, uniqueness: true, email: true, allow_blank: true
2014-09-02 18:07:02 +05:30
validates :bio, length: { maximum: 255 }, allow_blank: true
2015-04-26 12:48:37 +05:30
validates :projects_limit, presence: true, numericality: { greater_than_or_equal_to: 0 }
validates :username,
2015-12-23 02:04:40 +05:30
namespace: true,
2015-04-26 12:48:37 +05:30
presence: true,
2015-12-23 02:04:40 +05:30
uniqueness: { case_sensitive: false }
2014-09-02 18:07:02 +05:30
validate :namespace_uniq, if: ->(user) { user.username_changed? }
2015-09-11 14:41:01 +05:30
validate :avatar_type, if: ->(user) { user.avatar.present? && user.avatar_changed? }
2014-09-02 18:07:02 +05:30
validate :unique_email, if: ->(user) { user.email_changed? }
2015-04-26 12:48:37 +05:30
validate :owns_notification_email, if: ->(user) { user.notification_email_changed? }
2015-09-11 14:41:01 +05:30
validate :owns_public_email, if: ->(user) { user.public_email_changed? }
2015-04-26 12:48:37 +05:30
validates :avatar, file_size: { maximum: 200.kilobytes.to_i }
2014-09-02 18:07:02 +05:30
before_validation :generate_password, on: :create
2015-09-11 14:41:01 +05:30
before_validation :restricted_signup_domains, on: :create
2014-09-02 18:07:02 +05:30
before_validation :sanitize_attrs
2015-04-26 12:48:37 +05:30
before_validation :set_notification_email, if: ->(user) { user.email_changed? }
before_validation :set_public_email, if: ->(user) { user.public_email_changed? }
2014-09-02 18:07:02 +05:30
2015-09-11 14:41:01 +05:30
after_update :update_emails_with_primary_email, if: ->(user) { user.email_changed? }
2014-09-02 18:07:02 +05:30
before_save :ensure_authentication_token
2016-06-02 11:05:42 +05:30
before_save :ensure_external_user_rights
2014-09-02 18:07:02 +05:30
after_save :ensure_namespace_correct
2015-04-26 12:48:37 +05:30
after_initialize :set_projects_limit
2016-06-02 11:05:42 +05:30
before_create :check_confirmation_email
2014-09-02 18:07:02 +05:30
after_create :post_create_hook
after_destroy :post_destroy_hook
2015-10-24 18:46:33 +05:30
# User's Layout preference
enum layout: [:fixed, :fluid]
2015-09-11 14:41:01 +05:30
# User's Dashboard preference
# Note: When adding an option, it MUST go on the end of the array.
2016-06-02 11:05:42 +05:30
enum dashboard: [:projects, :stars, :project_activity, :starred_project_activity, :groups, :todos]
2015-09-11 14:41:01 +05:30
# User's Project preference
# Note: When adding an option, it MUST go on the end of the array.
2015-11-26 14:37:03 +05:30
enum project_view: [:readme, :activity, :files]
2014-09-02 18:07:02 +05:30
alias_attribute :private_token, :authentication_token
delegate :path, to: :namespace, allow_nil: true, prefix: true
state_machine :state, initial: :active do
event :block do
transition active: :blocked
transition ldap_blocked: :blocked
end
event :ldap_block do
transition active: :ldap_blocked
2014-09-02 18:07:02 +05:30
end
event :activate do
transition blocked: :active
transition ldap_blocked: :active
end
state :blocked, :ldap_blocked do
def blocked?
true
end
2014-09-02 18:07:02 +05:30
end
end
2015-04-26 12:48:37 +05:30
mount_uploader :avatar, AvatarUploader
2014-09-02 18:07:02 +05:30
# Scopes
2015-09-11 14:41:01 +05:30
scope :admins, -> { where(admin: true) }
scope :blocked, -> { with_states(:blocked, :ldap_blocked) }
2016-06-02 11:05:42 +05:30
scope :external, -> { where(external: true) }
2014-09-02 18:07:02 +05:30
scope :active, -> { with_state(:active) }
scope :not_in_project, ->(project) { project.users.present? ? where("id not in (:ids)", ids: project.users.map(&:id) ) : all }
2015-04-26 12:48:37 +05:30
scope :without_projects, -> { where('id NOT IN (SELECT DISTINCT(user_id) FROM members)') }
def self.with_two_factor
joins("LEFT OUTER JOIN u2f_registrations AS u2f ON u2f.user_id = users.id").
where("u2f.id IS NOT NULL OR otp_required_for_login = ?", true).distinct(arel_table[:id])
end
def self.without_two_factor
joins("LEFT OUTER JOIN u2f_registrations AS u2f ON u2f.user_id = users.id").
where("u2f.id IS NULL AND otp_required_for_login = ?", false)
end
2014-09-02 18:07:02 +05:30
#
# Class methods
#
class << self
# Devise method overridden to allow sign in with email or username
def find_for_database_authentication(warden_conditions)
conditions = warden_conditions.dup
if login = conditions.delete(:login)
2015-12-23 02:04:40 +05:30
where(conditions).find_by("lower(username) = :value OR lower(email) = :value", value: login.downcase)
2014-09-02 18:07:02 +05:30
else
2015-12-23 02:04:40 +05:30
find_by(conditions)
2014-09-02 18:07:02 +05:30
end
end
2015-04-26 12:48:37 +05:30
def sort(method)
case method.to_s
when 'recent_sign_in' then reorder(last_sign_in_at: :desc)
when 'oldest_sign_in' then reorder(last_sign_in_at: :asc)
else
order_by(method)
end
end
2015-09-11 14:41:01 +05:30
# Find a User by their primary email or any associated secondary email
def find_by_any_email(email)
2015-11-26 14:37:03 +05:30
sql = 'SELECT *
FROM users
WHERE id IN (
SELECT id FROM users WHERE email = :email
UNION
SELECT emails.user_id FROM emails WHERE email = :email
)
LIMIT 1;'
User.find_by_sql([sql, { email: email }]).first
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
def filter(filter_name)
2014-09-02 18:07:02 +05:30
case filter_name
2015-09-11 14:41:01 +05:30
when 'admins'
self.admins
when 'blocked'
self.blocked
when 'two_factor_disabled'
self.without_two_factor
when 'two_factor_enabled'
self.with_two_factor
when 'wop'
self.without_projects
2016-06-02 11:05:42 +05:30
when 'external'
self.external
2014-09-02 18:07:02 +05:30
else
self.active
end
end
2016-06-02 11:05:42 +05:30
# Searches users matching the given query.
#
# This method uses ILIKE on PostgreSQL and LIKE on MySQL.
#
# query - The search query as a String
#
# Returns an ActiveRecord::Relation.
2015-04-26 12:48:37 +05:30
def search(query)
2016-06-02 11:05:42 +05:30
table = arel_table
pattern = "%#{query}%"
where(
table[:name].matches(pattern).
or(table[:email].matches(pattern)).
or(table[:username].matches(pattern))
)
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
def by_login(login)
2015-10-24 18:46:33 +05:30
return nil unless login
if login.include?('@'.freeze)
unscoped.iwhere(email: login).take
else
unscoped.iwhere(username: login).take
end
2015-04-26 12:48:37 +05:30
end
2015-09-11 14:41:01 +05:30
def find_by_username!(username)
find_by!('lower(username) = ?', username.downcase)
end
2016-06-22 15:30:34 +05:30
def find_by_personal_access_token(token_string)
personal_access_token = PersonalAccessToken.active.find_by_token(token_string) if token_string
personal_access_token.user if personal_access_token
end
2014-09-02 18:07:02 +05:30
def by_username_or_id(name_or_id)
2015-12-23 02:04:40 +05:30
find_by('users.username = ? OR users.id = ?', name_or_id.to_s, name_or_id.to_i)
2014-09-02 18:07:02 +05:30
end
def build_user(attrs = {})
User.new(attrs)
end
2015-09-11 14:41:01 +05:30
def reference_prefix
'@'
end
# Pattern used to extract `@user` user references from text
def reference_pattern
%r{
#{Regexp.escape(reference_prefix)}
(?<user>#{Gitlab::Regex::NAMESPACE_REGEX_STR})
}x
end
2014-09-02 18:07:02 +05:30
end
#
# Instance methods
#
def to_param
username
end
2015-09-11 14:41:01 +05:30
def to_reference(_from_project = nil)
"#{self.class.reference_prefix}#{username}"
end
2014-09-02 18:07:02 +05:30
def generate_password
if self.force_random_password
self.password = self.password_confirmation = Devise.friendly_token.first(8)
end
end
def generate_reset_token
@reset_token, enc = Devise.token_generator.generate(self.class, :reset_password_token)
self.reset_password_token = enc
self.reset_password_sent_at = Time.now.utc
@reset_token
end
2016-06-02 11:05:42 +05:30
def check_confirmation_email
skip_confirmation! unless current_application_settings.send_user_confirmation_email
end
2015-10-24 18:46:33 +05:30
def recently_sent_password_reset?
reset_password_sent_at.present? && reset_password_sent_at >= 1.minute.ago
end
2015-09-11 14:41:01 +05:30
def disable_two_factor!
transaction do
update_attributes(
otp_required_for_login: false,
encrypted_otp_secret: nil,
encrypted_otp_secret_iv: nil,
encrypted_otp_secret_salt: nil,
otp_grace_period_started_at: nil,
otp_backup_codes: nil
)
self.u2f_registrations.destroy_all
end
end
def two_factor_enabled?
two_factor_otp_enabled? || two_factor_u2f_enabled?
end
def two_factor_otp_enabled?
self.otp_required_for_login?
end
def two_factor_u2f_enabled?
self.u2f_registrations.exists?
2015-09-11 14:41:01 +05:30
end
2014-09-02 18:07:02 +05:30
def namespace_uniq
# Return early if username already failed the first uniqueness validation
2016-06-02 11:05:42 +05:30
return if self.errors.key?(:username) &&
self.errors[:username].include?('has already been taken')
2014-09-02 18:07:02 +05:30
namespace_name = self.username
2015-04-26 12:48:37 +05:30
existing_namespace = Namespace.by_path(namespace_name)
if existing_namespace && existing_namespace != self.namespace
self.errors.add(:username, 'has already been taken')
2014-09-02 18:07:02 +05:30
end
end
def avatar_type
unless self.avatar.image?
self.errors.add :avatar, "only images allowed"
end
end
def unique_email
2015-09-11 14:41:01 +05:30
if !self.emails.exists?(email: self.email) && Email.exists?(email: self.email)
self.errors.add(:email, 'has already been taken')
end
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
def owns_notification_email
2016-06-02 11:05:42 +05:30
return if self.temp_oauth_email?
2015-04-26 12:48:37 +05:30
self.errors.add(:notification_email, "is not an email you own") unless self.all_emails.include?(self.notification_email)
end
2015-09-11 14:41:01 +05:30
def owns_public_email
return if self.public_email.blank?
self.errors.add(:public_email, "is not an email you own") unless self.all_emails.include?(self.public_email)
end
def update_emails_with_primary_email
primary_email_record = self.emails.find_by(email: self.email)
if primary_email_record
primary_email_record.destroy
self.emails.create(email: self.email_was)
self.update_secondary_emails!
end
end
2015-11-26 14:37:03 +05:30
# Returns the groups a user has access to
2014-09-02 18:07:02 +05:30
def authorized_groups
2015-11-26 14:37:03 +05:30
union = Gitlab::SQL::Union.
new([groups.select(:id), authorized_projects.select(:namespace_id)])
2014-09-02 18:07:02 +05:30
2015-11-26 14:37:03 +05:30
Group.where("namespaces.id IN (#{union.to_sql})")
end
2014-09-02 18:07:02 +05:30
2016-06-02 11:05:42 +05:30
# Returns projects user is authorized to access.
def authorized_projects(min_access_level = nil)
Project.where("projects.id IN (#{projects_union(min_access_level).to_sql})")
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
def viewable_starred_projects
starred_projects.where("projects.visibility_level IN (?) OR projects.id IN (#{projects_union.to_sql})",
[Project::PUBLIC, Project::INTERNAL])
end
2014-09-02 18:07:02 +05:30
def owned_projects
2015-09-11 14:41:01 +05:30
@owned_projects ||=
2015-11-26 14:37:03 +05:30
Project.where('namespace_id IN (?) OR namespace_id = ?',
owned_groups.select(:id), namespace.id).joins(:namespace)
2014-09-02 18:07:02 +05:30
end
def is_admin?
admin
end
def require_ssh_key?
keys.count == 0
end
2015-04-26 12:48:37 +05:30
def require_password?
password_automatically_set? && !ldap_user?
end
2014-09-02 18:07:02 +05:30
def can_change_username?
gitlab_config.username_changing_enabled
end
def can_create_project?
projects_limit_left > 0
end
def can_create_group?
can?(:create_group, nil)
end
def abilities
2015-04-26 12:48:37 +05:30
Ability.abilities
2014-09-02 18:07:02 +05:30
end
def can_select_namespace?
several_namespaces? || admin
end
2015-04-26 12:48:37 +05:30
def can?(action, subject)
2014-09-02 18:07:02 +05:30
abilities.allowed?(self, action, subject)
end
def first_name
name.split.first unless name.blank?
end
def cared_merge_requests
MergeRequest.cared(self)
end
def projects_limit_left
projects_limit - personal_projects.count
end
def projects_limit_percent
return 100 if projects_limit.zero?
(personal_projects.count.to_f / projects_limit) * 100
end
2015-04-26 12:48:37 +05:30
def recent_push(project_id = nil)
2014-09-02 18:07:02 +05:30
# Get push events not earlier than 2 hours ago
events = recent_events.code_push.where("created_at > ?", Time.now - 2.hours)
events = events.where(project_id: project_id) if project_id
2015-09-25 12:07:36 +05:30
# Use the latest event that has not been pushed or merged recently
events.recent.find do |event|
project = Project.find_by_id(event.project_id)
next unless project
2016-06-22 15:30:34 +05:30
if project.repository.branch_exists?(event.branch_name)
2015-09-25 12:07:36 +05:30
merge_requests = MergeRequest.where("created_at >= ?", event.created_at).
where(source_project_id: project.id,
source_branch: event.branch_name)
merge_requests.empty?
end
end
2014-09-02 18:07:02 +05:30
end
def projects_sorted_by_activity
authorized_projects.sorted_by_activity
end
def several_namespaces?
owned_groups.any? || masters_groups.any?
end
def namespace_id
namespace.try :id
end
def name_with_username
"#{name} (#{username})"
end
2015-04-26 12:48:37 +05:30
def already_forked?(project)
2014-09-02 18:07:02 +05:30
!!fork_of(project)
end
2015-04-26 12:48:37 +05:30
def fork_of(project)
2014-09-02 18:07:02 +05:30
links = ForkedProjectLink.where(forked_from_project_id: project, forked_to_project_id: personal_projects)
if links.any?
links.first.forked_to_project
else
nil
end
end
def ldap_user?
2015-04-26 12:48:37 +05:30
identities.exists?(["provider LIKE ? AND extern_uid IS NOT NULL", "ldap%"])
end
def ldap_identity
@ldap_identity ||= identities.find_by(["provider LIKE ?", "ldap%"])
end
def project_deploy_keys
2015-09-11 14:41:01 +05:30
DeployKey.unscoped.in_projects(self.authorized_projects.pluck(:id)).distinct(:id)
2014-09-02 18:07:02 +05:30
end
def accessible_deploy_keys
2015-04-26 12:48:37 +05:30
@accessible_deploy_keys ||= begin
key_ids = project_deploy_keys.pluck(:id)
key_ids.push(*DeployKey.are_public.pluck(:id))
DeployKey.where(id: key_ids)
end
2014-09-02 18:07:02 +05:30
end
def created_by
User.find_by(id: created_by_id) if created_by_id
end
def sanitize_attrs
2015-09-11 14:41:01 +05:30
%w(name username skype linkedin twitter).each do |attr|
2014-09-02 18:07:02 +05:30
value = self.send(attr)
self.send("#{attr}=", Sanitize.clean(value)) if value.present?
end
end
2015-04-26 12:48:37 +05:30
def set_notification_email
if self.notification_email.blank? || !self.all_emails.include?(self.notification_email)
self.notification_email = self.email
end
end
def set_public_email
if self.public_email.blank? || !self.all_emails.include?(self.public_email)
self.public_email = ''
end
end
2015-09-11 14:41:01 +05:30
def update_secondary_emails!
self.set_notification_email
self.set_public_email
self.save if self.notification_email_changed? || self.public_email_changed?
end
2015-04-26 12:48:37 +05:30
def set_projects_limit
connection_default_value_defined = new_record? && !projects_limit_changed?
return unless self.projects_limit.nil? || connection_default_value_defined
self.projects_limit = current_application_settings.default_projects_limit
end
2014-09-02 18:07:02 +05:30
def requires_ldap_check?
if !Gitlab.config.ldap.enabled
false
elsif ldap_user?
!last_credential_check_at || (last_credential_check_at + 1.hour) < Time.now
else
false
end
end
2016-04-02 18:10:28 +05:30
def try_obtain_ldap_lease
# After obtaining this lease LDAP checks will be blocked for 600 seconds
# (10 minutes) for this user.
lease = Gitlab::ExclusiveLease.new("user_ldap_check:#{id}", timeout: 600)
lease.try_obtain
end
2014-09-02 18:07:02 +05:30
def solo_owned_groups
@solo_owned_groups ||= owned_groups.select do |group|
group.owners == [self]
end
end
def with_defaults
User.defaults.each do |k, v|
self.send("#{k}=", v)
end
self
end
def can_leave_project?(project)
project.namespace != namespace &&
project.project_member(self)
end
# Reset project events cache related to this user
#
# Since we do cache @event we need to reset cache in special cases:
# * when the user changes their avatar
# Events cache stored like events/23-20130109142513.
# The cache key includes updated_at timestamp.
# Thus it will automatically generate a new fragment
# when the event is updated because the key changes.
def reset_events_cache
Event.where(author_id: self.id).
order('id DESC').limit(1000).
update_all(updated_at: Time.now)
end
def full_website_url
2015-04-26 12:48:37 +05:30
return "http://#{website_url}" if website_url !~ /\Ahttps?:\/\//
2014-09-02 18:07:02 +05:30
website_url
end
def short_website_url
2015-04-26 12:48:37 +05:30
website_url.sub(/\Ahttps?:\/\//, '')
2014-09-02 18:07:02 +05:30
end
def all_ssh_keys
2015-09-11 14:41:01 +05:30
keys.map(&:publishable_key)
2014-09-02 18:07:02 +05:30
end
def temp_oauth_email?
2015-04-26 12:48:37 +05:30
email.start_with?('temp-email-for-oauth')
2014-09-02 18:07:02 +05:30
end
2015-12-23 02:04:40 +05:30
def avatar_url(size = nil, scale = 2)
2014-09-02 18:07:02 +05:30
if avatar.present?
2015-04-26 12:48:37 +05:30
[gitlab_config.url, avatar.url].join
2014-09-02 18:07:02 +05:30
else
2015-12-23 02:04:40 +05:30
GravatarService.new.execute(email, size, scale)
2014-09-02 18:07:02 +05:30
end
end
2015-04-26 12:48:37 +05:30
def all_emails
2016-01-29 22:53:50 +05:30
all_emails = []
all_emails << self.email unless self.temp_oauth_email?
all_emails.concat(self.emails.map(&:email))
all_emails
2015-04-26 12:48:37 +05:30
end
def hook_attrs
{
name: name,
username: username,
avatar_url: avatar_url
}
end
2014-09-02 18:07:02 +05:30
def ensure_namespace_correct
# Ensure user has namespace
self.create_namespace!(path: self.username, name: self.username) unless self.namespace
if self.username_changed?
self.namespace.update_attributes(path: self.username, name: self.username)
end
end
def post_create_hook
log_info("User \"#{self.name}\" (#{self.email}) was created")
2015-04-26 12:48:37 +05:30
notification_service.new_user(self, @reset_token) if self.created_by_id
2014-09-02 18:07:02 +05:30
system_hook_service.execute_hooks_for(self, :create)
end
def post_destroy_hook
log_info("User \"#{self.name}\" (#{self.email}) was removed")
system_hook_service.execute_hooks_for(self, :destroy)
end
def notification_service
NotificationService.new
end
2015-04-26 12:48:37 +05:30
def log_info(message)
2014-09-02 18:07:02 +05:30
Gitlab::AppLogger.info message
end
def system_hook_service
SystemHooksService.new
end
def starred?(project)
2015-12-23 02:04:40 +05:30
starred_projects.exists?(project.id)
2014-09-02 18:07:02 +05:30
end
def toggle_star(project)
2015-11-26 14:37:03 +05:30
UsersStarProject.transaction do
user_star_project = users_star_projects.
where(project: project, user: self).lock(true).first
if user_star_project
user_star_project.destroy
else
UsersStarProject.create!(project: project, user: self)
end
2014-09-02 18:07:02 +05:30
end
end
2015-04-26 12:48:37 +05:30
def manageable_namespaces
2015-10-24 18:46:33 +05:30
@manageable_namespaces ||= [namespace] + owned_groups + masters_groups
2015-04-26 12:48:37 +05:30
end
2015-09-11 14:41:01 +05:30
def namespaces
namespace_ids = groups.pluck(:id)
namespace_ids.push(namespace.id)
Namespace.where(id: namespace_ids)
end
2015-04-26 12:48:37 +05:30
def oauth_authorized_tokens
Doorkeeper::AccessToken.where(resource_owner_id: self.id, revoked_at: nil)
end
2015-11-26 14:37:03 +05:30
# Returns the projects a user contributed to in the last year.
#
# This method relies on a subquery as this performs significantly better
# compared to a JOIN when coupled with, for example,
# `Project.visible_to_user`. That is, consider the following code:
#
# some_user.contributed_projects.visible_to_user(other_user)
#
# If this method were to use a JOIN the resulting query would take roughly 200
# ms on a database with a similar size to GitLab.com's database. On the other
# hand, using a subquery means we can get the exact same data in about 40 ms.
def contributed_projects
events = Event.select(:project_id).
contributions.where(author_id: self).
2015-04-26 12:48:37 +05:30
where("created_at > ?", Time.now - 1.year).
2015-11-26 14:37:03 +05:30
uniq.
reorder(nil)
Project.where(id: events)
2015-04-26 12:48:37 +05:30
end
2015-09-11 14:41:01 +05:30
def restricted_signup_domains
email_domains = current_application_settings.restricted_signup_domains
unless email_domains.blank?
match_found = email_domains.any? do |domain|
escaped = Regexp.escape(domain).gsub('\*','.*?')
regexp = Regexp.new "^#{escaped}$", Regexp::IGNORECASE
email_domain = Mail::Address.new(self.email).domain
email_domain =~ regexp
end
unless match_found
self.errors.add :email,
'is not whitelisted. ' +
'Email domains valid for registration are: ' +
email_domains.join(', ')
return false
end
end
true
end
def can_be_removed?
!solo_owned_groups.present?
end
2015-09-25 12:07:36 +05:30
2015-11-26 14:37:03 +05:30
def ci_authorized_runners
@ci_authorized_runners ||= begin
2015-12-23 02:04:40 +05:30
runner_ids = Ci::RunnerProject.
where("ci_runner_projects.gl_project_id IN (#{ci_projects_union.to_sql})").
2015-11-26 14:37:03 +05:30
select(:runner_id)
Ci::Runner.specific.where(id: runner_ids)
end
end
2016-06-02 11:05:42 +05:30
def notification_settings_for(source)
notification_settings.find_or_initialize_by(source: source)
end
# Lazy load global notification setting
# Initializes User setting with Participating level if setting not persisted
def global_notification_setting
return @global_notification_setting if defined?(@global_notification_setting)
@global_notification_setting = notification_settings.find_or_initialize_by(source: nil)
@global_notification_setting.update_attributes(level: NotificationSetting.levels[DEFAULT_NOTIFICATION_LEVEL]) unless @global_notification_setting.persisted?
@global_notification_setting
end
def assigned_open_merge_request_count(force: false)
Rails.cache.fetch(['users', id, 'assigned_open_merge_request_count'], force: force) do
assigned_merge_requests.opened.count
end
end
def assigned_open_issues_count(force: false)
Rails.cache.fetch(['users', id, 'assigned_open_issues_count'], force: force) do
assigned_issues.opened.count
end
end
def update_cache_counts
assigned_open_merge_request_count(force: true)
assigned_open_issues_count(force: true)
end
2016-06-22 15:30:34 +05:30
def todos_done_count(force: false)
Rails.cache.fetch(['users', id, 'todos_done_count'], force: force) do
todos.done.count
end
end
def todos_pending_count(force: false)
Rails.cache.fetch(['users', id, 'todos_pending_count'], force: force) do
todos.pending.count
end
end
def update_todos_count_cache
todos_done_count(force: true)
todos_pending_count(force: true)
end
2015-11-26 14:37:03 +05:30
private
def projects_union(min_access_level = nil)
relations = [personal_projects.select(:id),
groups_projects.select(:id),
projects.select(:id),
groups.joins(:shared_projects).select(:project_id)]
if min_access_level
scope = { access_level: Gitlab::Access.values.select { |access| access >= min_access_level } }
relations = [relations.shift] + relations.map { |relation| relation.where(members: scope) }
end
Gitlab::SQL::Union.new(relations)
2015-09-25 12:07:36 +05:30
end
2015-11-26 14:37:03 +05:30
def ci_projects_union
scope = { access_level: [Gitlab::Access::MASTER, Gitlab::Access::OWNER] }
groups = groups_projects.where(members: scope)
other = projects.where(members: scope)
Gitlab::SQL::Union.new([personal_projects.select(:id), groups.select(:id),
other.select(:id)])
2015-09-25 12:07:36 +05:30
end
2015-12-23 02:04:40 +05:30
# Added according to https://github.com/plataformatec/devise/blob/7df57d5081f9884849ca15e4fde179ef164a575f/README.md#activejob-integration
def send_devise_notification(notification, *args)
devise_mailer.send(notification, self, *args).deliver_later
end
2016-06-02 11:05:42 +05:30
def ensure_external_user_rights
return unless self.external?
self.can_create_group = false
self.projects_limit = 0
end
2014-09-02 18:07:02 +05:30
end