Module: RoleAuthorization::Roles::Manager::InstanceMethods

Included in:
RoleAuthorization::Roles::Manager
Defined in:
lib/role_authorization/roles/manager.rb

Instance Method Summary collapse

Instance Method Details

#any(new_scope = nil) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
 
# File 'lib/role_authorization/roles/manager.rb', line 76

def any(new_scope = nil)
  case new_scope
  when nil
    [global_roles, object_roles.values].flatten
  when :global
    global_roles
  else
    object_roles[new_scope]
  end
end

#cache(value) ⇒ Object 



50
51
52
 
# File 'lib/role_authorization/roles/manager.rb', line 50

def cache(value)
  @cache_user_ids = value
end

#cache_user(role_name, user_id, scope = nil) ⇒ Object 



23
24
25
26
27
 
# File 'lib/role_authorization/roles/manager.rb', line 23

def cache_user(role_name, user_id, scope = nil)
  if @cache_user_ids
    role(role_name).add_user(user_id, scope)
  end
end

#creation_rules(rules) ⇒ Object 



62
63
64
65
66
 
# File 'lib/role_authorization/roles/manager.rb', line 62

def creation_rules(rules)
  rules.each_pair do |key, allowed_roles|
    @creations[key] = allowed_roles.flatten.uniq
  end
end

#group(groups) ⇒ Object 



68
69
70
 
# File 'lib/role_authorization/roles/manager.rb', line 68

def group(groups)
  @group_definitions = groups
end

#nickname(nicknames) ⇒ Object 



72
73
74
 
# File 'lib/role_authorization/roles/manager.rb', line 72

def nickname(nicknames)
  @nicknames = nicknames
end

#persist! ⇒ Object

make sure our defined roles are in the database remove any roles taken out



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/role_authorization/roles/manager.rb', line 89

def persist!
  return if klass.nil?
  return unless klass.new.respond_to?(:nickname)

  persisted_roles = klass.all.inject({}) {|hash, record| hash[record.name.to_sym] = record; hash}

  [global_roles, object_roles.values].flatten.map do |role_name|
    if persisted_roles.delete(role_name).nil?
      klass.create(:name => role_name.to_s, :nickname => nicknames[role_name].to_s)
    end
  end

  # if we have persisted roles left we delete them
  persisted_roles.values.map(&:destroy)
end

#role(role_name) ⇒ Object 



35
36
37
38
 
# File 'lib/role_authorization/roles/manager.rb', line 35

def role(role_name)
  @_role ||= {}
  @_role[role_name] ||= klass.find_by_name(role_name)
end

#roles(*options) ⇒ Object 



54
55
56
57
58
59
60
 
# File 'lib/role_authorization/roles/manager.rb', line 54

def roles(*options)
  @global_roles, @object_roles = if options.last.is_a?(Hash)
                                   [options.pop, options].reverse
                                 else
                                   [options, {}]
                                 end
end

#setup(klass) ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/role_authorization/roles/manager.rb', line 40

def setup(klass)
  @klass = klass
  klass.send(:include, RoleAuthorization::Roles::Role)

  # now that we know what class to use, create our role groups
  (@group_definitions || {}).each_pair do |group_name, roles|
    @groups[group_name.to_sym] = RoleAuthorization::Roles::RoleGroup.new(klass, roles)
  end
end

#uncache_user(role_name, user_id, scope = nil) ⇒ Object 



29
30
31
32
33
 
# File 'lib/role_authorization/roles/manager.rb', line 29

def uncache_user(role_name, user_id, scope = nil)
  if @cache_user_ids
    role(role_name).remove_user(user_id, scope)
  end
end