user.rb 9.54 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
#

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

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

  attr_accessor :force_random_password
gitlabhq's avatar
gitlabhq committed
46

47
  # Namespace for personal projects
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
  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
69

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

78

79 80
  validate :namespace_uniq, if: ->(user) { user.username_changed? }

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

85
  delegate :path, to: :namespace, allow_nil: true, prefix: true
86

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

96 97 98
  #
  # Class methods
  #
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
99 100 101 102 103 104 105 106 107
  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
108 109
    end

110 111 112 113 114 115 116 117
    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
118 119
    def without_projects
      where('id NOT IN (SELECT DISTINCT(user_id) FROM users_projects)')
120 121
    end

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

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

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

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

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

143 144 145
  #
  # Instance methods
  #
146 147 148 149 150

  def to_param
    username
  end

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

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

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

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

    # Add groups you can manage
172 173
    namespaces += groups.all

174 175 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
    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
210

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

  # 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

  def can_create_project?
    projects_limit > personal_projects.count
  end

  def can_create_group?
240
    can?(:create_group, nil)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
241 242 243 244 245 246 247 248 249 250
  end

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

251 252 253 254
  def can_select_namespace?
    several_namespaces? || admin
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 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
  def can? action, subject
    abilities.allowed?(self, action, subject)
  end

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

  def cared_merge_requests
    MergeRequest.where("author_id = :id or assignee_id = :id", id: self.id)
  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
303 304 305 306 307 308 309 310 311 312 313

  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
gitlabhq's avatar
gitlabhq committed
314
end