Questa è la seconda parte dell'Esercizio Express Sessions.
Abbiamo completato la prima parte in precedenza,
dove abbiamo aggiunto il supporto per Express Sessions,
e utilizzare Express Sessions come un modo per monitorare gli utenti sul lato server
e riconoscere le richieste in arrivo dagli utenti.
In questo esercizio, non ci stiamo concentrando così tanto sulle sessioni Express,
ma vedremo un modo per estendere il nostro server API REST express per supportare
un nuovo modello per la registrazione e l'autenticazione degli utenti.
Quindi, introdurremo un nuovo modello utente e schema nella nostra applicazione.
Abbiamo già il percorso degli utenti slash che
il generatore espresso ha già montato il router di un utente.
Quindi, abbiamo intenzione di sfruttare questo e quindi aggiornarlo
per supportare la registrazione di nuovi utenti,
l'autenticazione di un utente esistente,
e anche la disconnessione di un utente dal nostro sito server.
Quindi, esamineremo Express Sessions come un modo per monitorare gli utenti una volta che l'utente accede,
e quindi quando l'utente si disconnette,
la sessione verrà rimossa dal sistema.
Quindi, come facciamo a fare questa estensione in questo esercizio?
Andiamo a scoprirlo.
Continuando con il nostro server API REST espresso,
andiamo ora nei modelli e aggiungere un nuovo file chiamato user.js.
Questo è il file in cui creeremo lo schema utente e il modello.
Verrà creato uno schema utente semplice che tiene traccia del nome utente e della password
e anche un flag impostato per indicare
se l'utente è un amministratore o un utente normale.
Quindi, questo è un modo per distinguere tra diversi tipi di utenti.
Quindi, in questo file,
cerchiamo prima di richiedere Mongoose perché stiamo creando uno schema Mongoose,
e poi creeremo uno schema denominato Schema Mongoose,
e poi diremo utente var.
Quindi questo è lo schema utente che stiamo per creare,
e diremo nuovo schema utente.
Lo schema utente sarà definito come ho appena detto,
con tre campi qui chiamati username
che ovviamente sarebbe della stringa di tipo,
e questo è un campo obbligatorio,
e questo è un campo univoco.
Non si desidera che due utenti con lo stesso nome utente nel sistema,
quindi creiamo il nome utente e quindi il secondo campo è campo password.
Ora, naturalmente, è possibile estendere
questo schema utente per consentire all'utente di monitorare l'intero profilo,
ma lo faremo in uno degli esercizi successivi, per il momento,
un utente viene riconosciuto all'interno del sistema semplicemente dal nome utente e dalla password.
Quindi, la password è della stringa di tipo e quindi è richiesta.
Il terzo campo che userò è chiamato admin.
Quindi l'amministratore è del tipo booleano,
e diremo default false.
Quindi, per impostazione predefinita, quando viene creato
un utente, viene creato un nuovo utente,
il flag di amministratore sarà impostato su false. È
possibile impostarlo esplicitamente su true dall'interno
del codice per contrassegnare un utente come utente amministrativo.
Forse è possibile fornire privilegi aggiuntivi a un utente amministrativo
o, forse, consentire all'utente amministratore di eseguire
determinate operazioni che gli utenti normali non lo farebbero.
Vedremo che in uno degli esercizi successivi,
per il momento, questo è lo schema utente che abbiamo creato,
creiamo un modulo da questo ed esportiamo da
questo modulo un modello Mangusta del nome utente.
Quindi, questo è il modello Mongoose e lo schema è
lo schema utente che abbiamo appena definito un po 'prima.
Quindi, questo è il modo in cui definiamo il nostro schema utente.
Quindi, ora che abbiamo definito il nostro schema utente,
andiamo nel router che è già stato impostato
dal generatore express quando genera questa applicazione express.
Quindi, se vai nella cartella route,
vedrai questo file chiamato users.js.
Quindi, questo file users.js verrà esteso per creare il router.
Quindi, proprio lì quello che ho intenzione di fare è importare corpo-parser,
e poi dichiareranno il router espresso,
e poi diremo anche importare
lo schema utente e il
modello da modelli utente,
e poi per il router espresso diremo,
router usa body parser.
Quindi, ora che abbiamo dichiarato il parser corpo lì dentro,
stiamo andando a lasciare questa parte come tale, in
seguito lo modificheremo per consentire
all'amministratore di essere in grado di recuperare
tutti gli utenti che sono registrati nel sistema, ma per il momento,
stiamo andando a lasciare quel percorso in quanto tale.
Aggiungeremo qualche altro percorso qui,
quindi diremo, «Router post».
Quindi supporteremo l'operazione di post su un percorso chiamato registrazione e, come ci si aspetta,
questo percorso di registrazione permetterà a un utente di
registrarsi sul sistema, quindi questo supporterà la registrazione dell'utente.
Quindi diremo: «Rec, res, il prossimo.»
E così questo sarebbe il post di registrazione del router,
i metodi rimanenti non saranno consentiti sulla parte finale della registrazione.
Quindi, per accedere a questo,
dal momento che questo router utenti è montato su utenti barra,
vorremmo specificare questo endpoint come barra utenti slash registrazione,
e questo è il punto finale che verrà utilizzato per registrare nuovi utenti all'interno del sistema.
Quindi, la prima cosa che faremo è usare
il metodo utente e l'aspettativa è che per un utente si iscriva,
il nome utente e la password saranno forniti come una stringa JSON
all'interno del corpo della richiesta di post in arrivo.
Quindi, dal corpo,
dal momento che il corpo sarebbe già stato analizzato dal parser del corpo,
quindi dal corpo,
controllerà prima per assicurarsi che
l'utente con quel nome utente non esista all'interno del sistema.
Se l'utente con quel nome utente esiste,
si sta tentando di registrare un utente duplicato
e questo non dovrebbe essere consentito nel sistema.
Quindi, diremo, «Gli utenti ne trovano uno», e poi cercheremo di trovare se
c'è un utente con il nome utente che è stato
selezionato dal client che sta cercando di registrare un nuovo utente.
Se l'utente esiste già
, ovviamente non permetterai al nuovo utente di registrarsi con lo stesso nome utente.
Quindi, diremo, «Allora utente».
Quindi, questo restituirà l'utente qui e all'interno di questo campo utente,
quindi controlleremo se l'utente esiste già,
e quindi mi permetta di rilevare l'errore qui.
Quindi diremo, «Catch error», e poi, «next error».
Quindi, lo passeremo al gestore degli errori lì.
Quindi, se questa ricerca per l'utente restituisce il campo utente,
se l'utente non è uguale a null.
Quindi, se l'utente restituito da questa ricerca
non è nullo, significa che l'utente con quel nome utente esiste già,
quindi non dovresti consentire una registrazione duplicata.
Quindi diremo, «Var err nuovo errore.»
E diremo, «User req. body username.»
Esiste già. Quindi, fondamentalmente,
stai impedendo a un utente duplicato di registrarsi e quindi diremo
err.status 403 rispetto al proibito e quindi esci,
chiamando il gestore degli errori, prossimo err.
Altrimenti, questo significa che l'utente non esiste,
quindi dovresti consentire all'utente di essere disconnesso.
Quindi, nella parte altrimenti,
diremo, restituisce user.create ().
Creeremo un nuovo utente con il nome utente impostato su req.body.username,
e poi lasciatemi mettere questo nella riga successiva in modo che sia più chiaro per voi,
e diremo password: req.body.password.
Ora, sappiamo già che il flag admin per impostazione predefinita sarà impostato su false,
quindi lo lasceremo come tale,
e questo permetterà al nostro nuovo utente di essere registrato e quando il nuovo utente è iscritto,
questo restituirà una promessa e all'interno del «allora» gestiremo questa promessa qui.
Quindi, questo restituirà la promessa da
questo «allora» e poi la gestiremo nel prossimo «allora» qui.
Dirà quindi, res.statusCode è 200,
Res.SetHeader e diremo Content-type application/json
e diremo, res.json (status: Registrazione riuscita),
e se vuoi,
possiamo caricare l'utente in
questo messaggio di risposta qui come proprietà nel json.
Dirà Registrazione riuscita.
Quindi se c'è un errore in
questa operazione dirà «prossimo errore».
Quindi gestirà l'errore.
Se la promessa non si risolve correttamente,
verrà gestita da questo. Quindi questo è tutto.
Quindi qui, abbiamo un modo per l'utente di registrarsi.
Quindi, affinché l'utente si iscriva,
l'utente farà un post su/users/signup e nel corpo del messaggio,
il client includerà una stringa json
con proprietà username e password in quella stringa json.
Ecco come ti iscrivi per un nuovo utente.
Ora, vediamo come accederemo l'utente.
Ora, useremo ancora le sessioni Express che abbiamo fatto in precedenza per tenere traccia dell'utente.
Quindi, per registrare un utente dirà «router.post» sul punto finale/login.
Quindi sull'endpoint /login,
faremo un router.post.
Ovviamente invece di dire funzione,
è possibile utilizzare la funzione freccia qui per il router.post,
ho intenzione di fare la stessa cosa qui.
Mi sono appassionato alle funzioni delle frecce.
Quindi, faremo una funzione freccia qui.
Quindi, per il login, come procede il login?
Quindi, per il login,
quello che faremo è che andremo al file app.js e poi all'interno di questa autenticazione,
stavamo facendo quella registrazione per l'utente lì.
Quindi, quello che faro' e' copiare
tutta questa faccenda, perche' comunque non farei tutto questo.
Quindi, piuttosto lasciami copiare tutto il percorso da questo punto in poi fino a req.session.user.
Quindi, la parte if di req.session.user ho intenzione di copiare,
e poi venire a users.js e per il login.
È esattamente come farò l'autenticazione.
Quindi diremo se non req.session.user.
Ciò significa che l'utente non si è ancora autenticato.
Quindi, si prevede l'autenticazione di base come
meccanismo per l'utente da utilizzare per l'autenticazione.
Quindi diremo var authHeader se! AuthHeader quindi solleveremo l'errore,
altrimenti recupereremo il nome utente e la password dall'intestazione.
Ora, qui stavamo facendo se il nome utente è uguale a admin e la password è uguale alla password.
Ma ora, quello che faremo è che stiamo andando a cercare
nel database per vedere se quel particolare utente esiste.
Quindi, invece di farlo qui,
invece di farlo se username e password,
diremo, user.findone
e diremo username è username.
Quindi questa proprietà è uguale a questo nome utente che abbiamo appena recuperato
e poi diremo poi utente.
Quindi dentro questo «allora».
Quindi ho intenzione di spostare questo codice all'interno di questo «allora» perché
ora quello che ho intenzione di controllare è ora che ho recuperato l'utente,
ho bisogno di controllare per assicurarmi che questo utente sia esattamente quello che sto cercando.
Quindi, a questo punto,
ci accingiamo prima a verificare che l'utente non sia nullo.
Quindi diremo se l'utente è nullo.
Quindi, se l'utente è nullo, il
che significa che non siamo riusciti a trovare un utente con quel particolare nome utente.
Quindi, dovrai restituire un errore qui.
Quindi lasciami copiare questa parte e poi incollarla
qui e poi torneremo dicendo var nuovo errore
e diremo che il nome
utente spazio utente
non esiste.
Quindi in questo caso,
questo utente non esiste, quindi rimuoverò questa parte e
quindi lo stato di errore corrispondente sarebbe 403 qui.
Quindi questa è la prima parte.
Se l'utente è nullo allora stiamo ovviamente andando a dire che l'utente non esiste.
La seconda parte che stiamo andando a controllare è Else se password utente.
Quindi il che significa che l'utente esiste a questo punto.
Quindi, il secondo controllo che faremo è che la password dell'utente non è
uguale alla password allora.
Abbiamo ancora bisogno di indicare l'errore lì.
Quindi l'errore direbbe,
in questo caso, diremo
«la tua password non è corretta».
Quindi questa è la seconda parte qui.
Quindi la tua password non è corretta e poi l'ultima parte.
Diremo «altro».
Quindi lasciami indentare questo codice.
Quindi se user.username
è username che ovviamente dovrebbe essere vero in questo caso.
Quindi la seconda parte,
user.password è uguale alla password che ovviamente dovrebbe essere corretta a questo punto.
Ma in ogni caso,
ho intenzione di controllare questo problema qui e questo altro non si verificherà affatto in questo caso.
Quindi, quando raggiungi questo punto,
il nome utente dovrebbe essere
lo stesso del nome utente e la password dovrebbe essere la stessa di una password,
ma in ogni caso ho messo un doppio controllo a quel punto solo per essere doppiamente sicuro.
Quindi in questo caso,
diremo che req.session.user è autenticato.
Quindi, imposteremo questo su autenticato
e anche questo, diremo
res.statusCode è 200.
Quindi siamo stati in grado di autenticare con successo l'utente.
Quindi, diremo res.statusCode è 200 e poi diremo res.setHeader
Content-Type testo semplice e
res.end semplicemente invieremo un messaggio dicendo «Sei autenticato».
Questo è tutto. Quindi, questo copre la parte allora dell'utente findOn.
Quindi prima, controlliamo che se l'utente è nullo,
ciò significa che non siamo riusciti a trovare l'utente,
quindi stiamo ovviamente restituendo un errore che dice che il nome utente non esiste.
Se la password dell'utente non corrisponde alla password,
quindi a questo punto,
l'utente esiste ma la password non corrisponde, quindi diremo,
«La password non è corretta», e poi, infine,
raggiungiamo questo punto, quindi il nome utente e la password dovrebbero essere identificati correttamente.
Anche se non ho bisogno di questo controllo, ma l'ho appena messo lì e poi a questo punto,
imposterò req.session.user per
autenticarlo e quindi impostare il codice di stato su 200, il che significa che sei stato
in grado di autenticare l'utente e quindi puoi finire a quel punto.
Poiché questo è un allora,
inserirò una cattura a questo punto,
quindi diremo errore catch e se si verifica l'errore,
allora passerò semplicemente l'errore
al successivo in modo
che il gestore degli errori sia in grado di gestire l'errore in modo appropriato.
In modo che finisca questo utente findONE.
Ora, questo è il caso in cui req.session.user non è impostato.
Se questo è già
impostato, significa che l'utente è già connesso.
Quindi, in questo caso,
l'altra parte qui si occupa della situazione dicendo che imposteremo
lo StatusCode su 200
e il Content-Type su text/plain e poi diremo,
«Sei già autenticato».
Quindi, se raggiungi quest'altra parte,
verresti qui perché req.session.user non è già nullo,
quindi il che significa che l'utente è già stato autenticato,
quindi significa che quando raggiungi questo punto,
l'utente ha già effettuato l'accesso in precedenza,
quindi non è necessario verificare.
Quindi direte semplicemente
«Sei già autenticato» e poi finisci a questo punto.
Ok. Quindi ora, l'ultimo metodo che implementeremo è per disconnettere l'utente.
Quindi, faremo un router.get su/logout.
Vi starete chiedendo perché facciamo un get
sul logout piuttosto che un post che abbiamo fatto sul login?
Al login, è necessario inviare il nome utente e la password.
Per il logout stai semplicemente disconnettendo te stesso dal sistema,
quindi non è necessario fornire ulteriori informazioni perché
il server ti sta già monitorando in base al
tuo ID di sessione e all'interno di quel cookie di sessione qui.
Quindi, è per questo che non abbiamo
esplicitamente bisogno di inviare ulteriori informazioni nel corpo del messaggio.
Quindi diremo se req.session in modo che significa che la sessione deve esistere
, altrimenti si sta cercando di disconnettere un utente che non ha effettuato l'accesso.
Quindi non ha senso.
Ora, la sessione stessa fornisce questo metodo
chiamato destroy e quando si chiama il metodo destroy,
la sessione viene distrutta e le informazioni vengono rimosse
dal lato server relativo a questa sessione.
Quindi, il che significa che se il client tenta di inviare nuovamente
le informazioni di sessione che sono memorizzate sotto forma
di un cookie firmato sul lato client,
ciò non sarà valido.
Quindi abbiamo bisogno di un metodo per eliminare il cookie che viene memorizzato sul lato client.
Ora, questa operazione rimuoverà
le informazioni di sessione dal lato server in modo che la sessione non sia più valida.
Quindi, a questo punto,
diremo req.session.destroy e poi diremo, res.clearcookie.
Quindi ClearCookie è un modo per chiedere al client di
rimuovere il cookie e il nome del cookie è l'ID della sessione.
Quindi, nell'esercizio precedente,
abbiamo visto che il cookie è stato memorizzato con il nome dell'ID di sessione sul lato client.
Quindi stiamo chiedendo al cliente di eliminare questo cookie
dal lato client nel messaggio di risposta e poi diremo,
res.redirect e lo reindirizzeremo alla homepage qui.
Quindi, questo è un modo per reindirizzare l'utente per accedere alla loro pagina standard,
quindi ad esempio, la homepage della tua applicazione.
Quindi, questo è il modo in cui gestiresti il logout del sistema.
Se la req.session non esiste,
significa che non hai effettuato l'accesso,
quindi dovremo generare un errore.
Quindi diremo var err,
nuovo errore, «Non sei connesso»,
e imposteremo lo stato di errore su 403,
questa è un'operazione proibita e
quindi generare l'errore al gestore degli errori, il gioco è fatto.
Così ora, si vede che abbiamo esteso il router dell'utente per supportare tre nuovi endpoint,
l'endpoint di registrazione che consente a un utente di registrarsi,
l'endpoint di login che consente a un utente registrato di accedere,
e quindi l'endpoint di logout che consente a un utente connesso di disconnettersi dal sistema.
Nel processo di disconnessione,
stai distruggendo la sessione sul lato server,
stai anche cancellando il cookie sul lato client, in
modo che il client non possa essere utilizzato nella sessione scaduta per provare a contattare quel server.
Una correzione minore in users.js,
questo dovrebbe essere var User require.. /models/user,
ricorda che il file users.js si trova nella cartella route e quindi
il file user.js si trova
nella cartella models che è su di un livello e quindi nella cartella models.
Quindi, questo dovrebbe essere.. /models/user,
quindi fai quella correzione minore, il gioco è fatto.
Abbiamo modificato il file users.js,
ora l'ultima cosa che dobbiamo fare è andare a riparare il file app.js.
Nel file app.js dell'app,
se si naviga nel file app.js,
si vedrebbe che abbiamo
questo indice barra qui e gli utenti barra qui dopo l'autenticazione.
Ora, questo non funzionerà per noi perché se hai bisogno di registrarti,
allora l'utente dovrebbe registrarsi e accedere prima che l'autorizzazione sia confermata,
comunque se l'iscrizione e l'accesso è per il processo di registrazione,
quindi ho intenzione di spostarli su prima della fase di autenticazione qui.
Quindi, lo sposteremo in questo posto.
Quindi, un utente in arrivo può accedere
al file di indice alla barra e anche accedere all'endpoint degli utenti senza essere autenticato,
ma qualsiasi altro endpoint,
l'utente deve essere autenticato,
quindi questo è il modo in cui impostiamo questo.
All' interno dell'autenticazione della funzione, diremo,
«Se non req.session.user,» quindi notare che questo posto,
non permetteremmo all'utente di entrare qui senza che l'utente abbia effettuato l'accesso.
Quindi, se non req.session.user,
allora diremo semplicemente che non sei autenticato.
Questa autenticazione deve essere eseguita utilizzando il metodo di login qui.
Quindi, ho intenzione di rimuovere tutta questa parte qui.
Quindi, diremo, se non req.session.user,
diremo che non sei autenticato e quindi dovremo inviare una foto tre qui,
quindi il che significa che non dovresti mai scendere in questo punto
senza che l'utente acceda.
Quindi, diremo che non sei autenticato.
Ricorda che devi autenticarti facendo un POST
sul punto finale di accesso barra degli utenti.
Quindi diremo che non sei autenticato, altrimenti,
se req.session.user è uguale a,
ricorda che nella funzione di login nel
users.js abbiamo impostato l'utente della sessione successiva sulla stringa autenticata.
Quindi, questo è quello che stiamo andando a controllare.
Diciamo, se req.session.user è autenticato,
diremo dopo, altrimenti non si è autenticati di nuovo.
Poi invieremo un messaggio proibito. Questo è tutto.
Quindi, con questo aggiornamento,
anche il mio file app.js è pronto.
Ora, dopo aver fatto questi aggiornamenti,
andiamo a controllare come funziona la nostra applicazione ora.
Andando al terminale,
se il server è in esecuzione, interromperlo e quindi riavviare il server.
Il mio server non è in esecuzione al momento,
quindi dirò npm start
e il mio server dovrebbe essere attivo e funzionante.
Vediamo ora come accederemo al server.
Andando a Postman, fammi fare un GET su
localhost: 3000/piatti e poi vedrai immediatamente
che si lamenta dicendo che non sei autenticato.
Ovviamente, non sono autenticato qui.
Permettetemi di provare ad accedere solo al localhost: 3000 e vedrete che,
quella radice è disponibile per noi.
Ora, naturalmente, vogliamo prima registrare un utente e quindi accedere
come utente e poi ottenere l'accesso al resto degli endpoint API REST.
Quindi, per prima cosa, fammi registrare un utente.
Per registrare l'utente,
ho bisogno di fare un POST per localhost: 3000/users/signup.
Per questo messaggio POST,
nel corpo del messaggio,
ho bisogno di includere nel corpo
del messaggio una stringa JSON con il nome utente.
Quindi, lasciami accedere da
solo e poi userò la password come password.
Questa è una registrazione valida.
Quindi, quando mi iscrivo come utente con
queste informazioni sotto forma di una stringa JSON inclusa nel corpo del messaggio,
fammi vedere che l'intestazione ora contiene l'applicazione di tipo di contenuto,
JSON perché ho impostato il JSON nel corpo
del messaggio e quindi inviare il POST alla registrazione.
Quindi, quando invio il POST alla registrazione,
vedi immediatamente cosa viene restituito dal server qui.
Quindi, vedi che il server è tornato dicendo,
«Registrazione riuscita» e se stesso,
mi dà i dettagli dell'utente qui.
Quindi, questo è un record che esiste nel mio MongoDB e
nota che il tipo di modello è il tipo di modello utente che abbiamo impostato.
Quindi, abbiamo il nome utente e la password e
il flag di amministratore come puoi vedere è impostato su false per impostazione predefinita.
Una volta registrato l'utente,
questo utente è ora un utente valido.
Quindi, fammi provare a POST di nuovo lo stesso utente e vedere cosa succede.
Quindi, quando POSSO lo stesso utente ovviamente,
lì dal lato server,
risponde dicendo che questo utente esiste già.
Quindi, puoi vedere che abbiamo impostato la nostra procedura di registrazione per non consentire all'
utente di duplicare il registro con lo stesso ID utente.
Ok. Quindi, questa e' la seconda parte.
Ora, facciamo un login dell'utente.
Per fare un login dell'utente,
lasciami rimuovere il tipo di contenuto e quindi
rimuoverò anche il corpo perché per il login, non è richiesto.
Quindi, non inserisco nulla
nell'intestazione e poi provo ad accedere e quando ho provato ad accedere,
risponde dicendo che non sei autenticato.
Non sei autorizzato.
Ora, ho bisogno di registrarmi.
Quindi, questo è dove posso usare l'autenticazione di base.
Quindi, nell'autenticazione di base,
sto solo andando a digitare il mio nome utente e
password che ho appena registrato nel passaggio precedente e quindi aggiornare la mia richiesta,
e quindi fare un POST sul login.
Quindi, quando faccio un POST sul login,
vedi che il server risponde dicendo «Sei autenticato».
Quindi, a questo punto,
posso eseguire le
richieste GET, PUT, POST e DELETE su tutti gli altri endpoint.
Quindi, a questo punto, se faccio un GET sull'endpoint piatti,
vedresti che questo restituisce
il campo vuoto perché il mio database è attualmente vuoto.
Permettetemi di cancellare l'autorizzazione e anche dall'intestazione rimuovere
l'autorizzazione e quindi fare GET e la sua cassetta degli attrezzi va bene.
Quindi, puoi vedere che ora sono in grado di
accedere agli endpoint perché ho effettuato l'accesso.
Quindi ora, lasciami fare un logout dell'utente.
Quindi, diremo, localhost: 3000 e logout.
Si noti inoltre che, nei cookie,
un cookie è stato impostato all'ID di sessione proprio lì.
Quindi, quel cookie esiste sul mio sito cliente.
Quindi ora, lasciami uscire dicendo GET localhost: 3000/utenti/logout.
Quindi, quando eseguo un log out dall'utente,
vedrai immediatamente che vengo reindirizzato a
quell'endpoint localhost: 3000 e noterò anche che il cookie è sparito.
Quindi, quando guardo i cookie,
vedi che il localhost,
il cookie è sparito perché dal mio lato server quando faccio il logout
invia un cookie chiaro di riposo al lato client e quindi il cookie è sparito.
Ora, se provo a fare un GET
sull'endpoint localhost: 3000/piatti,
questo non funzionerà perché non sono autenticato.
Quindi, questo dimostra come è possibile estendere il server Express per
consentire agli utenti di registrarsi e quindi consentire all'utente di accedere al sistema
e quindi anche disconnettersi dal sistema.
Sul lato server si sta tracciando un utente connesso utilizzando la sessione e utilizzando
il cookie sul lato client e quando l'utente si
disconnette il cookie viene distrutto sul lato client.
Con questo, completiamo questo esercizio.
Questo è un buon momento per fare un commit Git,
con il messaggio, le sessioni Express parte due.