Autorización Con Pundit

() translation by (you can also view the original English article)

Pundit es una herramienta que te permite restringir ciertas partes de tu aplicación Rails a usuarios autorizados. Hace esto proporcionándote ciertos ayudantes.

En este tutorial, construirás un blog que restringe partes tales como crear, actualizar y borrar artículos solo para usuarios autorizados.

Comenzando

Comienza generando una nueva aplicación Rails.

1	rails new pundit-blog -T

La bandera -T le dice a Rails que genere la nueva aplicación sin la suite de prueba por defecto. Ejecutar el comando generará tu aplicación Rails e instalará los gems por defecto.

Continúa y agrega los siguientes gems a tu Gemfile. Estarás usando bootstrap-sass para el diseño de tu aplicación, y Devise manejará la autenticación de usuario.

#Gemfile

...
gem 'bootstrap-sass'
gem 'devise'

Ejecuta el comando para instalar el gem.

1	bundle install

Ahora renombra app/assets/stylesheets/application.css a app/assets/stylesheets/application.scss. Agrega las siguientes líneas de código para importar bootstrap.

#app/assets/stylesheets/application.scss

...
@import 'bootstrap-sprockets';
@import 'bootstrap';

Crea un parcial llamado _navigation.html.erb para contener tu código de navegación; el parcial debería estar ubicado en el directorio app/views/layouts. Haz que el parcial luzca como lo que tengo abajo.

#app/views/layouts/_navigation.html.erb

<nav class="navbar navbar-inverse">
  <div class="container">
    <div class="navbar-header">
      <%= link_to 'Pundit Blog', root_path, class: 'navbar-brand' %>
    </div>
    <div id="navbar">
 
    <ul class="nav navbar-nav pull-right">
      <li><% link_to 'Home', root_path %></li>
      <ul class="nav navbar-nav pull-right">
        <% if user_signed_in? %>
        <li><%= current_user.email %></li>
        <li><%= link_to 'Log out', destroy_user_session_path, method: :delete %></li>
        <% else %>
          <li><%= link_to 'Log In', new_user_session_path %></li>
          <li><%= link_to 'Sign Up', new_user_registration_path %></li>
        <% end %>
      </ul>
    </ul>
  </div>
</nav>

Para que la navegación sea usada, necesitas generarla en tu diseño de aplicación. Modifica tu diseño de aplicación para que luzca como lo que tengo abajo.

#app/views/layouts/application.html.erb

<!DOCTYPE html>
<html>
  <head>
    <title>Pundit-Blog</title>
    <%= csrf_meta_tags %>

    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body>
    <%= render "layouts/navigation" %>
    <div id="flash">
      <% flash.each do |key, value| %>
        <div class="flash <%= key %>"><%= value %></div>
      <% end %>
    </div>
    <div class="container-fluid">
      <%= yield %>
    </div>
  </body>
</html>

General el Modelo de Usuario

Ejecuta el comando para instalar Devise.

1	rails generate devise:install

Ahora genera tu modelo de Usuario.

1	rails generate devise User

Migra tu base de datos.

1	rake db:migrate

Genera Recursos de Artículo

Ejecuta el comando para generar tus recursos de Artículo.

1	rails generate scaffold Articles title:string body:text

Esto generará tu ArticlesController y Modelo de Artículo. También generará las vistas necesarias.

Ahora migra tu base de datos ejecutando:

1	rake db:migrate

Abre app/views/articles/_form.html.erb y hazlo lucir como lo que tengo abajo.

#app/views/articles/_form.html.erb

<%= form_for(article) do |f| %>
  <% if article.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(article.errors.count, "error") %> prohibited this article from being saved:</h2>

      <ul>
      <% article.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= f.label :title %>
    <%= f.text_field :title %>
  </div>

  <div class="field">
    <%= f.label :body %>
    <%= f.text_area :body %>
  </div>

  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

Para tu archivo index, debería lucir así.

#app/views/articles/index.html.erb

<table class="table table-bordered table-striped table-condensed table-hover">
  <thead>
  <tr>
    <th>Title</th>
    <th>Body</th>
    <th colspan="3"></th>
  </tr>
  </thead>

  <tbody>
    <% @articles.each do |article| %>
    <tr>
      <td><%= article.title %></td>
      <td><%= article.body %></td>
      <td><%= link_to 'Show', article %></td>
      <td><%= link_to 'Edit', edit_article_path(article) %></td>
      <td><%= link_to 'Destroy', article, method: :delete, data: { confirm: 'Are you sure?' } %></td>
    </tr>
    <% end %>
  </tbody>
</table>

<br>

<%= link_to 'New article', new_article_path %>

El código de arriba acomoda los artículos en la página index en un formato de tabla para hacerlo lucir presentable.

Abre tu archivo de rutas y agrega la rut apara los recursos de artículos.

#config/routes.rb

...
  resources :articles
  root to: "articles#index"

Integra Pundit

Agrega el gem Pundit a tu Gemfile.

1	#Gemfile
2
3	...
4	gem 'pundit'

Ejecuta el comando para instalar.

1	bundle install

Integra Pundit a tu aplicación agregando la siguiente línea a tu ApplicationController.

#app/controllers/application_controller.rb

...
  include Pundit
...

Ejecuta el generador de Pundit.

1	rails g pundit:install

Esto generará una carpeta app/policies que contiene una clase base con políticas. Cada política es una clase Ruby básica.

Así es como luce la clase básica de política.

#app/policies/application_policy.rb

class ApplicationPolicy
  attr_reader :user, :record

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

  def index?
    false
  end

  def show?
    scope.where(:id => record.id).exists?
  end

  def create?
    false
  end

  def new?
    create?
  end

  def update?
    false
  end

  def edit?
    update?
  end

  def destroy?
    false
  end

  def scope
    Pundit.policy_scope!(user, record.class)
  end

  class Scope
    attr_reader :user, :scope

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

    def resolve
      scope
    end
  end
end

Crea la Política de Artículo

Ahora necesitas escribir tu propia política. Para este tutorial, quieres permitir solo usuarios registrados para que creen nuevos artículos. Además de eso, solo los creadores de un artículo deberían poder editar y borrar el artículo.

Para lograr esto, tu política de artículo lucirá así.

#app/policies/article_policy.rb

class ArticlePolicy < ApplicationPolicy
  def index?
    true
  end

  def create?
    user.present?
  end

  def update?
    return true if user.present? && user == article.user
  end

  def destroy?
    return true if user.present? && user == article.user
  end

  private

    def article
      record
    end
end

En lo de arriba, estás permitiendo a todos (usuarios registrados y no registrados) ver la página index. Para crear un nuevo artículo, un usuario tiene que estar registrado. Usas user.present? para averiguar si el usuario que está intentando realizar la acción está registrado.

Para actualizar y borrar, quieres asegurarte de que solo el usuario que creó el artículo pueda realizar estas acciones.

En este punto, necesitas establecer una relación entre tu modelo de Artículo y Usuario.

Lo haces generando una nueva migración.

1	rails generate migration add_user_id_to_articles user:references

Después, migra tu base de datos ejecutando el comando:

1	rake db:migrate

Abre el modelo User y agrega la línea que sella la relación.

1	#app/models/user.rb
2
3	...
4	has_many :articles

Tu modelo Article debería tener esto.

1	#app/models/article.rb
2
3	...
4	belongs_to :user

Ahora necesitas actualizar tu ArticlesController para que esté en sincronía con lo que has hecho hasta ahora.

#app/controllers/articles_controller.rb

class ArticlesController < ApplicationController
  before_action :set_article, only: [:show, :edit, :update, :destroy]

  # GET /articles
  # GET /articles.json
  def index
    @articles = Article.all
    authorize @articles
  end

  # GET /articles/1
  # GET /articles/1.json
  def show
  end

  # GET /articles/new
  def new
    @article = Article.new
    authorize @article
  end

  # GET /articles/1/edit
  def edit
  end

  # POST /articles
  # POST /articles.json
  def create
    @article = Article.new(article_params)
    @article.user = current_user
    authorize @article

    respond_to do |format|
      if @article.save
        format.html { redirect_to @article, notice: 'Article was successfully created.' }
        format.json { render :show, status: :created, location: @article }
      else
        format.html { render :new }
        format.json { render json: @article.errors, status: :unprocessable_entity }
      end
    end
  end

  # PATCH/PUT /articles/1
  # PATCH/PUT /articles/1.json
  def update
    respond_to do |format|
      if @article.update(article_params)
        format.html { redirect_to @article, notice: 'Article was successfully updated.' }
        format.json { render :show, status: :ok, location: @article }
      else
        format.html { render :edit }
        format.json { render json: @article.errors, status: :unprocessable_entity }
      end
    end
  end

  # DELETE /articles/1
  # DELETE /articles/1.json
  def destroy
    @article.destroy
    respond_to do |format|
      format.html { redirect_to articles_url, notice: 'Article was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  private
    # Use callbacks to share common setup or constraints between actions.
    def set_article
      @article = Article.find(params[:id])
      authorize @article
    end

    # Never trust parameters from the scary internet, only allow the white list through.
    def article_params
      params.require(:article).permit(:title, :body, :user_id)
    end
end

En este punto en tu aplicación, has implementado satisfactoriamente políticas que restringen ciertas partes de tu aplicación a usuarios selectos.

Quieres agregar un mensaje de error estándar que muestre cuando un usuario no autorizado intenta acceder a una página restringida. Para hacerlo, agrega lo siguiente a tu ApplicationController.

#app/controllers/application_controller.rb

...
  rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

  private

    def user_not_authorized
      flash[:warning] = "You are not authorized to perform this action."
      redirect_to(request.referrer || root_path)
    end

Este código simplemente genera un texto básico que le dice al usuario que no está autorizado para realizar la acción.

Ejecuta:

1	$ rails server

Para comenzar tu servidor Rails, apunta a tu navegador a https://localhost:3000 para ver lo que tienes.

Conclusión

En este tutorial, aprendiste cómo trabajar con Devise y Pundit. Pudiste crear políticas que permitieron solo a usuarios autorizados ver ciertas partes de la aplicación. También creaste un texto de error básico que muestra cuando un usuario no autorizado intenta acceder a una parte restringida de la aplicación.

Puedes aprender más sobre Pundit revisando la página de GitHub.

1	#app/policies/application_policy.rb
2
3	class ApplicationPolicy
4	attr_reader :user, :record
5
6	def initialize(user, record)
7	@user = user
8	@record = record
9	end
10
11	def index?
12	false
13	end
14
15	def show?
16	scope.where(:id => record.id).exists?
17	end
18
19	def create?
20	false
21	end
22
23	def new?
24	create?
25	end
26
27	def update?
28	false
29	end
30
31	def edit?
32	update?
33	end
34
35	def destroy?
36	false
37	end
38
39	def scope
40	Pundit.policy_scope!(user, record.class)
41	end
42
43	class Scope
44	attr_reader :user, :scope
45
46	def initialize(user, scope)
47	@user = user
48	@scope = scope
49	end
50
51	def resolve
52	scope
53	end
54	end
55	end