2014-09-14 14:54:10 +00:00
|
|
|
class Member < ActiveRecord::Base
|
2015-02-05 22:20:55 +00:00
|
|
|
include Sortable
|
2016-06-01 16:03:51 +00:00
|
|
|
include Importable
|
2016-08-18 21:45:41 +00:00
|
|
|
include Expirable
|
2014-09-14 14:54:10 +00:00
|
|
|
include Gitlab::Access
|
|
|
|
|
2015-04-14 16:04:29 +00:00
|
|
|
attr_accessor :raw_invite_token
|
|
|
|
|
2015-04-10 12:46:09 +00:00
|
|
|
belongs_to :created_by, class_name: "User"
|
2014-09-14 14:54:10 +00:00
|
|
|
belongs_to :user
|
|
|
|
belongs_to :source, polymorphic: true
|
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
validates :user, presence: true, unless: :invite?
|
2014-09-14 14:54:10 +00:00
|
|
|
validates :source, presence: true
|
2015-11-11 15:42:27 +00:00
|
|
|
validates :user_id, uniqueness: { scope: [:source_type, :source_id],
|
2015-04-10 13:09:37 +00:00
|
|
|
message: "already exists in source",
|
|
|
|
allow_nil: true }
|
2014-09-14 16:32:51 +00:00
|
|
|
validates :access_level, inclusion: { in: Gitlab::Access.all_values }, presence: true
|
2015-11-17 14:49:37 +00:00
|
|
|
validates :invite_email,
|
|
|
|
presence: {
|
|
|
|
if: :invite?
|
|
|
|
},
|
2016-02-09 16:59:47 +00:00
|
|
|
email: {
|
2015-11-17 14:49:37 +00:00
|
|
|
allow_nil: true
|
|
|
|
},
|
|
|
|
uniqueness: {
|
|
|
|
scope: [:source_type, :source_id],
|
|
|
|
allow_nil: true
|
|
|
|
}
|
2014-09-14 14:54:10 +00:00
|
|
|
|
2016-09-05 15:37:26 +00:00
|
|
|
# This scope encapsulates (most of) the conditions a row in the member table
|
|
|
|
# must satisfy if it is a valid permission. Of particular note:
|
|
|
|
#
|
|
|
|
# * Access requests must be excluded
|
|
|
|
# * Blocked users must be excluded
|
|
|
|
# * Invitations take effect immediately
|
|
|
|
# * expires_at is not implemented. A background worker purges expired rows
|
|
|
|
scope :active, -> do
|
|
|
|
is_external_invite = arel_table[:user_id].eq(nil).and(arel_table[:invite_token].not_eq(nil))
|
|
|
|
user_is_active = User.arel_table[:state].eq(:active)
|
|
|
|
|
|
|
|
includes(:user).references(:users)
|
|
|
|
.where(is_external_invite.or(user_is_active))
|
|
|
|
.where(requested_at: nil)
|
|
|
|
end
|
|
|
|
|
2016-04-18 16:53:32 +00:00
|
|
|
scope :invite, -> { where.not(invite_token: nil) }
|
2016-06-02 16:05:06 +00:00
|
|
|
scope :non_invite, -> { where(invite_token: nil) }
|
2016-04-18 16:53:32 +00:00
|
|
|
scope :request, -> { where.not(requested_at: nil) }
|
2016-09-05 15:37:26 +00:00
|
|
|
|
|
|
|
scope :has_access, -> { active.where('access_level > 0') }
|
|
|
|
|
|
|
|
scope :guests, -> { active.where(access_level: GUEST) }
|
|
|
|
scope :reporters, -> { active.where(access_level: REPORTER) }
|
|
|
|
scope :developers, -> { active.where(access_level: DEVELOPER) }
|
|
|
|
scope :masters, -> { active.where(access_level: MASTER) }
|
|
|
|
scope :owners, -> { active.where(access_level: OWNER) }
|
|
|
|
scope :owners_and_masters, -> { active.where(access_level: [OWNER, MASTER]) }
|
2014-09-14 16:32:51 +00:00
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
before_validation :generate_invite_token, on: :create, if: -> (member) { member.invite_email.present? }
|
2016-03-14 13:13:35 +00:00
|
|
|
|
2016-06-01 16:03:51 +00:00
|
|
|
after_create :send_invite, if: :invite?, unless: :importing?
|
2016-06-16 12:07:49 +00:00
|
|
|
after_create :send_request, if: :request?, unless: :importing?
|
|
|
|
after_create :create_notification_setting, unless: [:pending?, :importing?]
|
|
|
|
after_create :post_create_hook, unless: [:pending?, :importing?]
|
|
|
|
after_update :post_update_hook, unless: [:pending?, :importing?]
|
2016-03-14 13:13:35 +00:00
|
|
|
after_destroy :post_destroy_hook, unless: :pending?
|
2015-04-10 13:09:37 +00:00
|
|
|
|
2014-09-14 16:32:51 +00:00
|
|
|
delegate :name, :username, :email, to: :user, prefix: true
|
2015-04-10 13:09:37 +00:00
|
|
|
|
2016-03-28 21:22:28 +00:00
|
|
|
default_value_for :notification_level, NotificationSetting.levels[:global]
|
|
|
|
|
2015-04-14 10:33:27 +00:00
|
|
|
class << self
|
2016-07-25 13:21:55 +00:00
|
|
|
def access_for_user_ids(user_ids)
|
2016-08-04 05:59:14 +00:00
|
|
|
where(user_id: user_ids).has_access.pluck(:user_id, :access_level).to_h
|
2016-07-25 13:21:55 +00:00
|
|
|
end
|
|
|
|
|
2015-04-14 10:33:27 +00:00
|
|
|
def find_by_invite_token(invite_token)
|
|
|
|
invite_token = Devise.token_generator.digest(self, :invite_token, invite_token)
|
|
|
|
find_by(invite_token: invite_token)
|
|
|
|
end
|
|
|
|
|
|
|
|
# This method is used to find users that have been entered into the "Add members" field.
|
|
|
|
# These can be the User objects directly, their IDs, their emails, or new emails to be invited.
|
|
|
|
def user_for_id(user_id)
|
|
|
|
return user_id if user_id.is_a?(User)
|
|
|
|
|
|
|
|
user = User.find_by(id: user_id)
|
|
|
|
user ||= User.find_by(email: user_id)
|
|
|
|
user ||= user_id
|
|
|
|
user
|
|
|
|
end
|
|
|
|
|
2016-08-02 18:37:22 +00:00
|
|
|
def add_user(members, user_id, access_level, current_user: nil, expires_at: nil)
|
2015-04-14 10:33:27 +00:00
|
|
|
user = user_for_id(user_id)
|
2015-10-30 19:55:19 +00:00
|
|
|
|
2015-04-14 10:33:27 +00:00
|
|
|
# `user` can be either a User object or an email to be invited
|
|
|
|
if user.is_a?(User)
|
|
|
|
member = members.find_or_initialize_by(user_id: user.id)
|
|
|
|
else
|
|
|
|
member = members.build
|
|
|
|
member.invite_email = user
|
|
|
|
end
|
2015-10-30 19:55:19 +00:00
|
|
|
|
2016-01-20 18:55:47 +00:00
|
|
|
if can_update_member?(current_user, member) || project_creator?(member, access_level)
|
2015-10-29 16:10:27 +00:00
|
|
|
member.created_by ||= current_user
|
|
|
|
member.access_level = access_level
|
2016-08-01 18:12:30 +00:00
|
|
|
member.expires_at = expires_at
|
2015-04-14 10:33:27 +00:00
|
|
|
|
2015-10-29 16:10:27 +00:00
|
|
|
member.save
|
|
|
|
end
|
2015-04-14 10:33:27 +00:00
|
|
|
end
|
2015-10-30 19:55:19 +00:00
|
|
|
|
|
|
|
private
|
|
|
|
|
2015-11-03 11:11:56 +00:00
|
|
|
def can_update_member?(current_user, member)
|
2015-11-17 14:49:37 +00:00
|
|
|
# There is no current user for bulk actions, in which case anything is allowed
|
|
|
|
!current_user ||
|
|
|
|
current_user.can?(:update_group_member, member) ||
|
2015-11-11 15:42:27 +00:00
|
|
|
current_user.can?(:update_project_member, member)
|
2015-10-30 19:55:19 +00:00
|
|
|
end
|
2016-01-20 18:55:47 +00:00
|
|
|
|
|
|
|
def project_creator?(member, access_level)
|
|
|
|
member.new_record? && member.owner? &&
|
|
|
|
access_level.to_i == ProjectMember::MASTER
|
|
|
|
end
|
2015-04-10 13:22:31 +00:00
|
|
|
end
|
|
|
|
|
2016-06-02 16:05:06 +00:00
|
|
|
def real_source_type
|
|
|
|
source_type
|
|
|
|
end
|
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
def invite?
|
|
|
|
self.invite_token.present?
|
|
|
|
end
|
|
|
|
|
2016-03-14 13:13:35 +00:00
|
|
|
def request?
|
2016-06-02 16:05:06 +00:00
|
|
|
requested_at.present?
|
2016-03-14 13:13:35 +00:00
|
|
|
end
|
|
|
|
|
2016-06-02 16:05:06 +00:00
|
|
|
def pending?
|
|
|
|
invite? || request?
|
2015-04-10 13:09:37 +00:00
|
|
|
end
|
|
|
|
|
2016-04-18 16:53:32 +00:00
|
|
|
def accept_request
|
2016-03-14 13:13:35 +00:00
|
|
|
return false unless request?
|
|
|
|
|
2016-06-02 16:05:06 +00:00
|
|
|
updated = self.update(requested_at: nil)
|
2016-04-18 16:53:32 +00:00
|
|
|
after_accept_request if updated
|
2016-03-14 13:13:35 +00:00
|
|
|
|
2016-04-18 16:53:32 +00:00
|
|
|
updated
|
2016-03-14 13:13:35 +00:00
|
|
|
end
|
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
def accept_invite!(new_user)
|
2015-04-10 13:22:31 +00:00
|
|
|
return false unless invite?
|
2015-11-11 15:42:27 +00:00
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
self.invite_token = nil
|
|
|
|
self.invite_accepted_at = Time.now.utc
|
|
|
|
|
|
|
|
self.user = new_user
|
|
|
|
|
|
|
|
saved = self.save
|
|
|
|
|
|
|
|
after_accept_invite if saved
|
|
|
|
|
|
|
|
saved
|
|
|
|
end
|
|
|
|
|
2015-04-10 14:37:02 +00:00
|
|
|
def decline_invite!
|
|
|
|
return false unless invite?
|
|
|
|
|
|
|
|
destroyed = self.destroy
|
|
|
|
|
|
|
|
after_decline_invite if destroyed
|
|
|
|
|
|
|
|
destroyed
|
|
|
|
end
|
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
def generate_invite_token
|
|
|
|
raw, enc = Devise.token_generator.generate(self.class, :invite_token)
|
|
|
|
@raw_invite_token = raw
|
|
|
|
self.invite_token = enc
|
|
|
|
end
|
|
|
|
|
|
|
|
def generate_invite_token!
|
|
|
|
generate_invite_token && save(validate: false)
|
|
|
|
end
|
|
|
|
|
|
|
|
def resend_invite
|
|
|
|
return unless invite?
|
|
|
|
|
|
|
|
generate_invite_token! unless @raw_invite_token
|
|
|
|
|
|
|
|
send_invite
|
|
|
|
end
|
|
|
|
|
2016-03-28 16:25:57 +00:00
|
|
|
def create_notification_setting
|
2016-03-29 12:03:23 +00:00
|
|
|
user.notification_settings.find_or_create_for(source)
|
2016-03-28 16:25:57 +00:00
|
|
|
end
|
|
|
|
|
2016-03-29 11:37:43 +00:00
|
|
|
def notification_setting
|
2016-04-11 21:23:12 +00:00
|
|
|
@notification_setting ||= user.notification_settings_for(source)
|
2016-03-28 18:31:36 +00:00
|
|
|
end
|
|
|
|
|
2015-04-10 13:09:37 +00:00
|
|
|
private
|
|
|
|
|
|
|
|
def send_invite
|
|
|
|
# override in subclass
|
|
|
|
end
|
|
|
|
|
2016-04-18 16:53:32 +00:00
|
|
|
def send_request
|
2016-06-17 12:06:55 +00:00
|
|
|
notification_service.new_access_request(self)
|
2015-04-10 13:09:37 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def post_create_hook
|
|
|
|
system_hook_service.execute_hooks_for(self, :create)
|
|
|
|
end
|
|
|
|
|
|
|
|
def post_update_hook
|
|
|
|
# override in subclass
|
|
|
|
end
|
|
|
|
|
|
|
|
def post_destroy_hook
|
|
|
|
system_hook_service.execute_hooks_for(self, :destroy)
|
|
|
|
end
|
|
|
|
|
|
|
|
def after_accept_invite
|
|
|
|
post_create_hook
|
|
|
|
end
|
|
|
|
|
2015-04-10 14:37:02 +00:00
|
|
|
def after_decline_invite
|
|
|
|
# override in subclass
|
|
|
|
end
|
|
|
|
|
2016-04-18 16:53:32 +00:00
|
|
|
def after_accept_request
|
2015-04-10 13:09:37 +00:00
|
|
|
post_create_hook
|
|
|
|
end
|
|
|
|
|
|
|
|
def system_hook_service
|
|
|
|
SystemHooksService.new
|
|
|
|
end
|
|
|
|
|
|
|
|
def notification_service
|
|
|
|
NotificationService.new
|
|
|
|
end
|
2014-09-14 14:54:10 +00:00
|
|
|
end
|