Rails 3 Authentication and Authorization with Devise and CanCan (Part 2)

by iqbalfarabi on Feb 25, 2011 | 19 Comments
RubyOnRails_2

This article is also published in Iqbal’s blog here.


This is the second part of two posts tutorial on how to use Devise and CanCan with Rails 3. You can find the first part of this tutorial at the original blog here or at this site here.

Where were we?

In the previous part, we have used Devise library to create our User model in CRUD style. With what we have coded in the previous part, you should now be able to manage users and authenticate them. Now it’s time to add the roles and define what features they may access.

1. Adding the Roles

This step is pretty traditional, we can just scaffold all the MVC part for our roles. In this article, I only need one attribute that is the name of the role.

[cc lang="bash"]
rails generate scaffold Role name:string
[/cc]

2. Making HABTM relationship between roles and users

We have to do several tasks in this step. The first thing is to manually create the migration file for the habtm table. We do it by first generating the migration file like this:

[cc lang="bash"]
rails generate migration UsersHaveAndBelongToManyRoles
[/cc]

and then we fill the file with this code:

[cc lang="ruby"]
class UsersHaveAndBelongsToManyRoles < ActiveRecord::Migration def self.up create_table :roles_users, :id => false do |t|
t.references :role, :user
end
end

def self.down
drop_table :roles_users
end
end
[/cc]

And do not forget to modify our model files. This is how our role.rb looks like after we modify it:

[cc lang="ruby"]
class Role < ActiveRecord::Base has_and_belongs_to_many :users end [/cc] And this is how our user.rb file looks like. Please be noted that we also add :role_ids in the attr_accessible and we add a method to identify the role of the respective user. [cc lang="ruby"] class User < ActiveRecord::Base has_and_belongs_to_many :roles # Include default devise modules. Others available are: # :token_authenticatable, :confirmable, :lockable and :timeoutable devise :database_authenticatable, :recoverable, :rememberable, :trackable, :validatable # Setup accessible (or protected) attributes for your model attr_accessible :email, :username, :password, :password_confirmation, :remember_me, :role_ids def role?(role) return !!self.roles.find_by_name(role.to_s.camelize) end end [/cc] In the views part, we have to modify at least the _form.html.erb from our users view so that we can assign the role to the user from web interface. This is how the file users/_form.html.erb looks like: [cc lang="ruby"] <%= form_for(@user) do |f| %>
<% if @user.errors.any? %>

<%= pluralize(@user.errors.count, "error") %> prohibited this user from being saved:

    <% @user.errors.full_messages.each do |msg| %>

  • <%= msg %>
  • <% end %>

<% end %>

<%= f.label :email %>
<%= f.text_field :email %>
<%= f.label :username %>
<%= f.text_field :username %>

<% if @current_method == "new" %>

<%= f.label :password %>
<%= f.password_field :password %>
<%= f.label :password_confirmation %>
<%= f.password_field :password_confirmation %>

<% end %>
<% for role in Role.find(:all) %>

<%= check_box_tag "user[role_ids][]", role.id, @user.roles.include?(role) %>
<%= role.name %>

<% end %>

<%= f.submit %>

<% end %>
[/cc]

Of course you can also modify your index.html.erb and show.html.erb files to show the role of the listed user(s). But I think I leave it to you to do it yourself. After all these tasks, we can run rake task db:migrate.

[cc lang="bash"]
rake db:migrate
[/cc]

In this state, we can now add users and assign them with the roles we desire. But of course each role has not yet identified with any permission by CanCan. That’s what we’re going to do in the next step.

3. Adding ability

To use CanCan, we have to make a class that defines the permissions that are given to each role. In CanCan, this is called as “ability” and to set it up, we have to create the ability.rb file as part of our models.

[cc lang="ruby"]
class Ability
include CanCan::Ability

def initialize(user)
user ||= User.new # guest user

if user.role? :administrator
can :manage, :all
elsif user.role? :operator
can :manage, Post
else
can :read, :all
end
end
end
[/cc]

CanCan use a very pleasant way to describe our roles and it’s corresponding allowed features. In our code above, we use the keyword “can” and then follow it with the level of authorization we want the respective role to have and at last we end it with the name of the model. The level of authorizations that I have tried so far is :create, :read, :update, :delete, and :manage. Maybe there is a way to define another ability, you can find about it in depth in the official Github page of CanCan library here.

4. Adding authorization

Finally, in every controller that needs authorization, we add this line:

[cc lang="ruby"]
load_and_authorize_resource
[/cc]

Final Words

I think that’s it for now. I know I only have covered the basic part of using Devise and CanCan but I hope this can be helpful for anyone that just starts to learn about both libraries. I may add a working source code to this tutorial later. Meanwhile, if you have any trouble following this tutorial, you can ask me in the comment section.

Back to top

Rails 3 Authentication and Authorization with Devise and CanCan (Part 1)

by iqbalfarabi on Feb 25, 2011 | 7 Comments
RubyOnRails_2

This article is also published in Iqbal’s blog here.


Recently, I was involved in a new project that uses Rails 3. That was my first Rails 3 project, I’ve always used Rails 2 before. Therefore, I tried to get accustomed to how Rails 3 works and how it differs from Rails 2. One thing that I really had to change back then was what authentication and authorization plugin to use. In my previous projects, I always used Authlogic and Lockdown. When I started this particular project, it seemed that both Authlogic and Lockdown was not Rails 3 ready (but I heard now both are Rails 3 ready). So I decided to give a try to different plugins. That’s how I found Devise and CanCan.

Most part of this writing is heavily duplicated from tutorials from Devise’s official github page, Asciicast’s episode on CanCan by Ryan Bates, and Tony Amoyal’s tutorial. I took most of the codes from these resources and then slightly modified it to meet my own needs. In this post, I try to share my experience working with both Devise and CanCan. I’ll explain it in a step-by-step style, maybe some steps are just too obvious for expert readers, please bear with it.

The Project

I wanted to have a user management feature. In the project, we had several roles with predefined sets of features that each role can access. The system has an administrator roles. Users can’t freely register to the system, the admins add them to the system and then assign a role to them. In the actual system I worked with, users passwords are generated by the application and then sent to the respective user’s mail. To keep this post simple, I’ll make administrator set the password directly.

1. Adding needed gems

Add these lines to your Gemfile:

[cc lang="ruby"]gem ‘devise’
gem ‘cancan’[/cc]

then install the gems with this command from your command line:

[cc lang="bash"]bundle install[/cc]

2. Adding Devise to your project

Run these commands from your command line:

[cc lang="bash"]
rails generate devise:install
rails generate devise User
[/cc]

3. Modifying user model and migration file

As said before, I needed the user management feature to be able to add, delete, and modify users through a CRUD mechanism. Therefore, there are several things we need to change in our user model and migration file. First, we delete the “registerable” attribute.  Second, we add a “username” attribute to the model and to the migration file. Here is how your user model should look like:

[cc lang="ruby"]
class User < ActiveRecord::Base # Include default devise modules. Others available are: # :token_authenticatable, :confirmable, :lockable and :timeoutable devise :database_authenticatable, :recoverable, :rememberable, :trackable, :validatable # Setup accessible (or protected) attributes for your model attr_accessible :email, :username, :password, :password_confirmation, :remember_me end [/cc] and your migration file for user should look like this: [cc lang="ruby"] class DeviseCreateUsers < ActiveRecord::Migration def self.up create_table(:users) do |t| t.database_authenticatable :null => false
t.recoverable
t.rememberable
t.trackable
t.string :username

# t.confirmable
# t.lockable :lock_strategy => :failed_attempts, :unlock_strategy => :both
# t.token_authenticatable

t.timestamps
end

add_index :users, :email, :unique => true
add_index :users, :reset_password_token, :unique => true
# add_index :users, :confirmation_token, :unique => true
# add_index :users, :unlock_token, :unique => true
end

def self.down
drop_table :users
end
end
[/cc]

4. Modifying the routes

When we installed Devise, it added it’s own routes to our routes.rb file. Since we want to have CRUD ability, we have to add another routes for our user resources. So this is what we do:

[cc lang="ruby"]
DeviseTest::Application.routes.draw do
devise_for :users
resources :users

# add another lines as you need…
end
[/cc]

5. Creating the controller and views

In this step, we can just use a generic controller and views template that usually created when you use rails generator to do a scaffolding. Anyway, this is how my users_controller.rb looks:

[cc lang="ruby"]
class UsersController < ApplicationController # GET /users # GET /users.xml def index @users = User.all respond_to do |format| format.html # index.html.erb format.xml { render :xml => @users }
end
end

# GET /users/1
# GET /users/1.xml
def show
@user = User.find(params[:id])

respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @user }
end
end

# GET /users/new
# GET /users/new.xml
def new
@user = User.new
@current_method = “new”

respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @user }
end
end

# GET /users/1/edit
def edit
@user = User.find(params[:id])
end

# POST /users
# POST /users.xml
def create
@user = User.new(params[:user])

respond_to do |format|
if @user.save
format.html { redirect_to(@user, :notice => ‘User was successfully created.’) }
format.xml { render :xml => @user, :status => :created, :location => @user }
else
format.html { render :action => “new” }
format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
end
end
end

# PUT /users/1
# PUT /users/1.xml
def update
@user = User.find(params[:id])

respond_to do |format|
if @user.update_attributes(params[:user])
format.html { redirect_to(@user, :notice => ‘User was successfully updated.’) }
format.xml { head :ok }
else
format.html { render :action => “edit” }
format.xml { render :xml => @user.errors, :status => :unprocessable_entity }
end
end
end

# DELETE /users/1
# DELETE /users/1.xml
def destroy
@user = User.find(params[:id])
@user.destroy

respond_to do |format|
format.html { redirect_to(users_url) }
format.xml { head :ok }
end
end
end
[/cc]

Again, although this is a generated view, I’ll include it here anyway. Here’s our _form.html.erb:

[cc lang="ruby"]
<%= form_for(@user) do |f| %>
<% if @user.errors.any? %>

<%= pluralize(@user.errors.count, "error") %> prohibited this user from being saved:

    <% @user.errors.full_messages.each do |msg| %>

  • <%= msg %>
  • <% end %>

<% end %>

<%= f.label :email %>
<%= f.text_field :email %>
<%= f.label :username %>
<%= f.text_field :username %>

<% if @current_method == "new" %>

<%= f.label :password %>
<%= f.password_field :password %>
<%= f.label :password_confirmation %>
<%= f.password_field :password_confirmation %>

<% end %>

<%= f.submit %>

<% end %>
[/cc]

Our edit.html.erb:
[cc lang="ruby"]

Editing user

<%= render 'form' %>

<%= link_to 'Show', @user %> |
<%= link_to 'Back', users_path %>
[/cc]

Our index.html.erb:
[cc lang="ruby"]

Listing users

<% @users.each do |user| %>

<% end %>

Email Username
<%= user.email %> <%= user.username %> <%= link_to 'Show', user %> <%= link_to 'Edit', edit_user_path(user) %> <%= link_to 'Destroy', user, :confirm => ‘Are you sure?’, :method => :delete %>

<%= link_to 'New user', new_user_path %>
[/cc]

Our new.html.erb:
[cc lang="ruby"]

New user

<%= render 'form' %>

<%= link_to 'Back', users_path %>
[/cc]

And the last… our show.html.erb:
[cc lang="ruby"]

<%= notice %>

Email:
<%= @user.email %>

Username:
<%= @user.username %>

<%= link_to 'Edit', edit_user_path(@user) %> |
<%= link_to 'Back', users_path %>
[/cc]

6. Using the Devise

In order Devise to really work, we have to put this line in every controller that can only be accessed by authenticated users.

[cc lang="ruby"]
before_filter :authenticate_user!
[/cc]

Next Step

Well, it’s a long post already… . I guess it’s better for us to take a break. So, this is the first part. We have not used CanCan yet, but now we have a working user management feature as we wanted it in the beginning. Hope this post helps you with your own project using Devise. I’ll write the second part where we will use CanCan as soon as possible.

Back to top