Padroneggiare l'autorizzazione in Rails con Pundit Gem

L'autorizzazione è un componente critico di qualsiasi applicazione web, in quanto garantisce che gli utenti possano accedere solo alle risorse a cui sono autorizzati. Pundit è una popolare libreria di autorizzazioni per Ruby on Rails che consente agli sviluppatori di definire regole di accesso a grana fine. Questo articolo vi guiderà nell'uso del gemma Pundit per l'autorizzazione in un'applicazione web. Applicazione delle rotaie, con tanto di esempio.

Guida passo-passo 

1. Aggiunta di Pundit all'applicazione Rails

Per prima cosa, aggiungete Pundit al vostro Gemfile ed eseguite l'installazione del bundle:

gemma "opinionista

installazione del pacchetto

Quindi, generare i file di installazione di Pundit:

rails generate pundit:install

In questo modo si creerà un application_policy.rb nella cartella app/policies, che serve come criterio predefinito per tutti i modelli.

2. Definizione delle politiche
Le policy in Pundit sono oggetti Plain Old Ruby (PORO) che incapsulano la logica di autorizzazione. Ogni criterio corrisponde a un modello dell'applicazione. Consideriamo un semplice esempio in cui abbiamo un modello Post e vogliamo definire le regole di autorizzazione per esso.

Creare un criterio per il modello Post:

le rotaie generano il post di pundit:policy

Questo genera un post_policy.rb nella cartella app/policies.

3. Implementazione della logica di autorizzazione
Aprire il file post_policy.rb e definire le regole di autorizzazione:

classe PostPolicy < ApplicationPolicy
  def index?
    vero
  fine

  def show?
    vero
  fine

  def creare?
    utente.presente?
  fine

  def aggiornamento?
    utente.presente? && utente == record.user
  fine

  def destroy?
    utente.presente? && utente == record.user
  fine
fine

Qui si definiscono i metodi corrispondenti a ciascuna azione (index?, show?, create?, update? e destroy?). Questi metodi restituiscono true o false in base all'utente e al record a cui si accede.

4. Uso dei criteri nei controllori
Nei controllori, si può usare Pundit per autorizzare le azioni. Innanzitutto, includere il modulo Pundit nell'ApplicationController:

classe ApplicationController < ActionController::Base
include l'opinionista
FINE

Quindi, utilizzare il metodo authorize per verificare l'autorizzazione nel PostsController:

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

  def index
    @posts = Post.all
    autorizzare @posts
  fine

  def mostra
  fine

  def nuovo
    @post = Post.new
    autorizzare @post
  fine

  def creare
    @post = current_user.posts.build(post_params)
    autorizzare @post
    se @post.save
      redirect_to @post, notice: 'Il post è stato creato con successo'.
    else
      render :new
    fine
  fine

  def modifica
    autorizza @post
  fine

  def aggiornamento
    autorizzare @post
    se @post.update(post_params)
      redirect_to @post, notice: 'Il post è stato aggiornato con successo'.
    altrimenti
      render :edit
    fine
  fine

  def distruggere
    autorizza @post
    @post.destroy
    redirect_to posts_url, notice: 'Il post è stato distrutto con successo'.
  fine

  privato

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

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

In questo controllore, usiamo authorize per verificare i permessi prima di eseguire qualsiasi azione.

5. Gestione degli accessi non autorizzati
Pundit solleva un Pundit::NotAuthorizedError se un utente non è autorizzato a eseguire un'azione. È possibile gestire questo errore globalmente nell'ApplicationController:

classe ApplicationController < ActionController::Base
  includere Pundit

  rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

  privato

  def utente_non_autorizzato
    flash[:alert] = "Non sei autorizzato a eseguire questa azione".
    redirect_to(request.referrer || root_path)
  fine
fine

In questo modo, se un utente tenta di eseguire un'azione non autorizzata, verrà reindirizzato con un messaggio di errore.

Conclusione

L'uso di Pundit per l'autorizzazione in Rails è un modo potente e flessibile per controllare l'accesso alle risorse nella vostra applicazione. Definendo le policy e utilizzandole nei controllori, si può garantire che gli utenti possano eseguire solo le azioni per cui sono autorizzati. Questo ha coperto le basi, ma Pundit supporta anche scenari più complessi, tra cui gli ambiti e i generatori di policy personalizzate.

Per informazioni più dettagliate, consultare il sito Repository GitHub di Pundit