‫-: Ben tornato.
‫Quindi, abbiamo implementato l'autenticazione nel
‫nostro progetto fino a questo punto.
‫E funziona bene.
‫Tuttavia, a volte, la semplice autenticazione, quindi l'accesso
‫di un utente, non
‫è davvero sufficiente.
‫E quindi
‫in questo video implementeremo anche l'autorizzazione.
‫Quindi, immagina l'atto di eliminare un tour
‫dal nostro database.
‫Quindi, non tutti gli utenti dovrebbero, ovviamente,
‫essere autorizzati a farlo.
‫Anche se l'utente ha effettuato l'accesso, giusto?
‫Quindi, fondamentalmente dobbiamo autorizzare solo
‫determinati tipi di utenti, per
‫eseguire determinate azioni.
‫E quindi questo è esattamente ciò che è l'autorizzazione.
‫Sta verificando se un determinato utente ha i
‫diritti per interagire con una determinata risorsa.
‫Quindi, ancora una volta, con l'autorizzazione controlliamo sostanzialmente se
‫un determinato utente è autorizzato ad accedere a una determinata risorsa, anche
‫se ha effettuato l'accesso.
‫Quindi non tutti gli utenti che hanno effettuato l'accesso saranno in grado
‫di eseguire le stesse azioni nella nostra API, ok?
‫E questo è uno scenario molto comune
‫che dovrebbe essere implementato in ogni applicazione
‫web di solito, va bene?
‫Quindi costruiremo un'altra funzione middleware
‫qui, questa volta per limitare determinati percorsi.
‫Ad esempio, per eliminare i tour.
‫Quindi, questo significa che qui costruiremo
‫un'altra funzione middleware.
‫Questa volta, per limitare determinati percorsi, come,
‫ad esempio, l'eliminazione dei
‫tour, solo a determinati ruoli utente.
‫Va bene?
‫E quindi lascia che ti mostri effettivamente
‫come sarebbe in pratica.
‫Quindi qui, nei
‫percorsi dei tour, torniamo a quell'esempio di eliminazione dei
‫tour, quindi aggiungiamo un po' di middleware nello stack qui.
‫Quindi authController, proteggi.
‫Quindi, prima, dobbiamo sempre
‫verificare se un utente ha effettivamente effettuato l'accesso, ok?
‫Quindi, se un amministratore sta cercando di eliminare un
‫tour, dovrebbe comunque
‫controllare se ha effettivamente effettuato l'accesso, giusto?
‫Quindi il primo middleware nello stack qui,
‫sarà sempre quello di protezione.
‫Ma poi, dopo quello,
‫avremo anche authController. limitare.
‫Quindi restringi a, ok?
‫E in questa funzione passeremo quindi alcuni ruoli utente,
‫che saranno autorizzati a interagire con questa risorsa.
‫In questo caso, con l'eliminazione di un tour, ok?
‫Quindi impostiamo questo su admin.
‫Quindi, solo agli amministratori.
‫Ok, quindi ora abbiamo a che fare con i ruoli utente qui.
‫Quindi proprio come l'amministratore.
‫E in questo momento, non lo abbiamo nel nostro modello utente.
‫E quindi implementiamolo rapidamente qui.
‫Va bene.
‫Quindi, facciamolo.
‫In realtà, prima della roba della password, quindi come qui.
‫E qui sotto puoi effettivamente vedere come il nostro gestore
‫di eccezioni non rilevate funziona bene,
‫perché restTo non è ancora una funzione, giusto?
‫Non l'abbiamo ancora implementato.
‫L'ho semplicemente usato per mostrare
‫cosa costruiremo esattamente.
‫E quindi, ovviamente, c'è un
‫errore, quindi
‫nodemon ora sta aspettando il riavvio del server, ok?
‫Ad ogni modo, il ruolo qui dovrebbe
‫essere del tipo String, e ora userò il validatore enum per
‫consentire solo alcuni tipi di ruoli qui da specificare.
‫E questi sono i generali, quindi gli utenti normali,
‫quindi chiamiamoli utenti.
‫Quindi, abbiamo la
‫guida turistica, abbiamo la guida
‫turistica principale e abbiamo l'amministratore.
‫Quindi, sto solo chiamando quell'amministratore, va bene?
‫E questi ruoli utente che abbiamo qui
‫saranno ovviamente specifici del dominio dell'applicazione.
‫Quindi, ad esempio, quando gestisci un sito di community,
‫non avrà molto senso
‫avere una guida e una guida principale.
‫Invece probabilmente avrai, come,
‫moderatori o contributori o membri.
‫Quindi, avrai sempre nomi diversi,
‫a seconda del tipo di applicazione che stai scrivendo.
‫Ma nel nostro caso, questo è ciò che ha senso.
‫Quindi, vogliamo anche impostare un valore predefinito qui,
‫quindi in realtà non dobbiamo specificare
‫sempre quale tipo di utente stiamo creando.
‫E quindi utente, l'utente normale, diciamo, è quello
‫che verrà creato per impostazione predefinita.
‫Quindi ora andiamo avanti ed
‫eliminiamo gli utenti che abbiamo già,
‫perché non hanno
‫alcun ruolo e quindi non ne abbiamo più bisogno in questo modo.
‫Va bene.
‫E quindi andiamo
‫anche avanti e ne creiamo di nuovi.
‫Quindi, mi iscriverò qui come hello@jonas, e quindi
‫ora sarà un utente normale, e ora non siamo riusciti a ottenere
‫alcuna risposta, e questo
‫ovviamente è perché abbiamo questo errore qui, e
‫quindi, diciamo molto estrarre rapidamente questa riga di codice.
‫E ora l'errore è sparito.
‫E quindi ora dovrebbe
‫funzionare, e in effetti ora abbiamo
‫questo utente, con il ruolo di utente, ok?
‫Quindi questa è la
‫nostra impostazione predefinita, ma ora creiamo un amministratore qui.
‫E per renderlo
‫davvero chiaro, mettiamolo anche qui nell'e-mail, e
‫ora dobbiamo davvero specificare il ruolo
‫e impostarlo su admin.
‫Invialo, e così ora abbiamo qui il nostro amministratore di sistema.
‫Freddo.
‫Quindi, torniamo qui, reinseriamo effettivamente questo codice e lo faremo
‫in modo che possiamo
‫effettivamente passare più argomenti in questo restringTo.
‫Quindi, voglio che l'amministratore sia in grado di eliminare i
‫tour, ma anche eliminare una guida.
‫Va bene?
‫E quindi aggiungiamolo anche qui.
‫Va bene?
‫Quindi l'amministratore e la guida principale possono ora eliminare
‫i tour, ma non le guide normali e nemmeno gli utenti normali.
‫Va bene?
‫Quindi è così che funzionerà limitTo, ora
‫andiamo avanti e implementiamolo.
‫Quindi esportazioni. restringTo, e
‫ora, come lo implementeremo effettivamente?
‫Perché di solito non possiamo
‫passare argomenti in una funzione middleware, giusto?
‫Ma in questo caso, lo vogliamo davvero.
‫Vogliamo passare i
‫ruoli, chi è autorizzato ad accedere alla risorsa, giusto?
‫Quindi questo caso, l'amministratore e la guida principale.
‫Quindi abbiamo bisogno di un modo per passare sostanzialmente argomenti
‫nella funzione middleware in un modo
‫che di solito non funziona.
‫Allora, come lo faremo?
‫Bene, qui in realtà creeremo come una
‫funzione wrapper, che poi restituirà
‫la funzione middleware che vogliamo effettivamente creare, ok?
‫Quindi, questa è la funzione restTo, e
‫qui vogliamo passare
‫un numero arbitrario di argomenti.
‫Quindi, in fondo, dei ruoli.
‫Quindi possiamo usare la sintassi del parametro rest,
‫che è di nuovo nuova in ES6, e questo
‫creerà quindi un
‫array di tutti gli argomenti che sono stati specificati, ok?
‫Quindi stiamo creando
‫questa funzione e immediatamente restituiremo una nuova funzione.
‫E questa è la stessa funzione del middleware.
‫Quindi, richiesta, risposta e il prossimo.
‫Va bene?
‫Ha senso?
‫E quindi questa funzione
‫qui fondamentalmente otterrà l'accesso al parametro
‫di questo ruolo qui, perché c'è una chiusura, ok?
‫Quindi, proprio come un commento qui per
‫spiegare, i ruoli sono un array.
‫Quindi, ad esempio, potrebbe essere,
‫in questo caso, amministratore e guida principale, ok?
‫Quindi, quando daremo a un utente l'accesso a un determinato percorso?
‫Bene, in pratica, quando il suo ruolo
‫utente è all'interno di questo array di ruoli che abbiamo passato, giusto?
‫Quindi diciamo che ora abbiamo l'utente
‫normale, che ha un ruolo di semplice utente,
‫quindi scriviamolo qui.
‫Il ruolo ora è solo utente.
‫E quindi fondamentalmente non è contenuto in
‫questo array, quindi quell'utente non ha il permesso, ok?
‫E quindi, scriviamolo in codice.
‫In realtà è abbastanza semplice.
‫Quindi, se non ruoli. include, e ok, ancora una
‫volta include è un metodo array molto carino che
‫è in Java Script disponibile su tutti gli array, ok?
‫Quindi, se questo array di
‫ruoli non include il
‫ruolo dell'utente corrente, non diamo l'autorizzazione a quell'utente.
‫E dove è memorizzato il ruolo dell'utente corrente?
‫Bene, ricordiamo la riga di codice che
‫in realtà abbiamo messo qui, proprio
‫alla fine dove concediamo l'accesso al
‫percorso protetto,
‫memorizziamo l'utente corrente nella richiesta. utente.
‫E ricorda come questo
‫middleware di protezione viene sempre eseguito prima districtTo, giusto?
‫Quindi, qui, prima abbiamo protetto e
‫poi abbiamo limitTo.
‫Quindi, quando questa funzione middleware viene eseguita, questa
‫è già stata completata
‫e ha inserito l'utente corrente nell'oggetto richiesta.
‫E così ora, possiamo usarlo qui.
‫Quindi richiesta. utente. ruolo.
‫Quindi è lì che viene memorizzato il ruolo.
‫Così semplice.
‫In questo caso, creiamo un nuovo errore.
‫Quindi, proprio come prima, e
‫ora diciamo che non hai il permesso di eseguire questa azione.
‫E ora un nuovo codice di stato, che è 403.
‫E questo significa proibito, ok?
‫Quindi c'è davvero
‫un codice di stato http specifico solo per
‫questo caso, quindi per l'autorizzazione in pratica, va bene?
‫E, beh, altrimenti, chiamiamo semplicemente Next.
‫Ed è davvero così.
‫Quindi è così semplice.
‫Quindi ricapitoliamo rapidamente ciò che abbiamo appena fatto qui.
‫Quindi, qui, eseguiamo prima il middleware di protezione.
‫Quindi, restringere il middleware
‫e solo se questi due middleware passano al
‫successivo, si passa al tour principale.
‫E quindi fondamentalmente questo
‫route handler, o questo route controller, è
‫protetto ed è anche limitato da questo
‫middleware che abbiamo appena creato.
‫Quindi in
‫questa funzione, passiamo tutti i
‫ruoli a cui è consentito interagire con questa risorsa.
‫Quindi, in pratica, chi è
‫autorizzato a eseguire questa funzione di gestore, ok?
‫Quindi, questa funzione restringTo verrà quindi
‫eseguita e restituirà la stessa funzione middleware, ok?
‫E quella stessa funzione middleware è in realtà questa.
‫Avrà poi, per
‫via della chiusura, accesso ai ruoli, ok?
‫E quindi, diciamo che il ruolo dell'utente corrente, che
‫è, ricorda, memorizzato in req. utente. ruolo, no?
‫Quindi, diciamo che il suo ruolo è
‫utente, e poiché quel ruolo non è nell'array di
‫questo ruolo, beh, allora otteniamo questo errore, ok?
‫E quindi questo è ciò che questo ruoli. include i test qui per, ok?
‫Ma ovviamente, se è
‫incluso, si passa al middleware successivo.
‫Che di nuovo, è quindi il gestore del percorso stesso.
‫Freddo.
‫Quindi, spero che abbia senso.
‫Ora andiamo avanti e testiamolo rapidamente.
‫Va bene?
‫Quindi in questo
‫momento abbiamo questo token qui, memorizzato nella variabile JTW, giusto?
‫Quindi ricordatelo dall'ultima lezione.
‫Quindi, siamo in questo ambiente
‫di sviluppo, e quindi ecco quella variabile.
‫Quindi esattamente quello che è quaggiù.
‫Va bene?
‫Quindi, se ora dovessimo
‫eliminare un tour, dovremmo specificare quella variabile lì, giusto?
‫Quindi andiamo all'autorizzazione, il token al portatore,
‫e poi in realtà
‫lo mette già qui per noi.
‫Quindi sa già
‫che questo è quello che vogliamo usare,
‫perché, beh, l'abbiamo usato prima, ok?
‫Ora, voglio iniziare mostrandoti che
‫un utente normale non può eliminare un tour ora, ok?
‫E quindi iniziamo accedendo come utente normale.
‫E quindi questo è ciao, giusto?
‫Ricorda, in questo momento abbiamo hello@jonas. io, che è un utente normale,
‫e abbiamo admin@jonas. io.
‫E abbiamo ancora questo vecchio qui, liberiamocene.
‫Va bene.
‫E quindi inizierò con hello@jonas. io.
‫Va bene?
‫Quindi, accedendo, quel token verrà archiviato nella variabile d'ambiente
‫e ora siamo pronti per
‫eliminare un tour.
‫In realtà dobbiamo anche ottenere un ID ora,
‫quindi prendiamone uno velocemente da qui,
‫quindi in pratica elimineremo uno dei nostri tour qui.
‫Quindi usiamo solo l'ultimo qui.
‫Quindi, l'osservatore di stelle.
‫Va bene?
‫E vediamo se riceviamo il nostro messaggio di errore.
‫E, in effetti, non hai il permesso di
‫eseguire questa azione.
‫Quindi, 403.
‫Quindi, in effetti, sta funzionando, giusto?
‫Ma, per
‫completare ora, accediamo ovviamente come amministratore.
‫Allora, amministratore.
‫Login.
‫E quindi questo token è ora memorizzato in questa variabile.
‫Quindi, se lo esegui
‫ora, dovremmo essere in grado di eliminare efficacemente il tour.
‫Voglio vedere?
‫Ed è andato.
‫Quindi abbiamo un codice 204, nessun contenuto, che
‫è lo standard durante l'eliminazione,
‫ma ora se otteniamo tutti i
‫nostri tour, ora dovremmo vedere un numero otto
‫qui, quindi solo
‫otto risultati, e ciò significa che l'ultimo è ora andato, ok?
‫E quindi in questo momento, come
‫abbiamo appena dimostrato, un
‫amministratore ha l'autorizzazione per eliminare efficacemente i tour, ok?
‫E non posso davvero sottolineare
‫abbastanza quanto sia importante questo pezzo di codice qui.
‫Quindi, in pratica, dove otteniamo il ruolo
‫dell'utente corrente dal middleware prima, ok?
‫Quindi, memorizzare l'utente nella richiesta come abbiamo
‫fatto qui, è davvero
‫cruciale affinché questo passaggio successivo funzioni effettivamente, ok?
‫Quindi, l'ID codificato nel token web Jason è ciò che fa in modo
‫che il nostro codice sappia se l'utente
‫che sta tentando di eseguire l'azione è un utente, o se è
‫un amministratore, o se è una guida per i lead, o altro.
‫Di nuovo, perché i
‫dati provengono da questo middleware di protezione.
‫Grande.
‫Questo è stato un altro pezzo importante del
‫puzzle nell'implementazione del nostro flusso di lavoro di autenticazione qui.
‫E, naturalmente, vuoi limitare molti
‫altri percorsi, ad esempio, come l'aggiornamento qui, ok?
‫Ma lo lascerò per
‫un punto successivo del corso, ok?
‫Proprio qui, volevo solo
‫mostrarti come funziona tutto questo, ok?
‫Quindi, penso di averlo fatto con successo.
‫Spero che tu abbia capito come funziona e, naturalmente,
‫in caso contrario, puoi sempre fare una domanda nella
‫sezione ufficiale di domande e risposte.
‫Ad ogni modo, ci sono altri fantastici contenuti in arrivo in questo
‫momento e quindi, andiamo avanti.