Ora che comprendiamo i cookie e le sessioni express,
in questo esercizio, diamo un'occhiata ai cookie in particolare.
Vedremo come possiamo utilizzare il middleware cookie-parser
per impostare e gestire i cookie all'interno della nostra applicazione espressa.
Tornando alla nostra applicazione Confusione Server Express
su cui abbiamo lavorato finora,
noterai in cima che il parser di cookie è
già incluso nella nostra applicazione espressa.
Se è necessario installare in modo esplicito cookie-parser,
è sufficiente digitare «npm install cookie-parser meno meno save».
Ma dal momento che il nostro Generatore Express ha già incluso
il parser di cookie nella nostra applicazione espressa che abbiamo impalcato,
non abbiamo bisogno di fare questo passo in questo esercizio.
Quindi, vedi che il parser di cookie è già incluso lì,
e quindi se scorri verso il basso,
vedrai che nel codice qui sotto,
vedrai che il parser di cookie è già stato incluso nel middleware lì.
Ora, per questo parser di cookie,
useremo i cookie firmati in questo esercizio.
Quindi, per questo parser di cookie,
ho intenzione di fornire una chiave segreta come parametro qui.
La chiave segreta potrebbe essere qualsiasi stringa lì,
quindi sto solo andando a fornire una stringa come questa, dirò 12345-67890.
Non deve essere nulla di significativo,
è solo una chiave che può essere utilizzata dal
nostro parser di cookie per crittografare
le informazioni e firmare il cookie che viene inviato dal server al client.
Quindi, una volta impostato il nostro cookie parser per gestire i cookie firmati,
quindi all'interno dell'autorizzazione stessa,
in modo da vedere che abbiamo l'autorizzazione che abbiamo costruito qui.
Ora, all'interno dell'autorizzazione,
quello che faremo è,
la prima volta che l'utente tenta di accedere al server,
ci aspettiamo che l'utente si autorizzi.
Successivamente, imposteremo il cookie sul lato client dal server e
successivamente il client non dovrà
continuare esplicitamente a inviare le informazioni di autenticazione di base.
Invece, il client dovrà semplicemente includere il cookie nella richiesta in uscita.
Dal momento che stiamo usando i cookie firmati qui, quindi,
quando arriva la richiesta in arrivo,
quindi gestiremo che all'interno dell'autorizzazione.
Ora, si ricorda che abbiamo già impostato il middleware di autorizzazione qui.
Quindi, stiamo andando a modificare questo middleware di autorizzazione per fare uso di
cookie invece dell'intestazione di autorizzazione.
Quindi, quello che faremo qui è che,
diremo «console.log» e poi lo faremo,
«console.log (Req.signedCookies)» in modo da vedere ciò che è effettivamente
incluso nel cookie firmato qui.
Ora, anche dopo questo,
quello che faremo sarà dire, «Se (! Req.signedCookies.user)». L'
utente sarà una proprietà che imposteremo
nel cookie firmato come vedrai un
po 'più tardi come imposteremo il cookie firmato.
Quindi, se la richiesta in arrivo non include il campo utente nei cookie firmati,
e quindi ciò significa che l'utente non è stato ancora autorizzato.
Quindi, in questo caso,
quello che faremo è aspettarci che l'utente si autentichi.
Quindi, allora, faremo tutta questa parte qui.
Quindi si noti che lo avevamo già fatto
in precedenza dove stavamo gestendo l'intestazione di autenticazione.
Quindi prenderemo tutta questa parte,
fino a questo «altro» qui e poi includeremo quello qui dentro.
Quindi, essenzialmente, quello che stiamo specificando qui è che,
permettetemi di indentarlo.
Come vedi, sono molto particolare sul mio rientro
perché questo mantiene il codice più facile da leggere.
Quindi all'interno di questo se,
quindi questo è il punto di chiusura del if di questo qui.
Quindi stiamo dicendo che se il cookie firmato non contiene la proprietà dell'utente su di esso,
allora ci aspettiamo che l'utente autorizzi includendo l'intestazione di autorizzazione.
Quindi cercheremo l'intestazione di autorizzazione.
Se l'intestazione di autorizzazione non è disponibile,
allora rifiuteremo semplicemente l'utente e chiederemo
all'utente di inserire il nome utente e la password come abbiamo fatto nell'esercizio precedente.
Se l'intestazione di autorizzazione è inclusa,
allora elaboreremo l'intestazione di autorizzazione proprio come abbiamo fatto prima,
e se l'utente è un utente autorizzato,
ricordare che abbiamo chiamato il prossimo per consentire all'utente di procedere in avanti.
Ora, a questo punto,
quello che faremo è che
diremo, imposteremo il cookie a questo punto.
Quindi questo è dove useremo il cookie res qui.
Si noti che il cookie non esiste,
quindi diremo «res.cookie».
Come puoi vedere, il cookie res stesso prende la stringa del nome del primo valore, la stringa del
valore e le opzioni, le opzioni dei cookie.
Impostare il nome del cookie su valore con le opzioni date e le opzioni sono incluse qui,
alcune opzioni per il cookie qui.
Ho intenzione di utilizzare semplicemente alcune delle opzioni qui.
Quindi diremo, «res.cookie» e poi ho intenzione di impostare il cookie con il nome utente.
Ora nota che questo è il motivo
per cui sto controllando Req.signedCookies.User lassù.
Quindi diremo «res.cookie ('utente',)» e
il campo utente lo imposterò su 'admin' e
poi lo imposterò come cookie firmato.
Quindi dirò «firmato: vero».
Quindi il che significa che il mio parser di cookie farà in modo
che questo cookie venga firmato e configurato.
Quindi questa è l'opzione che ho impostato per il cookie res qui.
Quindi questo includerà
questo particolare nome nel cookie firmato con questo particolare valore.
Quindi questo è il motivo per cui sono in grado di controllare quel valore quassù.
Quindi, se questo non esiste,
ovviamente mi aspetto che l'utente si autentichi utilizzando l'autenticazione di base,
e se l'autenticazione di base ha successo,
allora imposterò il cookie qui e imposterò
il campo cookie nel messaggio di risposta in uscita qui e
questo richiederà il per impostare il cookie sul lato client e quindi
tutte le richieste successive includeranno questo cookie nella richiesta del client.
Quindi è così che sto gestendo il fatto quando il cookie.user non esiste.
Lì. Se esiste,
allora la parte else,
quindi significa che il cookie firmato
esiste già e la proprietà dell'utente è definita su quello,
quindi nell'altro,
quello che controllerò è
se req.signedCookies.User è admin.
Quindi, ciò significa che il cookie firmato contiene le informazioni corrette.
Allora, dirò il prossimo.
Quindi il che significa che consentirai la richiesta di passare attraverso.
In caso contrario, questo cookie non è valido perché non contiene questo valore corretto.
Quindi questo significa che questo è un errore.
Quindi, in questo caso,
diremo che non sei autenticato,
e quindi causeremo semplicemente l'errore in questo punto.
Ora, non abbiamo intenzione di chiedere all'utente per
la sessione perché questo deve essere stato fatto in precedenza.
Ora, normalmente, questo non accadrebbe
perché se il cookie è già impostato sul lato client,
allora deve includere comunque il valore corretto.
Ma per motivi di completezza,
ho anche incluso il controllo degli errori else qui a questo punto. Questo è tutto.
Con questa configurazione, abbiamo trasformato
la nostra applicazione espressa in una che gestisce i cookie qui.
Nota ancora, lascia che richiami la tua attenzione su quello che stiamo facendo qui ancora una volta.
Qui, stiamo controllando per assicurarci
che la proprietà dell'utente nei cookie firmati non esista,
o che il cookie firmato stesso non esista.
Quindi, ci aspetteremo che venga fatta un'autorizzazione di base.
Se l'autorizzazione ha successo,
allora ho intenzione di impostare il cookie utilizzando il res.cookie qui.
Quindi, tutte le richieste successive porteranno comunque il cookie firmato,
quindi controllerò per vedere che il cookie firmato è
un cookie firmato valido e contiene la proprietà utente impostata su admin.
Se lo fa, allora questo è un accesso autorizzato,
quindi permetterà di procedere in avanti.
In caso contrario, allora sollevo un errore a questo punto.
Correzione minore, le nuove versioni di Node.js si aspettano di utilizzare questo come
nuovo buffer.From invece di nuovo Buffer per affrontare alcuni problemi di sicurezza.
Quindi basta correggere questa linea al nuovo buffer.from. Questo è tutto.
Salviamo le modifiche e poi andiamo a guardare la nostra applicazione in quel postino.
Se il server precedente è in esecuzione,
basta interromperlo digitando Control C,
quindi riavviare il server dicendo npm start.
Naturalmente, assicurati che il tuo server MongoDB sia attivo e funzionante.
In caso contrario, il server espresso non verrà avviato correttamente.
Quindi, una volta avviato il server espresso,
andiamo al nostro Postman e proviamo a connetterci al server.
E dimostrerò alcuni aspetti su come vengono gestiti i cookie.
Ora, andando al Postman,
fammi cancellare tutte queste informazioni
dal mio postino e poi inizieremo con le basi.
Quindi fammi provare ad accedere al localhost: 3000/piatti.
Ora, dopo aver cancellato tutto,
invierò la richiesta e salverò.
E così dal lato server,
dice che non sei autenticato.
Quindi, quando guardi l'intestazione,
questo mi sta chiedendo di autenticarmi usando WWW-Authenticate.
Quindi ora, lasciami entrare nell'autorizzazione e quindi impostare l'autorizzazione di base,
quindi imposterò l'autorizzazione come amministratore e quindi la
password, e quindi aggiorna la richiesta in modo che l'intestazione
conterrà ora l'intestazione di autorizzazione qui con le informazioni lì.
E poi lasciami inviare la richiesta Git su questa parte.
Se invio la richiesta Git,
quindi in risposta, vedi che la richiesta Git ha avuto successo.
Nota anche alcune altre cose.
Vedrai che lo stato è 200 OK.
Si noti inoltre che un cookie è stato impostato sul nostro lato client all'interno di Postman qui.
Questo cookie contiene informazioni.
Vedremo i dettagli del biscotto tra un minuto.
Quindi, quando guardi l'intestazione,
vedi nell'intestazione questo valore qui dicendo Set-Cookie,
e quindi queste informazioni che arrivano qui.
Ora, se lo guardi attentamente,
vedrai qualcosa qui dice utente uguale a,
e poi vedi questo valore qui, admin lì.
Quindi, si nota che qualcosa è stato racchiuso all'interno del cookie.
Se si vuole effettivamente esaminare il cookie,
andare qui in Postman e poi fare clic su queste chiavi,
e poi questo vi mostrerà tutti i cookie che sono stati impostati su questo lato client.
Quindi, in particolare, ora permettetemi di cancellare tutti questi altri cookie.
Probabilmente ne ho usati alcuni per qualche altro motivo.
Quindi fammi pulire quei biscotti.
Comunque, se li vedi,
puoi lasciarli li'.
Non e' un grosso problema.
Concentrati specificamente sull'host locale qui,
e poi vedi questo cookie qui.
Basta fare clic sul cookie,
e poi si vede il valore effettivo all'interno del cookie che è memorizzato lì.
Quindi anche la data di scadenza per la configurazione dei cookie qui.
Ora, questo valore sarà esattamente quello che hai visto
nel cookie impostato che è entrato dal lato server.
Ora, questo significa anche che nelle richieste successive che entrano,
quindi anche se cancello la mia autorizzazione,
e anche se rimuovo l'intestazione di autorizzazione,
perché il cookie è stato impostato,
questo cookie è stato impostato sul mio host locale,
ogni richiesta successiva va a questo server includerà questo cookie.
Quindi, anche se non avrei le intestazioni impostate lì,
se invio la richiesta,
noterai che la richiesta Git funziona proprio come prima senza alcun problema, a
causa del fatto che ogni richiesta in uscita includerà automaticamente
questo cookie nella richiesta in uscita dal mio Postman Qui.
Questo dimostra l'uso dei cookie nella nostra applicazione.
Con questo, abbiamo visto come i cookie possono essere
impostati ed elaborati nel nostro server espresso utilizzando il parser di cookie
e come possiamo impostare i cookie firmati.
Questo è un buon momento per fare un commit git con i cookie del messaggio.