user.rb 24.2 KB
Newer Older
1 2 3 4
# == Schema Information
#
# Table name: users
#
Stan Hu's avatar
Stan Hu committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
#  id                         :integer          not null, primary key
#  email                      :string(255)      default(""), not null
#  encrypted_password         :string(255)      default(""), not null
#  reset_password_token       :string(255)
#  reset_password_sent_at     :datetime
#  remember_created_at        :datetime
#  sign_in_count              :integer          default(0)
#  current_sign_in_at         :datetime
#  last_sign_in_at            :datetime
#  current_sign_in_ip         :string(255)
#  last_sign_in_ip            :string(255)
#  created_at                 :datetime
#  updated_at                 :datetime
#  name                       :string(255)
#  admin                      :boolean          default(FALSE), not null
#  projects_limit             :integer          default(10)
#  skype                      :string(255)      default(""), not null
#  linkedin                   :string(255)      default(""), not null
#  twitter                    :string(255)      default(""), not null
#  authentication_token       :string(255)
#  theme_id                   :integer          default(1), not null
#  bio                        :string(255)
#  failed_attempts            :integer          default(0)
#  locked_at                  :datetime
#  username                   :string(255)
#  can_create_group           :boolean          default(TRUE), not null
#  can_create_team            :boolean          default(TRUE), not null
#  state                      :string(255)
#  color_scheme_id            :integer          default(1), not null
#  notification_level         :integer          default(1), not null
#  password_expires_at        :datetime
#  created_by_id              :integer
#  last_credential_check_at   :datetime
#  avatar                     :string(255)
#  confirmation_token         :string(255)
#  confirmed_at               :datetime
#  confirmation_sent_at       :datetime
#  unconfirmed_email          :string(255)
#  hide_no_ssh_key            :boolean          default(FALSE)
#  website_url                :string(255)      default(""), not null
#  notification_email         :string(255)
#  hide_no_password           :boolean          default(FALSE)
#  password_automatically_set :boolean          default(FALSE)
#  location                   :string(255)
#  encrypted_otp_secret       :string(255)
#  encrypted_otp_secret_iv    :string(255)
#  encrypted_otp_secret_salt  :string(255)
#  otp_required_for_login     :boolean          default(FALSE), not null
#  otp_backup_codes           :text
#  public_email               :string(255)      default(""), not null
#  dashboard                  :integer          default(0)
#  project_view               :integer          default(0)
57 58
#

59 60 61
require 'carrierwave/orm/activerecord'
require 'file_size_validator'

gitlabhq's avatar
gitlabhq committed
62
class User < ActiveRecord::Base
63
  extend Gitlab::ConfigHelper
64 65

  include Gitlab::ConfigHelper
66
  include Gitlab::CurrentSettings
67 68 69
  include Referable
  include Sortable
  include TokenAuthenticatable
70

71
  default_value_for :admin, false
72
  default_value_for :can_create_group, gitlab_config.default_can_create_group
73 74
  default_value_for :can_create_team, false
  default_value_for :hide_no_ssh_key, false
75
  default_value_for :hide_no_password, false
76
  default_value_for :theme_id, gitlab_config.default_theme
77

78 79
  devise :two_factor_authenticatable,
         otp_secret_encryption_key: File.read(Rails.root.join('.secret')).chomp
80
  alias_attribute :two_factor_enabled, :otp_required_for_login
81

82
  devise :two_factor_backupable, otp_number_of_backup_codes: 10
83 84
  serialize :otp_backup_codes, JSON

85 86
  devise :lockable, :async, :recoverable, :rememberable, :trackable,
    :validatable, :omniauthable, :confirmable, :registerable
gitlabhq's avatar
gitlabhq committed
87

88
  attr_accessor :force_random_password
gitlabhq's avatar
gitlabhq committed
89

90 91 92
  # Virtual attribute for authenticating by either username or email
  attr_accessor :login

93 94 95 96
  #
  # Relations
  #

97
  # Namespace for personal projects
98
  has_one :namespace, -> { where type: nil }, dependent: :destroy, foreign_key: :owner_id, class_name: "Namespace"
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
99

100 101
  # Profile
  has_many :keys, dependent: :destroy
102
  has_many :emails, dependent: :destroy
103
  has_many :identities, dependent: :destroy, autosave: true
104 105

  # Groups
106 107 108 109
  has_many :members, dependent: :destroy
  has_many :project_members, source: 'ProjectMember'
  has_many :group_members, source: 'GroupMember'
  has_many :groups, through: :group_members
110 111
  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
112

113
  # Projects
114 115
  has_many :groups_projects,          through: :groups, source: :projects
  has_many :personal_projects,        through: :namespace, source: :projects
116
  has_many :projects,                 through: :project_members
117
  has_many :created_projects,         foreign_key: :creator_id, class_name: 'Project'
Ciro Santilli's avatar
Ciro Santilli committed
118 119
  has_many :users_star_projects, dependent: :destroy
  has_many :starred_projects, through: :users_star_projects, source: :project
120

121
  has_many :snippets,                 dependent: :destroy, foreign_key: :author_id, class_name: "Snippet"
122
  has_many :project_members,          dependent: :destroy, class_name: 'ProjectMember'
123 124 125 126
  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"
127
  has_many :subscriptions,            dependent: :destroy
128
  has_many :recent_events, -> { order "id DESC" }, foreign_key: :author_id,   class_name: "Event"
129 130
  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"
Valery Sizov's avatar
Valery Sizov committed
131
  has_many :oauth_applications, class_name: 'Doorkeeper::Application', as: :owner, dependent: :destroy
132
  has_many :approvals, dependent: :destroy
133

134

135 136 137
  #
  # Validations
  #
Cyril's avatar
Cyril committed
138
  validates :name, presence: true
139
  # Note that a 'uniqueness' and presence check is provided by devise :validatable for email. We do not need to
140
  # duplicate that here as the validation framework will have duplicate errors in the event of a failure.
141
  validates :email, presence: true, email: { strict_mode: true }
142
  validates :notification_email, presence: true, email: { strict_mode: true }
143
  validates :public_email, presence: true, email: { strict_mode: true }, allow_blank: true, uniqueness: true
144
  validates :bio, length: { maximum: 255 }, allow_blank: true
145
  validates :projects_limit, presence: true, numericality: { greater_than_or_equal_to: 0 }
146 147 148 149
  validates :username,
    presence: true,
    uniqueness: { case_sensitive: false },
    exclusion: { in: Gitlab::Blacklist.path },
Douwe Maan's avatar
Douwe Maan committed
150 151
    format: { with: Gitlab::Regex.namespace_regex,
              message: Gitlab::Regex.namespace_regex_message }
152

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
153
  validates :notification_level, inclusion: { in: Notification.notification_levels }, presence: true
154
  validate :namespace_uniq, if: ->(user) { user.username_changed? }
155
  validate :avatar_type, if: ->(user) { user.avatar.present? && user.avatar_changed? }
156
  validate :unique_email, if: ->(user) { user.email_changed? }
157
  validate :owns_notification_email, if: ->(user) { user.notification_email_changed? }
158
  validate :owns_public_email, if: ->(user) { user.public_email_changed? }
159
  validates :avatar, file_size: { maximum: 200.kilobytes.to_i }
160

161
  before_validation :generate_password, on: :create
162
  before_validation :restricted_signup_domains, on: :create
163
  before_validation :sanitize_attrs
164
  before_validation :set_notification_email, if: ->(user) { user.email_changed? }
165
  before_validation :set_public_email, if: ->(user) { user.public_email_changed? }
166

167
  after_update :update_emails_with_primary_email, if: ->(user) { user.email_changed? }
Nihad Abbasov's avatar
Nihad Abbasov committed
168
  before_save :ensure_authentication_token
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
169
  after_save :ensure_namespace_correct
170
  after_initialize :set_projects_limit
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
171 172 173
  after_create :post_create_hook
  after_destroy :post_destroy_hook

174 175 176
  # User's Dashboard preference
  # Note: When adding an option, it MUST go on the end of the array.
  enum dashboard: [:projects, :stars]
177

178 179 180 181
  # User's Project preference
  # Note: When adding an option, it MUST go on the end of the array.
  enum project_view: [:readme, :activity]

Nihad Abbasov's avatar
Nihad Abbasov committed
182
  alias_attribute :private_token, :authentication_token
183

184
  delegate :path, to: :namespace, allow_nil: true, prefix: true
185

186 187 188 189 190 191 192 193 194 195
  state_machine :state, initial: :active do
    event :block do
      transition active: :blocked
    end

    event :activate do
      transition blocked: :active
    end
  end

196
  mount_uploader :avatar, AvatarUploader
197

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
198
  # Scopes
199
  scope :admins, -> { where(admin: true) }
200 201
  scope :blocked, -> { with_state(:blocked) }
  scope :active, -> { with_state(:active) }
skv's avatar
skv committed
202
  scope :not_in_project, ->(project) { project.users.present? ? where("id not in (:ids)", ids: project.users.map(&:id) ) : all }
203
  scope :without_projects, -> { where('id NOT IN (SELECT DISTINCT(user_id) FROM members)') }
204
  scope :subscribed_for_admin_email, -> { where(admin_email_unsubscribed_at: nil) }
205
  scope :ldap, -> { joins(:identities).where('identities.provider LIKE ?', 'ldap%') }
206 207
  scope :with_two_factor,    -> { where(two_factor_enabled: true) }
  scope :without_two_factor, -> { where(two_factor_enabled: false) }
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
208

209 210 211
  #
  # Class methods
  #
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
212
  class << self
213
    # Devise method overridden to allow sign in with email or username
214 215 216 217 218 219 220 221
    def find_for_database_authentication(warden_conditions)
      conditions = warden_conditions.dup
      if login = conditions.delete(:login)
        where(conditions).where(["lower(username) = :value OR lower(email) = :value", { value: login.downcase }]).first
      else
        where(conditions).first
      end
    end
222

Valery Sizov's avatar
Valery Sizov committed
223 224
    def sort(method)
      case method.to_s
225 226 227 228
      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)
Valery Sizov's avatar
Valery Sizov committed
229 230 231
      end
    end

232 233
    # Find a User by their primary email or any associated secondary email
    def find_by_any_email(email)
234 235 236 237 238 239 240 241 242 243 244
      user_table = arel_table
      email_table = Email.arel_table

      # Use ARel to build a query:
      query = user_table.
        # SELECT "users".* FROM "users"
        project(user_table[Arel.star]).
        # LEFT OUTER JOIN "emails"
        join(email_table, Arel::Nodes::OuterJoin).
        # ON "users"."id" = "emails"."user_id"
        on(user_table[:id].eq(email_table[:user_id])).
245 246
        # WHERE ("user"."email" = '<email>' OR "emails"."email" = '<email>')
        where(user_table[:email].eq(email).or(email_table[:email].eq(email)))
247 248

      find_by_sql(query.to_sql).first
249
    end
250

251
    def existing_member?(email)
Valery Sizov's avatar
Valery Sizov committed
252
      User.where(email: email).any? || Email.where(email: email).any?
253 254
    end

255
    def filter(filter_name)
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
256
      case filter_name
257 258 259 260 261 262 263 264 265 266
      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
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
267 268 269
      else
        self.active
      end
270 271
    end

272
    def search(query)
273
      where("lower(name) LIKE :query OR lower(email) LIKE :query OR lower(username) LIKE :query", query: "%#{query.downcase}%")
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
274
    end
gitlabhq's avatar
gitlabhq committed
275

276 277 278 279 280
    def by_login(login)
      where('lower(username) = :value OR lower(email) = :value',
            value: login.to_s.downcase).first
    end

281 282 283 284
    def find_by_username!(username)
      find_by!('lower(username) = ?', username.downcase)
    end

285
    def by_username_or_id(name_or_id)
286
      where('users.username = ? OR users.id = ?', name_or_id.to_s, name_or_id.to_i).first
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
287
    end
Florian Unglaub's avatar
Florian Unglaub committed
288

289 290
    def build_user(attrs = {})
      User.new(attrs)
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
291
    end
292 293 294

    def non_ldap
      joins('LEFT JOIN identities ON identities.user_id = users.id').
295
        where('identities.provider IS NULL OR identities.provider NOT LIKE ?', 'ldap%')
296
    end
297

298 299 300 301 302 303 304 305
    def clean_username(username)
      username.gsub!(/@.*\z/,             "")
      username.gsub!(/\.git\z/,           "")
      username.gsub!(/\A-/,               "")
      username.gsub!(/[^a-zA-Z0-9_\-\.]/, "")

      counter = 0
      base = username
306
      while User.by_login(username).present? || Namespace.by_path(username).present?
307
        counter += 1
308 309 310 311 312
        username = "#{base}#{counter}"
      end

      username
    end
313

314 315 316
    def reference_prefix
      '@'
    end
317 318 319 320 321 322 323 324

    # 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
vsizov's avatar
vsizov committed
325
  end
randx's avatar
randx committed
326

327 328 329
  #
  # Instance methods
  #
330 331 332 333 334

  def to_param
    username
  end

335 336 337 338
  def to_reference(_from_project = nil)
    "#{self.class.reference_prefix}#{username}"
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
339 340 341 342
  def notification
    @notification ||= Notification.new(self)
  end

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
343 344 345 346
  def generate_password
    if self.force_random_password
      self.password = self.password_confirmation = Devise.friendly_token.first(8)
    end
randx's avatar
randx committed
347
  end
348

349
  def generate_reset_token
350
    @reset_token, enc = Devise.token_generator.generate(self.class, :reset_password_token)
351 352 353 354

    self.reset_password_token   = enc
    self.reset_password_sent_at = Time.now.utc

355
    @reset_token
356 357
  end

358 359 360 361 362 363 364 365 366 367
  def disable_two_factor!
    update_attributes(
      two_factor_enabled:        false,
      encrypted_otp_secret:      nil,
      encrypted_otp_secret_iv:   nil,
      encrypted_otp_secret_salt: nil,
      otp_backup_codes:          nil
    )
  end

368 369
  def namespace_uniq
    namespace_name = self.username
370 371
    existing_namespace = Namespace.by_path(namespace_name)
    if existing_namespace && existing_namespace != self.namespace
lol768's avatar
lol768 committed
372
      self.errors.add :username, "already exists"
373 374
    end
  end
375

376 377 378 379 380 381
  def avatar_type
    unless self.avatar.image?
      self.errors.add :avatar, "only images allowed"
    end
  end

382
  def unique_email
383 384 385
    if !self.emails.exists?(email: self.email) && Email.exists?(email: self.email)
      self.errors.add(:email, 'has already been taken')
    end
386 387
  end

388 389 390 391
  def owns_notification_email
    self.errors.add(:notification_email, "is not an email you own") unless self.all_emails.include?(self.notification_email)
  end

392
  def owns_public_email
393 394
    return if self.public_email.blank?

395 396 397 398 399 400 401 402
    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)
403

404 405 406 407
      self.update_secondary_emails!
    end
  end

408 409
  # Groups user has access to
  def authorized_groups
410
    @authorized_groups ||= begin
411
                             group_ids = (groups.pluck(:id) + authorized_projects.pluck(:namespace_id))
412
                             Group.where(id: group_ids)
413
                           end
414 415 416 417 418
  end


  # Projects user has access to
  def authorized_projects
419
    @authorized_projects ||= begin
420
                               project_ids = personal_projects.pluck(:id)
421 422
                               project_ids.push(*groups_projects.pluck(:id))
                               project_ids.push(*projects.pluck(:id).uniq)
423
                               project_ids.push(*groups.joins(:shared_projects).pluck(:project_id))
424
                               Project.where(id: project_ids)
425
                             end
426 427
  end

428
  def owned_projects
429 430 431 432 433
    @owned_projects ||=
      begin
        namespace_ids = owned_groups.pluck(:id).push(namespace.id)
        Project.in_namespace(namespace_ids).joins(:namespace)
      end
434 435
  end

436 437
  # Team membership in authorized projects
  def tm_in_authorized_projects
438
    ProjectMember.where(source_id: authorized_projects.map(&:id), user_id: self.id)
439
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
440 441 442 443 444 445 446 447 448

  def is_admin?
    admin
  end

  def require_ssh_key?
    keys.count == 0
  end

449 450 451 452
  def require_password?
    password_automatically_set? && !ldap_user?
  end

453
  def can_change_username?
454
    gitlab_config.username_changing_enabled
455 456
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
457
  def can_create_project?
458
    projects_limit_left > 0
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
459 460 461
  end

  def can_create_group?
462
    can?(:create_group, nil)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
463 464 465
  end

  def abilities
Ciro Santilli's avatar
Ciro Santilli committed
466
    Ability.abilities
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
467 468
  end

469 470 471 472
  def can_select_namespace?
    several_namespaces? || admin
  end

473
  def can?(action, subject)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
474 475 476 477 478 479 480 481
    abilities.allowed?(self, action, subject)
  end

  def first_name
    name.split.first unless name.blank?
  end

  def cared_merge_requests
482
    MergeRequest.cared(self)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
483 484
  end

485
  def projects_limit_left
486
    projects_limit - personal_projects.count
487 488
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
489 490
  def projects_limit_percent
    return 100 if projects_limit.zero?
491
    (personal_projects.count.to_f / projects_limit) * 100
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
492 493
  end

494
  def recent_push(project_id = nil)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
495 496 497 498
    # 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

499 500 501 502 503 504 505 506 507 508 509 510 511
    # 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
      repo = project.repository

      if repo.branch_names.include?(event.branch_name)
        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
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
512 513 514 515 516 517 518
  end

  def projects_sorted_by_activity
    authorized_projects.sorted_by_activity
  end

  def several_namespaces?
519
    owned_groups.any? || masters_groups.any?
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
520 521 522 523 524
  end

  def namespace_id
    namespace.try :id
  end
525

526 527 528
  def name_with_username
    "#{name} (#{username})"
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
529 530

  def tm_of(project)
531
    project.project_member_by_id(self.id)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
532
  end
533

534
  def already_forked?(project)
535 536 537
    !!fork_of(project)
  end

538
  def fork_of(project)
539 540 541 542 543 544 545 546
    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
547 548

  def ldap_user?
549 550 551 552 553
    identities.exists?(["provider LIKE ? AND extern_uid IS NOT NULL", "ldap%"])
  end

  def ldap_identity
    @ldap_identity ||= identities.find_by(["provider LIKE ?", "ldap%"])
554
  end
555

556
  def project_deploy_keys
557
    DeployKey.unscoped.in_projects(self.authorized_projects.pluck(:id)).distinct(:id)
558 559
  end

560
  def accessible_deploy_keys
561 562 563 564 565
    @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
566
  end
567 568

  def created_by
skv's avatar
skv committed
569
    User.find_by(id: created_by_id) if created_by_id
570
  end
571 572

  def sanitize_attrs
573
    %w(name username skype linkedin twitter).each do |attr|
574 575 576 577
      value = self.send(attr)
      self.send("#{attr}=", Sanitize.clean(value)) if value.present?
    end
  end
578

579 580
  def set_notification_email
    if self.notification_email.blank? || !self.all_emails.include?(self.notification_email)
581
      self.notification_email = self.email
582 583 584
    end
  end

585 586
  def set_public_email
    if self.public_email.blank? || !self.all_emails.include?(self.public_email)
587
      self.public_email = ''
588 589 590
    end
  end

591 592 593 594 595 596
  def update_secondary_emails!
    self.set_notification_email
    self.set_public_email
    self.save if self.notification_email_changed? || self.public_email_changed?
  end

597 598 599 600 601 602 603
  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

604
  def requires_ldap_check?
605 606 607
    if !Gitlab.config.ldap.enabled
      false
    elsif ldap_user?
608
      !last_credential_check_at || (last_credential_check_at + Gitlab.config.ldap['sync_time']) < Time.now
609 610 611
    else
      false
    end
612
  end
613

614 615 616 617 618
  def solo_owned_groups
    @solo_owned_groups ||= owned_groups.select do |group|
      group.owners == [self]
    end
  end
619 620

  def with_defaults
621 622
    User.defaults.each do |k, v|
      self.send("#{k}=", v)
623
    end
624 625

    self
626
  end
627 628 629 630 631

  def can_leave_project?(project)
    project.namespace != namespace &&
      project.project_member(self)
  end
632 633 634 635 636 637 638 639 640 641 642 643 644 645

  # 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
Jerome Dalbert's avatar
Jerome Dalbert committed
646 647

  def full_website_url
648
    return "http://#{website_url}" if website_url !~ /\Ahttps?:\/\//
Jerome Dalbert's avatar
Jerome Dalbert committed
649 650 651 652 653

    website_url
  end

  def short_website_url
654
    website_url.sub(/\Ahttps?:\/\//, '')
Jerome Dalbert's avatar
Jerome Dalbert committed
655
  end
GitLab's avatar
GitLab committed
656

657
  def all_ssh_keys
658
    keys.map(&:publishable_key)
659
  end
660 661

  def temp_oauth_email?
662
    email.start_with?('temp-email-for-oauth')
663 664
  end

665 666
  def avatar_url(size = nil)
    if avatar.present?
667
      [gitlab_config.url, avatar.url].join
668
    else
669
      GravatarService.new.execute(email, size)
670 671
    end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
672

673 674 675 676
  def all_emails
    [self.email, *self.emails.map(&:email)]
  end

Kirill Zaitsev's avatar
Kirill Zaitsev committed
677 678 679 680 681 682 683 684
  def hook_attrs
    {
      name: name,
      username: username,
      avatar_url: avatar_url
    }
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
685 686 687 688 689 690 691 692 693 694 695
  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")
696
    notification_service.new_user(self, @reset_token) if self.created_by_id
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
697 698 699 700 701 702 703 704
    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

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
705
  def notification_service
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
706 707 708
    NotificationService.new
  end

709
  def log_info(message)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
710 711 712 713 714 715
    Gitlab::AppLogger.info message
  end

  def system_hook_service
    SystemHooksService.new
  end
716 717 718 719

  def admin_unsubscribe!
    update_column :admin_email_unsubscribed_at, Time.now
  end
720

Ciro Santilli's avatar
Ciro Santilli committed
721 722 723 724 725
  def starred?(project)
    starred_projects.exists?(project)
  end

  def toggle_star(project)
726 727
    user_star_project = users_star_projects.
      where(project: project, user: self).take
Ciro Santilli's avatar
Ciro Santilli committed
728 729 730 731 732 733
    if user_star_project
      user_star_project.destroy
    else
      UsersStarProject.create!(project: project, user: self)
    end
  end
734 735 736 737 738 739 740 741 742 743

  def manageable_namespaces
    @manageable_namespaces ||=
      begin
        namespaces = []
        namespaces << namespace
        namespaces += owned_groups
        namespaces += masters_groups
      end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
744

745 746 747 748 749 750
  def namespaces
    namespace_ids = groups.pluck(:id)
    namespace_ids.push(namespace.id)
    Namespace.where(id: namespace_ids)
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
751 752 753
  def oauth_authorized_tokens
    Doorkeeper::AccessToken.where(resource_owner_id: self.id, revoked_at: nil)
  end
754 755

  def contributed_projects_ids
756
    Event.contributions.where(author_id: self).
757
      where("created_at > ?", Time.now - 1.year).
758
      reorder(project_id: :desc).
759
      select(:project_id).
760
      uniq.map(&:project_id)
761
  end
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784

  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
785 786 787 788

  def can_be_removed?
    !solo_owned_groups.present?
  end
789 790 791 792 793 794 795 796 797

  def ci_authorized_projects
    @ci_authorized_projects ||= Ci::Project.where(gitlab_id: authorized_projects)
  end

  def ci_authorized_runners
    Ci::Runner.specific.includes(:runner_projects).
      where(ci_runner_projects: { project_id: ci_authorized_projects } )
  end
gitlabhq's avatar
gitlabhq committed
798
end