user.rb 9.82 KB
Newer Older
1 2 3 4 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
# == Schema Information
#
# Table name: users
#
#  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         not null
#  updated_at             :datetime         not null
#  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)
#  dark_scheme            :boolean          default(FALSE), not null
#  theme_id               :integer          default(1), not null
#  bio                    :string(255)
#  blocked                :boolean          default(FALSE), not null
#  failed_attempts        :integer          default(0)
#  locked_at              :datetime
#  extern_uid             :string(255)
#  provider               :string(255)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
33
#  username               :string(255)
34 35
#  can_create_group       :boolean          default(TRUE), not null
#  can_create_team        :boolean          default(TRUE), not null
36 37
#

gitlabhq's avatar
gitlabhq committed
38
class User < ActiveRecord::Base
39
  devise :database_authenticatable, :token_authenticatable, :lockable,
Marin Jankovski's avatar
Marin Jankovski committed
40
         :recoverable, :rememberable, :trackable, :validatable, :omniauthable, :registerable
gitlabhq's avatar
gitlabhq committed
41

42
  attr_accessible :email, :password, :password_confirmation, :remember_me, :bio, :name, :username,
Nihad Abbasov's avatar
Nihad Abbasov committed
43
                  :skype, :linkedin, :twitter, :dark_scheme, :theme_id, :force_random_password,
44
                  :extern_uid, :provider, as: [:default, :admin]
45
  attr_accessible :projects_limit, :can_create_team, :can_create_group, as: :admin
46 47

  attr_accessor :force_random_password
gitlabhq's avatar
gitlabhq committed
48

49
  # Namespace for personal projects
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
  has_one :namespace,                 dependent: :destroy, foreign_key: :owner_id,    class_name: "Namespace", conditions: 'type IS NULL'

  has_many :keys,                     dependent: :destroy
  has_many :users_projects,           dependent: :destroy
  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"
  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"

  has_many :groups,         class_name: "Group", foreign_key: :owner_id
  has_many :recent_events,  class_name: "Event", foreign_key: :author_id, order: "id DESC"

  has_many :projects,       through: :users_projects

  has_many :user_team_user_relationships, dependent: :destroy

  has_many :user_teams,                      through: :user_team_user_relationships
  has_many :user_team_project_relationships, through: :user_teams
  has_many :team_projects,                   through: :user_team_project_relationships
71

Cyril's avatar
Cyril committed
72
  validates :name, presence: true
73
  validates :bio, length: { within: 0..255 }
74
  validates :extern_uid, allow_blank: true, uniqueness: {scope: :provider}
Nihad Abbasov's avatar
Nihad Abbasov committed
75
  validates :projects_limit, presence: true, numericality: {greater_than_or_equal_to: 0}
76 77 78 79
  validates :username, presence: true, uniqueness: true,
            format: { with: Gitlab::Regex.username_regex,
                      message: "only letters, digits & '_' '-' '.' allowed. Letter should be first" }

80

81 82
  validate :namespace_uniq, if: ->(user) { user.username_changed? }

83
  before_validation :generate_password, on: :create
Nihad Abbasov's avatar
Nihad Abbasov committed
84 85
  before_save :ensure_authentication_token
  alias_attribute :private_token, :authentication_token
86

87
  delegate :path, to: :namespace, allow_nil: true, prefix: true
88

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
89
  # Scopes
Andrew8xx8's avatar
Andrew8xx8 committed
90 91 92 93
  scope :admins, -> { where(admin:  true) }
  scope :blocked, -> { where(blocked:  true) }
  scope :active, -> { where(blocked:  false) }
  scope :alphabetically, -> { order('name ASC') }
94 95
  scope :in_team, ->(team){ where(id: team.member_ids) }
  scope :not_in_team, ->(team){ where('users.id NOT IN (:ids)', ids: team.member_ids) }
96
  scope :potential_team_members, ->(team) { team.members.any? ? active.not_in_team(team) : active  }
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
97

98 99 100
  #
  # Class methods
  #
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
101 102 103 104 105 106 107 108 109
  class << self
    def filter filter_name
      case filter_name
      when "admins"; self.admins
      when "blocked"; self.blocked
      when "wop"; self.without_projects
      else
        self.active
      end
110 111
    end

112 113 114 115 116 117 118 119
    def not_in_project(project)
      if project.users.present?
        where("id not in (:ids)", ids: project.users.map(&:id) )
      else
        scoped
      end
    end

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
120 121
    def without_projects
      where('id NOT IN (SELECT DISTINCT(user_id) FROM users_projects)')
122 123
    end

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
124 125 126
    def create_from_omniauth(auth, ldap = false)
      gitlab_auth.create_from_omniauth(auth, ldap)
    end
gitlabhq's avatar
gitlabhq committed
127

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
128 129 130
    def find_or_new_for_omniauth(auth)
      gitlab_auth.find_or_new_for_omniauth(auth)
    end
Florian Unglaub's avatar
Florian Unglaub committed
131

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
132 133 134
    def find_for_ldap_auth(auth, signed_in_resource = nil)
      gitlab_auth.find_for_ldap_auth(auth, signed_in_resource)
    end
135

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
136 137 138
    def gitlab_auth
      Gitlab::Auth.new
    end
139

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
140
    def search query
141
      where("name LIKE :query OR email LIKE :query OR username LIKE :query", query: "%#{query}%")
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
142
    end
vsizov's avatar
vsizov committed
143
  end
randx's avatar
randx committed
144

145 146 147
  #
  # Instance methods
  #
148 149 150 151 152

  def to_param
    username
  end

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
153 154 155 156
  def generate_password
    if self.force_random_password
      self.password = self.password_confirmation = Devise.friendly_token.first(8)
    end
randx's avatar
randx committed
157
  end
158

159 160 161 162 163 164
  def namespace_uniq
    namespace_name = self.username
    if Namespace.find_by_path(namespace_name)
      self.errors.add :username, "already exist"
    end
  end
165 166 167 168 169 170 171 172 173

  # Namespaces user has access to
  def namespaces
    namespaces = []

    # Add user account namespace
    namespaces << self.namespace if self.namespace

    # Add groups you can manage
174 175
    namespaces += groups.all

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
    namespaces
  end

  # Groups where user is an owner
  def owned_groups
    groups
  end

  # Groups user has access to
  def authorized_groups
    @authorized_groups ||= begin
                           groups = Group.where(id: self.authorized_projects.pluck(:namespace_id)).all
                           groups = groups + self.groups
                           groups.uniq
                         end
  end


  # Projects user has access to
  def authorized_projects
    project_ids = users_projects.pluck(:project_id)
    project_ids = project_ids | owned_projects.pluck(:id)
    Project.where(id: project_ids)
  end

  # Projects in user namespace
  def personal_projects
    Project.personal(self)
  end

  # Projects where user is an owner
  def owned_projects
    Project.where("(projects.namespace_id IN (:namespaces)) OR
                  (projects.namespace_id IS NULL AND projects.creator_id = :user_id)",
                  namespaces: namespaces.map(&:id), user_id: self.id)
  end
212

213 214 215
  # Team membership in authorized projects
  def tm_in_authorized_projects
    UsersProject.where(project_id:  authorized_projects.map(&:id), user_id: self.id)
216
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

  # Returns a string for use as a Gitolite user identifier
  #
  # Note that Gitolite 2.x requires the following pattern for users:
  #
  #   ^@?[0-9a-zA-Z][0-9a-zA-Z._\@+-]*$
  def identifier
    # Replace non-word chars with underscores, then make sure it starts with
    # valid chars
    email.gsub(/\W/, '_').gsub(/\A([\W\_])+/, '')
  end

  def is_admin?
    admin
  end

  def require_ssh_key?
    keys.count == 0
  end

237 238 239 240
  def can_change_username?
    Gitlab.config.gitlab.username_changing_enabled
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
241
  def can_create_project?
242
    projects_limit > owned_projects.count
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
243 244 245
  end

  def can_create_group?
246
    can?(:create_group, nil)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
247 248 249 250 251 252 253 254 255 256
  end

  def abilities
    @abilities ||= begin
                     abilities = Six.new
                     abilities << Ability
                     abilities
                   end
  end

257 258 259 260
  def can_select_namespace?
    several_namespaces? || admin
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
261 262 263 264 265 266 267 268 269
  def can? action, subject
    abilities.allowed?(self, action, subject)
  end

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

  def cared_merge_requests
270
    MergeRequest.cared(self)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
  end

  # Remove user from all projects and
  # set blocked attribute to true
  def block
    users_projects.find_each do |membership|
      return false unless membership.destroy
    end

    self.blocked = true
    save
  end

  def projects_limit_percent
    return 100 if projects_limit.zero?
    (personal_projects.count.to_f / projects_limit) * 100
  end

  def recent_push project_id = nil
    # 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

    # Take only latest one
    events = events.recent.limit(1).first
  end

  def projects_sorted_by_activity
    authorized_projects.sorted_by_activity
  end

  def several_namespaces?
    namespaces.size > 1
  end

  def namespace_id
    namespace.try :id
  end
309 310 311 312 313 314 315 316 317 318 319

  def authorized_teams
    @authorized_teams ||= begin
                            ids = []
                            ids << UserTeam.with_member(self).pluck('user_teams.id')
                            ids << UserTeam.created_by(self).pluck('user_teams.id')
                            ids.flatten

                            UserTeam.where(id: ids)
                          end
  end
320 321 322 323

  def owned_teams
    UserTeam.where(owner_id: self.id)
  end
gitlabhq's avatar
gitlabhq committed
324
end