Autorização no Rails com Pundit

Introdução

O Pundit é uma gem de autorização (ou seja, que garante que os recursos só sejam acessados por quem tem autorização). Ele faz isso criando classes de política de acesso para cada model que for autorizado e por padrão (mas não fixo) a classe terá como nome o model + “Policy”.

Para explicar pra vocês como utilizar a gem, vou utilizar um exemplo de uma locadora de filmes. Nela teremos um usuário que tem privilégios de administrador e outro não, onde o administrador pode gerenciar os filmes e o outro apenas criar uma locação e listar as locações feitas.

O que vamos aprender

– Como funciona o Pundit

– Como implementar autorizações no Rails

– Como definir os escopos de acesso

Ingredientes

– Ruby 2.4.1

– Rails 5.1

– Sqlite 3

– Pundit (gem)

– Devise (gem)

Objetivos

Apesar de estarmos utilizando a gem Devise para autenticação, o nosso foco é o Pundit. Queremos que você termine este post compreendendo melhor como utilizar esta ferramenta muito interessante para melhorar a autorização do seu app.

Vamos ao código \o/

Configurações iniciais do nosso app

Primeiro, vamos gerar nosso projeto:

rails new movie_rental

1	rails new movie_rental

Entre na pasta do projeto:

cd movie_rental

1	cd movie_rental

Inclua as gems do Devise e do Pundit no seu Gemfile:

gem 'devise'
gem 'pundit'

1 2	gem 'devise' gem 'pundit'

Instale as gems:

bundle

bundle

Instale o devise

rails g devise:install

1	rails g devise:install

Vamos gerar um model User com o devise

rails g devise User

1	rails g devise User

E executar nossos migrates

rails db:migrate

1	rails db:migrate

Agora que já temos o nosso model User criado, vamos criar alguns scaffolds que utilizaremos depois para colocarmos as autorizações

Configurando nossos Scaffolds

Primeiro, vamos criar o scaffold para os filmes com atributos para o nome e outro para o tipo:

rails g scaffold movie name kind

1	rails g scaffold movie name kind

Depois, vamos criar um outro scaffold para a locação com atributos para data da locação, o filme e o usuário que criou:

rails g scaffold rental date:datetime movie:references user:references

1	rails g scaffold rental date:datetime movie:references user:references

Na partial de form do Rental que foi criado com o scaffold, precisamos colocar um select para os filmes (app/views/rentals/_form.html.erb).

a – Na linha onde foi gerado o seguinte código:

<%= form.text_field :movie_id, id: :rental_movie_id %>

1	<%= form.text_field :movie_id, id: :rental_movie_id %>

b – Substitua por:

<%= form.select :movie_id, Movie.all.collect {|m| [ m.name, m.id ] }, id: :rental_movie_id %>

1	<%= form.select :movie_id, Movie.all.collect {\|m\| [ m.name, m.id ] }, id: :rental_movie_id %>

c – E remova as linhas a baixo

<div class="field">
 <%= form.label :user_id %>
 <%= form.text_field :user_id, id: :rental_user_id %>
</div>

<%= form.label :user_id %>

<%= form.text_field :user_id, id: :rental_user_id %>

</div>

No controller RentalsController (app/controllers/rentals_controller.rb):

a – Na linha para filtrar os parâmetros, substitua o conteúdo a baixo:

def rental_params
  params.require(:rental).permit(:date, :movie_id)
end

def rental_params

params.require(:rental).permit(:date, :movie_id)

end

b – Pelo conteúdo a seguir, para armazenarmos sempre o id do usuário que criou o aluguel:

def rental_params
  params.require(:rental).permit(:date, :movie_id).merge(user_id: current_user.id)
end

def rental_params

params.require(:rental).permit(:date, :movie_id).merge(user_id: current_user.id)

end

No arquivo config/routes.rb, adicione:

root to: "rentals#index"

1	root to: "rentals#index"

Configure o ApplicationController para autenticar o usuário, adicionando a seguinte linha (app/controllers/application_controller.rb):

before_action :authenticate_user!

1	before_action :authenticate_user!

Agora vamos criar um atributo para identificar se o usuário é ou não admin:

rails g migration add_admin_to_users admin:boolean

1	rails g migration add_admin_to_users admin:boolean

E vamos executar os migrations

rails db:migrate

1	rails db:migrate

Agora vamos à parte principal do post! O PUNDIT \o/

Antes de tudo, nós temos que configurar o pundit no nosso app.

Primeiro, vamos criar um arquivo de política geral

rails g pundit:install

1	rails g pundit:install

Após executar este comando, foi criado com arquivo no caminho app/policies. O arquivo gerado é o ApplicationPolicy, ele segue o mesmo raciocínio do ApplicationController, é uma classe de onde todas as políticas vão herdar.

O conteúdo autogerado do meu arquivo, eu sobrescrevi por este, onde removi as ações padrão do Pundit (arquivo app/policies/application_policy.rb):

class ApplicationPolicy
  attr_reader :user, :record

  def initialize(user, record)
    @user = user
    @record = record
  end
 
  class Scope
    attr_reader :user, :scope


    def initialize(user, scope)
      @user = user
      @scope = scope
    end

    def resolve
      scope
    end
  end
end

class ApplicationPolicy

attr_reader :user, :record

def initialize(user, record)

@user = user

@record = record

end

class Scope

attr_reader :user, :scope

def initialize(user, scope)

@user = user

@scope = scope

end

def resolve

scope

end

Repare: a política é uma classe pura do Ruby. Ela é inicializada com um registro de usuário (user) e um registro dos objetos que queremos autorizar (record). E como temos um attr_reader para estes dois registros, os métodos get destes atributos vão ficar disponíveis inclusive para a classe que herdar dela. A classe Scope interna a ela também é bem importante. Mas chegaremos lá =D.

As ações padrões que eu disse lá em cima são as seguintes: se você criar um arquivo de autorização para algum model e ele não tiver a autorização para uma determinada ação, ele vai buscar no ApplicationPolicy.

Por que eu removi as padrões? Para que a gente possa fazer um passo a passo mais claro sem nos preocuparmos com ele =)

Agora vamos seguir alguns passos para autorizar um recurso e já explico o que foi feito:

Vamos incluir o Pundit nos controllers. Para isso nós vamos no ApplicationController e incluir a linha (app/controllers/application_controller.rb):

include Pundit

1	include Pundit

Depois de incluir o Application Controller ficou desse jeito:

class ApplicationController < ActionController::Base
  include Pundit

  protect_from_forgery with: :exception
  before_action :authenticate_user!
end

class ApplicationController < ActionController::Base

include Pundit

protect_from_forgery with: :exception

before_action :authenticate_user!

end

Crie a classe para autorização aos filmes (model Movie):

rails g pundit:policy movie

1	rails g pundit:policy movie

(Perceba que ele criou um arquivo chamado MoviePolicy apenas com a classe Scope. Calma, vamos chegar na Scope.)

Vamos no arquivo MoviePolicy (app/policies/movie_policy.rb) e incluir o seguinte método: (ele deve ficar dentro da classe MoviePolicy, mas fora da classe Scope)

def index?
  user.admin?
end

def index?

user.admin?

end

Apenas como amostra, o MoviePolicy ficou assim:

class MoviePolicy < ApplicationPolicy
  def index?
    user.admin?
  end

  class Scope < Scope
    def resolve
      scope
    end
  end
end

class MoviePolicy < ApplicationPolicy

def index?

user.admin?

end

class Scope < Scope

def resolve

scope

end

Vamos no controller de filme, o MoviesController, e lá na action :index, vamos deixá-la da seguinte forma (app/controllers/movies_controller.rb):

def index
  authorize Movie
  @movies = Movie.all
end

def index

authorize Movie

@movies = Movie.all

end

O que foi feito nestes passos?

Depois que incluímos o Pundit no ApplicationController, foi criado um método chamado “index?” dentro do MoviePolicy. Este método é que vai executar a verificação de autorização conforme a operação lógica que está dentro dele.

Então, quando eu chamo “authorize Movie” na action :index do meu controller, eu estou dizendo: “Verifique na política do Movie se o acesso para a ação index está liberado”. Com isso, o método “index?” da política foi executado.

Mas, o método authorize ainda pode ser chamado de outras formas.
Como assim? Há quatro jeitos de chamar o authorize e vou usar o Movie como exemplo:

authorize Movie
authorize Movie, :any_action?
authotize @movie
authorize @movie, :any_action?

authorize Movie

authorize Movie, :any_action?

authotize @movie

authorize @movie, :any_action?

No primeiro authorize eu estou dizendo que será válido para qualquer filme (movie). Inclusive, quando eu chamo o “authorize” desta forma (com a classe), o registro (record) no arquivo Policy vem nulo. Ele pode ser utilizado quando você não precisa do objeto para autorizar.
No segundo eu estou especificando a ação que eu quero chamar no arquivo da política. Quando eu não especifico, ele considera a action atual do controller.
No terceiro eu estou especificando um objeto. É para quando é necessário fazer a autorização para um registro específico e nele o seu record vai ser preenchido para você poder construir as regras.
E no quarto, especificando a action e enviando um objeto, é o mesmo do segundo mas com o record da política preenchido.

Quando chamados este authorize, por baixos dos panos o Pundit está procurando quem é a classe de política do Movie, no caso a MoviePolicy, instanciando-a com o usuário, que por padrão ele pega o :current_user do controller, e com o registro (se for classe, ele instancia com nulo). Então, é chamado o método compatível com a ação.

Voltando ao código….

Eu sei que independente do filme, apenas o administrador vai poder acessar as ações. Então, para isso eu vou criar um hook before action no meu MovieController para ele sempre autorizar antes mesmo de fazer alguma operação:

Crie o seguinte método em MoviesController (app/controllers/movies_controller.rb), de preferência como private:

def authorize_movie
  authorize Movie
end

def authorize_movie

authorize Movie

end

Adicione na primeira linha da sua classe:

before_action :authorize_movie

1	before_action :authorize_movie

Remova o authorize da action :index, deixando ela desta forma:

def index
  @movies = Movie.all
end

def index

@movies = Movie.all

end

Vamos criar as autorizações para cada action de MoviesController em MoviePolicy, deixando o MoviePolicy da seguinte forma (app/policies/movie_policy.rb):

class MoviePolicy < ApplicationPolicy
  class Scope < Scope
    def resolve
      scope
    end
  end

  def index?
    user.admin?
  end

  def new?
    user.admin?
  end

  def create?
    user.admin?
  end

  def show?
    user.admin?
  end

  def edit?
   user.admin?
  end

  def update?
    user.admin?
  end

  def destroy?
    user.admin?
  end
end

class MoviePolicy < ApplicationPolicy

class Scope < Scope

def resolve

scope

end

def index?

user.admin?

end

def new?

user.admin?

end

def create?

user.admin?

end

def show?

user.admin?

end

def edit?

user.admin?

end

def update?

user.admin?

end

def destroy?

user.admin?

end

Mas, espera, e quando eu não tenho autorização a uma página e tento acessar? Bem, o Pundit retorna um erro: Pundit::NotAuthorizedError.

Com este erro, nós podemos adicionar mais um item em nosso ApplicationController para identificar este erro e, em vez de parar nossa aplicação, retornar o usuário para tela de filmes alugados. Para isso, adicione o seguinte código no ApplicationController (app/controllers/application_controller.rb):

rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

private

def user_not_authorized
  redirect_to root_path
end

rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

private

def user_not_authorized

redirect_to root_path

end

Neste método “user_not_authorized” é possível retornar uma mensagem, setar uma flash message e várias outras coisas. Mas para simplificar eu vou apenas retornar o usuário para a tela de aluguéis.

Agora de volta aos aluguéis…

Vamos finalizar a parte de configurar as autorizações criando as políticas de acesso para as actions to Aluguel (Rental)

Crie o arquivo de policy do Aluguel:

rails g pundit:policy rental

1	rails g pundit:policy rental

Preencha o arquivo RentalPolicy (app/policies/rental_policy.rb) com as autorizações para as actions, deixando-o da seguinte forma:

class RentalPolicy < ApplicationPolicy
  class Scope < Scope
    def resolve
      scope
    end
  end

  def show?
    user.admin? || record.user == user
  end

  def edit?
    user.admin? || record.user == user
  end

  def update?
    user.admin? || record.user == user
  end

  def destroy?
    user.admin? || record.user == user
  end
end

class RentalPolicy < ApplicationPolicy

class Scope < Scope

def resolve

scope

end

def show?

user.admin? || record.user == user

end

def edit?

user.admin? || record.user == user

end

def update?

user.admin? || record.user == user

end

def destroy?

user.admin? || record.user == user

end

Crie um método privado em RentalsController para autorizar as ações (app/controllers/rentals_controller.rb):

def authorize_rental
  authorize @rental
end

def authorize_rental

authorize @rental

end

Configure os before_actions do RentalsController da seguinte forma:

class RentalsController < ApplicationController
 before_action :set_rental, only: [:show, :edit, :update, :destroy]
 before_action :authorize_rental, only: [:show, :edit, :update, :destroy]  …
end

class RentalsController < ApplicationController

before_action :set_rental, only: [:show, :edit, :update, :destroy]

before_action :authorize_rental, only: [:show, :edit, :update, :destroy] …

end

O que fizemos nestes códigos foram:

Criar uma política de acesso para as actions de aluguel (Rental)
Criar um método para fazer a autorização do aluguel utilizando o objeto
Configurar os before_actions to controller para carregar o aluguel antes e depois, autorizá-lo.

Você deve ter percebido que eu não criei políticas para as ações index, new e create do aluguel. Bem fiz isso porque qualquer usuário pode criar um aluguel de um filme, mas somente quem criou o aluguel ou o administrador pode editar ou excluir. Foi justamente por isso que nas verificações da política, eu checo se o usuário é administrador ou é o dono do aluguel (Rental).

Vamos ver daqui há pouco que cada um só vai conseguir ver os aluguéis que criou.

Enfim, o escopo…

Com o pundit, nós podemos definir os escopos dos models. Hã? Bem, há situações, como a do aluguel, que eu não quero que o usuário veja os aluguéis do outro a não ser que ele seja o administrador.

E como podemos fazer isso? Simples, vamos utilizar o Scope que esta dentro do arquivo RentalPolicy.

Vamos colocar os seguintes trechos de codigo:

No arquivo RentalPolicy, coloque o seguinte conteúdo na classe Scope (app/policies/rental_policy.rb):

class Scope < Scope
  def resolve
    if user.admin?
      scope.all
    else
      scope.where(user: user)
    end
  end
end

class Scope < Scope

def resolve

if user.admin?

scope.all

else

scope.where(user: user)

end

Substitua o método index do RentalsController, por este (app/controllers/rentals_controller.rb):

def index
  @rentals = policy_scope(Rental).all
end

def index

@rentals = policy_scope(Rental).all

end

O que estamos fazendo neste trecho de código é: definindo um escopo que diz que se usuário for administrador, todos os aluguéis serão retornados e se ele não for, somente os aluguéis que ele é dono serão retornados. E na action :index do RentalsController eu estou dizendo: “use o escopo definido na policy de Aluguel (Rental)”.

Se visitarmos o sistema e criarmos uma novo usuário, veremos que todos ao aluguéis só serão exibidos para o usuário que tiver o atributo admin: true.

E para fechar…

Quero mostrar mais uma última e incrível feature que o Pundit nos fornece: meios de verificar a autorização no frontend.

Primeiro, abra o seu application.html.erb e adicione o seguinte trecho dentro do body antes do yield (app/views/layouts/application.html.erb)

 <%= link_to "Movies", movies_path %>
 <%= link_to "Rental", rentals_path %>
 <%= link_to "Logout", destroy_user_session_path, method: :delete %>
 <%= yield %>

<%= link_to "Movies", movies_path %>

<%= link_to "Rental", rentals_path %>

<%= link_to "Logout", destroy_user_session_path, method: :delete %>

<%= yield %>

Perceba que acabamos de adicionar 3 links: Um para ir para a lista de filmes, outro para ir para a lista de aluguéis e outro para Logout.

Mas pense comigo: Por que um usuário comum deveria ver o link “Movies” se é uma tela que ele não pode acessar? A resposta é: ele não deveria.

Poderíamos verificar se ele é admin no front-end? Poderíamos. Mas imagina o trabalho de, caso as políticas mudarem, ter quer ir no policy e alterar, depois sair procurando onde você estava checando se o usuário é admin… HARD.

Vamos usar o PUNDIT!

Coloque este código no seu body do application.html.erb (app/views/layouts/application.html.erb):

 <% if user_signed_in? %>
   <% if policy(Movie).index? %>
     <%= link_to "Movies", movies_path %>
   <% end %>
   <%= link_to "Rental", rentals_path %>
   <%= link_to "Logout", destroy_user_session_path, method: :delete %>
 <% end %>

<% if user_signed_in? %>

<% if policy(Movie).index? %>

<%= link_to "Movies", movies_path %>

<% end %>

<%= link_to "Rental", rentals_path %>

<%= link_to "Logout", destroy_user_session_path, method: :delete %>

<% end %>

Ele disponibiliza um meio da gente chamar a política sem precisar ficar instanciando nada e ainda verifica se o usuário atual tem permissão para uma determinada ação.
Neste caso, primeiro eu verifico se o usuário está logado e depois chamo o método :index? da política MoviePolicy. É o mesmo método que usado para validar a action :index do MoviesController!

Onde eu coloquei:

policy(Movie).index?

1	policy(Movie).index?

Eu também poderia ter colocado, caso quisesse validar um objeto @movie específico em alguma view:

policy(@movie).index?

1	policy(@movie).index?

E o mais incrível, ele vai instanciar a classe exatamente do mesmo jeito que o authorize no controller: enviou uma classe, vai com record nulo, enviou objeto, vai record preenchido.

Aah.. e não esqueçam de acessar o seu console para poder colocar o seu usuário como admin caso você queira acessar as view de Movie. Afinal, neste exemplo nós não nos preocupamos com uma view voltada para o perfil do usuário para não desfocar.

Caso tenham alguma dúvida, aqui vai uma colinha =)

rails c

rails c

E dentro do console:

User.find_by(email: ).update(admin: true)

1	User.find_by(email: ).update(admin: true)

12 formas de vencer o bloqueio criativo e escrever textos memoráveis (e 6 dicas extras)

Não perca nenhum conteúdo

Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/

Conclusão

O Pundit é uma ferramenta que nos proporciona um meio de fazer autorizações no nosso app seguindo um padrão muito bem formado de arquivos de política utilizando convenção sobre configuração, além de proporcionar diversas facilidades para que possamos concentrar nossas permissões todas em apenas um arquivo de políticas do model.

É isso, galera!

O Post ficou grande, mas eu queria trazer pra vocês a grande ferramenta que o Pundit é e como ele pode ajudar nosso dia-a-dia de dev =D

Para mais detalhes, eu recomendo a leitura dos docs do Pundit:

https://github.com/elabs/pundit

E os trechos de códigos que foram colocados aqui foram tirados de um app de exemplo que construímos:

https://github.com/OneBitCodeBlog/movie_rental

E é isso, galera! Se precisarem de um help, só chamar! \o/

Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!

O OneBitCode traz conteúdos de qualidade, e em português, sobre programação com foco em Ruby on Rails e também JavaScript.
Além disso, aqui sempre levamos à você conteúdos valiosos sobre a carreira de programação, dicas sobre currículos, portfólios, perfil profissional, soft skills, enfim, tudo o que você precisa saber para continuar evoluindo como Programador(a)!

Fique por dentro de todos os conteúdos o/

Nossas redes sociais:

📹 • https://youtube.com/Onebitcode [Live todas as terças-feiras às 19h)
💻 • https://linkedin.com/company/onebitcode
🙂 • https://facebook.com/onebitcode
📱 • https://instagram.com/one_bit_code
🐦 • https://twitter.com/onebitcode

Nossos cursos:

🥇 • Programador Full Stack Javascript em 8 Semanas
💎 • Curso Completo de Ruby
⚙ • Minicurso: API Rails 5 Completo
🐞 • Minicurso de Testes para Ruby on Rails com RSpec

Espero que curta nossos conteúdos e sempre que precisar de ajuda, fala com a gente!
Estamos aqui para você 🙂

Bem-vindo à família OneBitCode o/

0 0 votes

Article Rating

janeiro 17, 2020

Posts | Cursos

Daniel Moreto

Programador, Rubysta e praticante de Budo Taijutsu. Adoro discutir ideias, estar inserido em ambientes inovativos e, é claro, programar. Acredito que a programação é um conhecimento que vai muito além de construir softwares. LinkedIn: https://www.linkedin.com/in/dfmoreto Github: https://github.com/dfmoreto

Website :

8 Comentários

Oldest

Newest Most Voted

Inline Feedbacks

View all comments

Donato Azevedo

4 anos atrás

Legal conhecer este pundit. Eu costumo usar o CanCanCan com a classe Ability para definir a politica de Authorization, mas achei este modelo segmentado (em que uma classe “ClassPolicy” define as políticas) mais inteligível.

Nas minhas aplicações maiores, o Ability.rb já está ficando insustentável.

Responder

Admin

Leonardo Scorza

4 anos atrás

Reply to Donato Azevedo

Legal Donato, bora testar 🙂

Responder

romenigld

4 anos atrás

Muito bom tutorial, mas acho que tem que tirar o end desse método:

def authorize_rental
authorize @rentalend
end

e mudar para:

def authorize_rental
authorize @rental
end

Responder

Admin

Leonardo Scorza

4 anos atrás

Reply to romenigld

E a cara beleza?
Valeu por acompanhar o Blog e por fazer esse report (ajustamos)
Abraço

Responder

Glaucia

4 anos atrás

Dá pra usar o Pundit quando tem múltiplas regras de usuários, como: admin, manager, user ?

Responder

Autor

Daniel Moreto

4 anos atrás

Reply to Glaucia

Ei, Gláucia. Dá sim, sem problemas. No arquivo de política, na parte do Scope, vc pode colocar ifs e elses (ou case when) para pegar pegar o escopo de cada uma. O mesmo vale para as actions no arquivo de política, vc pode verificar se o usuário é admin, manager ou qualquer outro profile.

Responder

Felipe Maciel Ramos Vieira

3 anos atrás

Muito bom!

Responder

Carlos

2 anos atrás

Imaginei um cenário e não identifiquei onde colocaria:
Cenário:
Dependente esta autorizado ao locar filme em nome do titular.
Exemplo filho que aluga o filme na conta do pai.
Teria que fazer algumas checagem.
filho pode locar?
filho pode locar em nome de alguém?
este alguém autorizou este dependente?

Responder

Autorização no Rails com Pundit

Configurações iniciais do nosso app

Configurando nossos Scaffolds

Agora vamos à parte principal do post! O PUNDIT \o/

Não perca nenhum conteúdo

Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/

Conclusão

Primeira vez no OneBitCode? Curtiu esse conteúdo? O OneBitCode tem muito mais para você!

Nossas redes sociais:

Nossos cursos:

Daniel Moreto

Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!