Come utilizzare Pundit per l'autorizzazione in Hgr Rails?

Ehilà! In qualità di fornitore di Hgr Rails, mi viene spesso chiesto come utilizzare Pundit per l'autorizzazione nelle applicazioni Hgr Rails. In questo post del blog, ti guiderò attraverso il processo e condividerò alcuni suggerimenti che ti semplificheranno la vita.

Prima di tutto, parliamo un po' di cosa sono gli Hgr Rails. Le rotaie Hgr sono una parte essenziale di molti sistemi di movimento lineare. Offrono elevata precisione e durata, il che li rende molto popolari in vari settori. Puoi saperne di più su di loro in questa pagina:Rotaie Hgr. E se sei curioso di conoscere i diversi tipi di guide lineari, dai un'occhiataTipi di guide lineari. Un tipo specifico che potrebbe interessarti è ilGuida lineare GHH-CA.

Ora tuffiamoci in Pundit. Pundit è un gioiello che semplifica davvero la gestione dell'autorizzazione nelle applicazioni Rails. Segue il principio di mantenere la logica di autorizzazione separata dai modelli e dai controller, che è un'ottima pratica per mantenere il codice pulito e gestibile.

Iniziare con Pundit

Il primo passo è aggiungere Pundit alla tua applicazione Rails. Apri il tuoSalva filee aggiungi la seguente riga:

gemma 'esperto'

Allora corriinstallazione del pacchettonel tuo terminale. Una volta fatto ciò, devi configurare Pundit nella tua applicazione. Nel tuoControllore dell'applicazione, aggiungi il seguente codice:

class ApplicationController < ActionController::Base include Pundit Rescue_from Pundit::NotAuthorizedError, con: :user_not_authorized private def user_not_authorized flash[:alert] = "Non sei autorizzato a eseguire questa azione." reindirizza_to(richiesta.referrer || percorso_root) end end

Questo codice include il modulo Pundit nel tuoControllore dell'applicazionee imposta un blocco di salvataggio per quando un utente tenta di eseguire un'azione per la quale non è autorizzato.

Creazione di politiche

Le politiche sono al centro di Pundit. È qui che definisci le regole di autorizzazione per la tua applicazione. Per creare una policy, puoi utilizzare il generatore Rails. Ad esempio, se hai aProdottomodello, puoi creare una policy per questo in questo modo:

le rotaie generano un prodotto politico: esperto

Questo creerà un file chiamatopolitica_prodotto.rbnelapp/politichedirectory. Apri questo file e vedrai una struttura di base come questa:

class ProductPolicy < ApplicationPolicy def indice? spettacolo di false end def? creare la falsa fine def? falsa fine def nuovo? creare? fine aggiornamento def? modifica definizione falsa fine? aggiornamento? finire def distruggere? fine falsa fine

Questi metodi rappresentano diverse azioni che un utente potrebbe provare a eseguire su aProdotto. Per impostazione predefinita, ritornano tuttifalso, il che significa che nessuno è autorizzato a eseguire queste azioni. È necessario personalizzare questi metodi in base ai requisiti dell'applicazione.

Ad esempio, supponiamo che solo gli amministratori possano creare, aggiornare e distruggere i prodotti, ma tutti gli utenti possono visualizzare l'elenco e i dettagli dei prodotti. Puoi modificare la policy in questo modo:

class ProductPolicy < ApplicationPolicy def indice? vero spettacolo di fine def? vero fine def creare? utente.admin? fine def nuovo? creare? fine aggiornamento def? utente.admin? fine def modifica? aggiornamento? finire def distruggere? utente.admin? fine fine

In questo codice, ilutenterappresenta l'utente attualmente connesso. ILamministratore?si presuppone che il metodo sia un metodo suUtentemodello che ritornaVEROse l'utente è un amministratore.

Utilizzo delle policy nei controller

Dopo aver creato le policy, puoi utilizzarle nei controller. Ad esempio, nel tuoProdottiController, puoi aggiungere il seguente codice:

class ProductsController < ApplicationController def indice @products = Prodotto.all autorizza @prodotti end def show @prodotto = Prodotto.find(params[:id]) autorizza @prodotto end def new @prodotto = Prodotto.new autorizza @prodotto end def create @prodotto = Prodotto.new(product_params) autorizza @prodotto se @prodotto.save reindirizza_a @prodotto, avviso: 'Il prodotto è stato creato con successo.' else render :new end end def modifica @product = Product.find(params[:id]) autorizza @product end def update @product = Product.find(params[:id]) autorizza @product if @product.update(product_params) reindirizza_to @product, avviso: 'Il prodotto è stato aggiornato con successo.' else render :edit end end def destroy @product = Product.find(params[:id]) autorizza @product @product.destroy reindirizza_aproducts_url, avviso: 'Il prodotto è stato distrutto con successo.' end private def product_params params.require(:product).permit(:name, :price) end end

ILautorizzareviene chiamato in ogni azione per verificare se l'utente corrente è autorizzato a eseguire tale azione. Se l'utente non è autorizzato, Pundit genererà un fileEsperto::NotAuthorizedError, che verrà catturato dalutente_non_autorizzatometodo nelControllore dell'applicazione.

Politiche con ambito

A volte potresti voler limitare l'elenco delle risorse a cui un utente può accedere. Ad esempio, potresti avere un sistema in cui gli utenti possono vedere solo i prodotti che hanno creato. Pundit consente di definire policy con ambito a questo scopo.

Innanzitutto, crea una classe di ambito per il tuo modello. Per ilProdottomodello, puoi creare un filePolitica del prodotto::Ambitoclasse in questo modo:

classe ProductPolicy < ApplicationPolicy classe Ambito < Ambito def risolvere se utente.admin? scope.all else scope.where(user_id: user.id) end end end # Altri metodi di policy... end

Nelrisolveremetodo, si definisce la logica per limitare l'ambito delle risorse. In questo esempio, gli amministratori possono vedere tutti i prodotti, mentre gli utenti normali possono vedere solo i prodotti che hanno creato.

Poi, nel tuoProdottiController, puoi utilizzare la policy con ambito in questo modo:

class ProductsController < ApplicationController def indice @products = policy_scope(Prodotto) autorizza @products end # Altre azioni del controller... end

ILambito_politicaIl metodo restituisce una relazione con ambito basata sulla policy con ambito definita.

Conclusione

Usare Pundit per l'autorizzazione nelle applicazioni Hgr Rails è un ottimo modo per mantenere il tuo codice organizzato e sicuro. Separando la logica di autorizzazione in policy, puoi gestire facilmente chi può eseguire quali azioni nella tua applicazione.

Se stai cercando Hgr Rails o altri prodotti di movimento lineare, non esitare a contattarci per una discussione sull'acquisto. Siamo qui per fornirti prodotti di alta qualità e un servizio eccellente.

Riferimenti

• Documentazione ufficiale dell'esperto
• Guide Ferroviarie su autorizzazione