Maîtriser l'autorisation dans Rails avec Pundit Gem

L'autorisation est un élément essentiel de toute application web, car elle garantit que les utilisateurs ne peuvent accéder qu'aux ressources auxquelles ils sont autorisés. Pundit est une bibliothèque d'autorisation populaire pour Ruby on Rails qui permet aux développeurs de définir des règles d'accès fines. Cet article vous guidera dans l'utilisation de Pundit gem pour l'autorisation dans une application Web. Application Railsavec un exemple à l'appui.

Guide étape par étape 

1. Ajouter Pundit à votre application Rails

Tout d'abord, ajoutez Pundit à votre Gemfile et lancez l'installation du bundle :

gemme 'pundit'

installation groupée

Ensuite, générez les fichiers d'installation de Pundit :

rails generate pundit:install

Cela créera un application_policy.rb dans le répertoire app/policies, qui sert de politique par défaut pour tous les modèles.

2. Définition des politiques
Dans Pundit, les politiques sont des objets Plain Old Ruby (PORO) qui encapsulent la logique d'autorisation. Chaque politique correspond à un modèle de votre application. Prenons un exemple simple : nous avons un modèle Post et nous voulons définir des règles d'autorisation pour ce modèle.

Créer une politique pour le modèle Post :

rails générer pundit:policy post

Cela génère un post_policy.rb dans le répertoire app/policies.

3. Mise en œuvre de la logique d'autorisation
Ouvrez le fichier post_policy.rb et définissez les règles d'autorisation :

classe PostPolicy < ApplicationPolicy
  def index ?
    vrai
  end

  def show ?
    true
  end

  def create ?
    user.present ?
  end

  def update ?
    user.present ? && user == record.user
  end

  def destroy ?
    user.present ? && user == record.user
  end
end

Nous définissons ici les méthodes correspondant à chaque action (indexer ?, afficher ?, créer ?, mettre à jour ? et détruire ?). Ces méthodes renvoient un message vrai ou faux en fonction de l'utilisateur et de l'enregistrement auquel on accède.

4. Utilisation de stratégies dans les contrôleurs
Dans vos contrôleurs, vous pouvez utiliser Pundit pour autoriser des actions. Tout d'abord, incluez le module Pundit dans l'ApplicationController :

classe ApplicationController < ActionController::Base
y compris Pundit
fin

Ensuite, utilisez la méthode authorize pour vérifier l'autorisation dans votre PostsController :

classe PostsController < ApplicationController
  before_action :authenticate_user !
  before_action :set_post, only : [:show, :edit, :update, :destroy]

  def index
    @posts = Post.all
    autoriser @posts
  end

  def show
  end

  def new
    @post = Post.new
    autoriser @post
  end

  def create
    @post = current_user.posts.build(post_params)
    autoriser @post
    si @post.save
      redirect_to @post, notice : 'Le message a été créé avec succès.'
    else
      render :new
    end
  end

  def edit
    autoriser @post
  end

  def update
    autoriser @post
    si @post.update(post_params)
      redirect_to @post, notice : 'Le message a été mis à jour avec succès.'
    else
      render :edit
    end
  end

  def destroy
    autoriser @post
    @post.destroy
    redirect_to posts_url, notice : 'Le message a été détruit avec succès.'
  end

  privé

  def set_post
    @post = Post.find(params[:id])
  end

  def post_params
    params.require(:post).permit(:title, :body)
  end
end

Dans ce contrôleur, nous utilisons authorize pour vérifier les permissions avant d'effectuer des actions.

5. Traitement des accès non autorisés
Pundit lève une erreur Pundit::NotAuthorizedError si un utilisateur n'est pas autorisé à effectuer une action. Vous pouvez gérer cette erreur globalement dans l'ApplicationController :

class ApplicationController < ActionController::Base
  include Pundit

  rescue_from Pundit::NotAuthorizedError, with : :user_not_authorized

  private

  def user_not_authorized
    flash[:alert] = "Vous n'êtes pas autorisé à effectuer cette action."
    redirect_to(request.referrer || root_path)
  end
fin

Ainsi, si un utilisateur tente d'effectuer une action non autorisée, il sera redirigé vers un message d'erreur.

Conclusion

L'utilisation de Pundit pour l'autorisation dans Rails est un moyen puissant et flexible de contrôler l'accès aux ressources dans votre application. En définissant des politiques et en les utilisant dans vos contrôleurs, vous pouvez vous assurer que les utilisateurs ne peuvent effectuer que les actions pour lesquelles ils sont autorisés. Nous avons couvert les bases, mais Pundit prend également en charge des scénarios plus complexes, y compris les champs d'application et les générateurs de politiques personnalisés.

Pour plus d'informations, consultez le site Dépôt GitHub Pundit