Gates and Policies in Laravel

Oggi discuteremo il sistema di autorizzazione del framework web di Laravel. Il framework Laravel implementa l'autorizzazione sotto forma di porte e politiche. Dopo un'introduzione ai gate e alle policy, dimostrerò i concetti implementando un esempio personalizzato.

Presumo che tu sia già a conoscenza del sistema di autenticazione di Laravel incorporato poiché è essenziale per comprendere il concetto di autorizzazione. Ovviamente, il sistema di autorizzazione funziona in congiunzione con il sistema di autenticazione per identificare la sessione utente legittima.

Se non sei a conoscenza del sistema di autenticazione di Laravel, ti consiglio vivamente di consultare la documentazione ufficiale, che ti fornisce una conoscenza pratica sull'argomento.

L'approccio di Laravel all'autorizzazione

A questo punto, dovresti già sapere che il sistema di autorizzazione di Laravel è disponibile in due versioni: porte e criteri. Anche se può sembrare un affare complicato, direi che è abbastanza facile implementarlo una volta capito!

Le porte consentono di definire una regola di autorizzazione utilizzando un approccio basato sulla chiusura semplice. In altre parole, quando si desidera autorizzare un'azione non correlata a un modello specifico, il gate è il luogo perfetto per implementare quella logica.

Diamo una rapida occhiata a quale autorizzazione basata su gate assomiglia a:

... Gate :: define ('update-post', funzione ($ utente, $ post) return $ user-> id == $ post-> user_id;); ...) 

Lo snippet sopra riportato definisce la regola di autorizzazione aggiornamento post che puoi chiamare da qualsiasi punto della tua applicazione.

D'altra parte, è necessario utilizzare le politiche quando si desidera raggruppare la logica di autorizzazione di qualsiasi modello. Ad esempio, supponiamo di avere un modello Post nella tua applicazione e di autorizzare le azioni CRUD di quel modello. In tal caso, è la politica che è necessario implementare.

classe PostPolicy visualizzazione funzione pubblica (utente $ utente, post $ post)  funzione pubblica creazione (utente $ utente)  aggiornamento funzione pubblica (utente $ utente, post $ post)  eliminazione funzione pubblica (utente $ utente, posta $ post) 

Come puoi vedere, è una classe politica piuttosto semplice che definisce l'autorizzazione per le azioni CRUD di Inviare modello.

Quindi questa è stata un'introduzione ai cancelli e alle politiche di Laravel. Dalla prossima sezione in poi, faremo una dimostrazione pratica di ciascun elemento.

Gates

In questa sezione, vedremo un esempio del mondo reale per comprendere il concetto di porte.

Più spesso, si finisce col guardare al fornitore di servizi Laravel quando è necessario registrare un componente o un servizio. Seguendo questa convenzione, andiamo avanti e definiamo il nostro cancello personalizzato nel app / fornitori / AuthServiceProvider.php come mostrato nel seguente frammento.

 'App \ Policies \ ModelPolicy',]; / ** * Registrazione di tutti i servizi di autenticazione / autorizzazione. * * @return void * / public function boot () $ this-> registerPolicies (); Gate :: define ('update-post', function ($ utente, $ post) return $ user-> id == $ post-> user_id;); 

Nel avvio metodo, abbiamo definito il nostro cancello personalizzato:

Gate :: define ('update-post', function ($ utente, $ post) return $ user-> id == $ post-> user_id;);

Durante la definizione di un gate, richiede una chiusura che restituisce VERO o FALSO in base alla logica di autorizzazione definita nella definizione del gate. Oltre alla funzione di chiusura, ci sono altri modi per definire i cancelli.

Ad esempio, la seguente definizione di gate chiama l'azione del controller anziché la funzione di chiusura.

Gate :: define ('update-post', 'ControllerName @ MethodName');

Ora, andiamo avanti e aggiungere un percorso personalizzato in modo che possiamo passare attraverso una dimostrazione di come funziona l'autorizzazione basata su gate. Nel file delle rotte percorsi / web.php, aggiungiamo il seguente percorso.

Route :: get ('servizio / posta / porta', 'PostController @ gate');

Creiamo un file controller associato App / HTTP / Controller / PostController.php anche.

Nella maggior parte dei casi, finirai per utilizzare il consente o nega metodo del cancello facciata per autorizzare una certa azione. Nel nostro esempio sopra, abbiamo usato il consente metodo per verificare se l'utente corrente è in grado di eseguire il aggiornamento post azione.
Gli utenti con gli occhi acuti avrebbero notato che abbiamo passato solo il secondo argomento $ postale alla chiusura. Il primo argomento, l'utente attualmente loggato, viene automaticamente iniettato dal file cancello facciata.
Ecco come utilizzare le porte per autorizzare azioni nella tua applicazione Laravel. La prossima sezione tratta di come utilizzare le politiche, se desideri implementare l'autorizzazione per i tuoi modelli.
Politiche
Come discusso in precedenza, quando si desidera raggruppare logicamente le azioni di autorizzazione per qualsiasi modello o risorsa, è la politica che si sta cercando.
In questa sezione, creeremo un criterio per il modello Post che verrà utilizzato per autorizzare tutte le azioni CRUD. Suppongo che tu abbia già implementato il modello Post nella tua applicazione; altrimenti, qualcosa di simile farà.
Il Laravel artigiano comando è il tuo migliore amico quando si tratta di creare codice stubbed. È possibile utilizzare il seguente comando artisan per creare un criterio per il modello Post.
$ php artisan make: policy PostPolicy --model = Post
Come puoi vedere, abbiamo fornito il --Modello = Messaggio argomento in modo che crei tutti i metodi CRUD. In assenza di ciò, creerà una classe politica vuota. È possibile individuare la classe politica appena creata in app / Politiche / PostPolicy.php.
Sostituiamolo con il seguente codice.
id> 0;  / ** * Determina se l'utente può aggiornare il post. * * @param \ App \ Utente $ utente * @param \ App \ Posta $ post * @return misto * / aggiornamento funzione pubblica (utente $ utente, post $ post) return $ user-> id == $ post-> ID utente;  / ** * Determina se l'utente può cancellare il post. * * @param \ App \ utente $ utente * @param \ app \ post $ post * @return misto * / funzione pubblica delete (utente $ utente, post $ post) return $ user-> id == $ post-> ID utente; 
Per poter utilizzare la nostra classe politica, è necessario registrarla utilizzando il fornitore di servizi Laravel come mostrato nel seguente snippet.
 'App \ Policies \ ModelPolicy', Post :: class => PostPolicy :: class]; / ** * Registrazione di tutti i servizi di autenticazione / autorizzazione. * * @return void * / public function boot () $ this-> registerPolicies (); 
Abbiamo aggiunto la mappatura della nostra politica nel $ politiche proprietà. Indica a Laravel di chiamare il metodo della politica corrispondente per autorizzare l'azione CRUD.
È inoltre necessario registrare le politiche utilizzando il registerPolicies metodo, come abbiamo fatto nel avvio metodo.
Andando oltre, creiamo un paio di percorsi personalizzati nel percorsi / web.php file in modo che possiamo testare i nostri metodi di politica lì.
Route :: get ('servizio / post / vista', 'PostController @ view'); Route :: get ('service / post / create', 'PostController @ create'); Route :: get ('servizio / post / aggiornamento', 'PostController @ update'); Route :: get ('servizio / posta / cancella', 'PostController @ cancella');
Infine, creiamo un controller associato su App / HTTP / Controller / PostController.php.
can ('view', $ post)) echo "L'utente che ha effettuato l'accesso è autorizzato ad aggiornare il post: $ post-> id";  else echo 'Non autorizzato.';  public function create () // get corrente utente registrato $ user = Auth :: user (); if ($ user-> can ('create', Post :: class)) echo 'L'utente attualmente loggato è autorizzato a creare nuovi post.';  else echo 'Non autorizzato';  Uscita;  public function update () // get corrente loggato user $ user = Auth :: user (); // carica post $ post = Posta :: trova (1); if ($ user-> can ('update', $ post)) echo "L'utente attualmente loggato è autorizzato ad aggiornare il post: $ post-> id";  else echo 'Non autorizzato.';  public function delete () // get corrente utente registrato $ user = Auth :: user (); // carica post $ post = Posta :: trova (1); if ($ user-> can ('delete', $ post)) echo "L'utente loggato corrente può cancellare il post: $ post-> id";  else echo 'Non autorizzato.'; 
Esistono diversi modi per autorizzare le tue azioni utilizzando le Politiche. Nel nostro esempio sopra, abbiamo usato il Utente modello per autorizzare il nostro Inviare azioni modello.
Il modello Utente fornisce due metodi utili per scopi di autorizzazione-può e gergo. Il può il metodo viene utilizzato per verificare se l'utente corrente è in grado di eseguire una determinata azione. E la controparte del può metodo, il gergo metodo, viene utilizzato per determinare l'impossibilità dell'esecuzione dell'azione.
Prendiamo il frammento di vista metodo dal controller per vedere cosa fa esattamente.
public function view () // get corrente utente registrato $ user = Auth :: user (); // carica post $ post = Posta :: trova (1); if ($ user-> can ('view', $ post)) echo "L'utente attualmente loggato è autorizzato ad aggiornare il post: $ post-> id";  else echo 'Non autorizzato.'; 
Innanzitutto, carichiamo l'utente attualmente loggato, che ci fornisce l'oggetto del modello Utente. Successivamente, carichiamo un post di esempio utilizzando il modello Post.
Andando avanti, abbiamo usato il può metodo del modello Utente per autorizzare il vista azione del Inviare modello. Il primo argomento del può metodo è il nome dell'azione che si desidera autorizzare e il secondo argomento è l'oggetto del modello a cui si desidera ottenere l'autorizzazione.
Questa è stata una dimostrazione di come usare il Utente modello per autorizzare le azioni utilizzando le politiche. In alternativa, è possibile utilizzare il Controller Helper pure, se sei nel controller mentre autorizzi una determinata azione.
... $ this-> autorizza ('visualizza', $ post); ... 
Come puoi vedere, non è necessario caricare il modello User se si utilizza il Controller Helper.
Questo era il concetto di policy a tua disposizione, ed è davvero utile mentre autorizzi un modello o una risorsa in quanto ti consente di raggruppare la logica di autorizzazione in un unico punto.
Assicurati di non utilizzare le porte e le politiche del tutto per le stesse azioni del Modello, altrimenti creerai problemi. È da parte mia per oggi, e lo chiamerò un giorno!
Conclusione
Oggi, è stata l'autorizzazione di Laravel ad essere al centro del mio articolo. All'inizio dell'articolo, ho introdotto gli elementi principali dell'autorizzazione, delle porte e delle politiche di Laravel.
In seguito, abbiamo creato il nostro cancello personalizzato e la nostra politica per vedere come funziona nel mondo reale. Spero che tu abbia apprezzato l'articolo e imparato qualcosa di utile nel contesto di Laravel.
Per quelli di voi che stanno appena iniziando con Laravel o stanno cercando di espandere le vostre conoscenze, il vostro sito o la vostra applicazione con le estensioni, abbiamo una varietà di cose che potete studiare su Envato Market.
Come sempre, mi piacerebbe ricevere tue notizie sotto forma di commenti usando il feed qui sotto!



		
			
	   
	




Codice