Class: Rolify::Adapter::RoleAdapter

Inherits:
RoleAdapterBase show all
Defined in:
lib/rolify/adapters/mongoid/role_adapter.rb,
lib/rolify/adapters/active_record/role_adapter.rb

Instance Method Summary collapse

Methods inherited from Base

create, #initialize, #role_class, #role_table, #user_class

Constructor Details

This class inherits a constructor from Rolify::Adapter::Base

Instance Method Details

#add(relation, role) ⇒ Object 



17
18
19
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 17

def add(relation, role)
  relation.roles << role
end

#exists?(relation, column) ⇒ Boolean

Returns:

  • (Boolean) 


48
49
50
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 48

def exists?(relation, column)
  relation.where(column.to_sym.ne => nil)
end

#find_or_create_by(role_name, resource_type = nil, resource_id = nil) ⇒ Object 



11
12
13
14
15
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 11

def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
  self.role_class.find_or_create_by(:name => role_name, 
                                    :resource_type => resource_type, 
                                    :resource_id => resource_id)
end

#remove(relation, role_name, resource = nil) ⇒ Object 



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
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 21

def remove(relation, role_name, resource = nil)
  #roles = { :name => role_name }
  #roles.merge!({:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)}) if resource
  #roles.merge!({ :resource_id => resource.id }) if resource && !resource.is_a?(Class)
  #roles_to_remove = relation.roles.where(roles)
  #roles_to_remove.each do |role|
  #  # Deletion in n-n relations is unreliable. Sometimes it works, sometimes not. 
  #  # So, this does not work all the time: `relation.roles.delete(role)`
  #  # @see http://stackoverflow.com/questions/9132596/rails3-mongoid-many-to-many-relation-and-delete-operation
  #  # We instead remove ids from the Role object and the relation object.
  #  relation.role_ids.delete(role.id)
  #  role.send((user_class.to_s.underscore + '_ids').to_sym).delete(relation.id)
  #
  #  role.destroy if role.send(user_class.to_s.tableize.to_sym).empty?
  #end
  cond = { :name => role_name }
  cond[:resource_type] = (resource.is_a?(Class) ? resource.to_s : resource.class.name) if resource
  cond[:resource_id] = resource.id if resource && !resource.is_a?(Class)
  roles = relation.roles.where(cond)
  roles.each do |role| 
    relation.roles.delete(role)
    role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).delete(relation)
    role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty? 
  end if roles
  roles
end

#scope(relation, conditions) ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 52

def scope(relation, conditions)
  roles = where(role_class, conditions).map { |role| role.id }
  return [] if roles.size.zero?
  query = relation.any_in(:role_ids => roles)
  query
end

#where(relation, *args) ⇒ Object 



6
7
8
9
 
# File 'lib/rolify/adapters/mongoid/role_adapter.rb', line 6

def where(relation, *args)
  conditions = build_conditions(relation, args)
  relation.any_of(*conditions)
end