‫-: In questa lezione, consentiremo all'utente
‫attualmente connesso di manipolare i suoi dati utente.
‫E così ora, implementando gli aggiornamenti degli
‫utenti, stiamo davvero lasciando il dominio dell'autenticazione e
‫ci stiamo spostando di più in cose relative agli utenti reali, ok?
‫Quindi, invece di utilizzare il controller di autenticazione
‫ora, implementiamo questa funzionalità di aggiornamento
‫direttamente nel loro userController.
‫Ok, quindi
‫abbiamo un sacco di gestori, quindi
‫di percorsi, che non sono realmente implementati qui, ok?
‫Ma lasciamoli da parte per ora
‫e creiamo la nostra nuova funzione di gestione qui sotto.
‫E questo si chiamerà updateMe.
‫E così di nuovo, è updateMe perché serve
‫per aggiornare l'utente attualmente autenticato.
‫Successivamente, implementeremo anche questa funzione
‫updateUser qui, ma questo è come un amministratore
‫per aggiornare tutti i dati dell'utente, mentre l'utente
‫stesso può aggiornare solo, almeno per ora, il nome
‫e l'indirizzo e-mail.
‫Quindi, richiesta, risposta e il prossimo.
‫(clack della tastiera) E lo stiamo effettivamente
‫facendo, quindi aggiornando i dati dell'utente, in un
‫percorso diverso rispetto all'aggiornamento della password dell'utente, beh perché
‫di solito in una tipica applicazione web
‫è sempre così.
‫Quindi di solito hai
‫un posto dove puoi aggiornare
‫la tua password e poi un altro posto
‫dove puoi aggiornare i dati sull'utente o sull'account stesso.
‫E quindi qui, stiamo semplicemente seguendo questo schema.
‫Quindi, di nuovo, iniziamo esponendo i nostri passaggi.
‫E la prima cosa che
‫vogliamo fare qui è creare fondamentalmente
‫un errore se l'utente tenta di aggiornare la password.
‫Quindi crea un errore se l'utente pubblica
‫fondamentalmente i dati della password.
‫Ma in caso contrario, dobbiamo semplicemente aggiornare il documento dell'utente.
‫Abbastanza semplice, e cominciamo ovviamente con
‫il primo.
‫Ovviamente ci sarà un
‫corpo in cui passeremo i dati,
‫e quindi se su quel corpo ci sono dati sulla password,
‫o una conferma della password...
‫(tasti che battono)
‫Confermare.
‫Bene, in tal caso, vogliamo tornare immediatamente e
‫creare un nuovo Apperror.
‫Oh, e immagino che non l'abbiamo ancora implementato qui,
‫o in realtà lo
‫richiediamo, quindi prendiamolo da qui.
‫Quindi AppError...
‫Non è
‫qui, quindi userController...
‫Quindi AppError, ci siamo.
‫Quindi 'Questo percorso non è per gli aggiornamenti delle password.
‫'Utilizzare /updateMYPassword. ' Quindi sostanzialmente
‫il percorso che abbiamo specificato prima.
‫Quindi aggiornaMYPassword.
‫E poi anche un codice 400 per una cattiva richiesta.
‫E proviamo subito questo.
‫E per questo
‫solo due cose, prima dobbiamo inviare
‫una risposta, quindi diciamo res. status(200) per okay, quindi json,
‫aggiungi lo
‫stato come success.
‫E in seguito invieremo anche l'utente aggiornato, ma
‫lo lasciamo per dopo.
‫Quindi questa è la risposta, e ora ovviamente
‫abbiamo anche bisogno di aggiungere questo percorso al nostro router utente.
‫Quindi è ovviamente simile all'aggiornamento della mia
‫password, quindi router e, naturalmente, una patch, /updateMe,
‫quindi
‫di nuovo, è un percorso protetto
‫in modo che solo l'utente attualmente autenticato possa aggiornare i
‫dati dell'utente corrente.
‫E quindi tutto questo è ovviamente davvero
‫sicuro, ancora una volta perché l'ID dell'utente che verrà aggiornato
‫proviene dalla richiesta. user, che
‫è stato impostato da questo middleware di protezione qui, che a
‫sua volta ha preso l'idea dal token web json, e
‫poiché nessuno può cambiare l'ID in quel token web
‫json senza conoscere il segreto, sappiamo bene
‫che l'ID è quindi sicuro a causa di ciò.
‫E quindi per questo tutto qui è al sicuro.
‫Quindi, userController. aggiornami.
‫Adesso va bene...
‫Quindi proviamo questo ora.
‫Vai avanti e copialo di nuovo.
‫E prima di tutto, impostiamo l'autorizzazione.
‫Di nuovo dal token Bearer e ovviamente
‫con questa variabile d'ambiente.
‫Inoltre deve essere una richiesta di patch
‫e dobbiamo specificare un corpo.
‫E voglio iniziare testandolo, causando ovviamente
‫questo errore, quindi specifichiamo
‫una password e poi
‫un nome.
‫Quindi diciamo che questo è il nome che vogliamo
‫aggiornare, quindi salviamolo qui.
‫E in realtà è ovviamente nella cartella Utenti.
‫Dati utente.
‫E in realtà creiamo una nuova
‫cartella qui e mettiamo le cose relative all'autenticazione
‫nella propria cartella.
‫Quindi, quassù, creiamo
‫una nuova cartella e la chiamiamo Autenticazione.
‫Non è corretto.
‫AH-THEN-TICATION.
‫(ridacchia) Allora è così.
‫E quindi la password è correlata
‫all'autenticazione, anche alla reimpostazione della password, alla dimenticanza della password,
‫all'accesso e alla disconnessione.
‫Quindi, chiudiamo questi due e
‫ora accedi come, o effettivamente creiamo
‫un nuovo utente.
‫Quindi iscriviamoci qui,
‫come utente normale, così possiamo sbarazzarci di questi due qui.
‫E ora lo sto semplicemente chiamando, beh, prova di nuovo, va bene?
‫E diamo un'occhiata a quali utenti abbiamo attualmente
‫nel nostro database.
‫Quindi abbiamo ciao e
‫amministratore, quindi ora usiamo test.
‫E sono sempre di nuovo, usando la stessa
‫password per renderlo davvero facile.
‫Va bene, dobbiamo dare anche il nome, chiamiamolo
‫J qui.
‫E ora effettivamente otteniamo il nostro token,
‫e siamo già connessi,
‫quindi ora quando aggiorniamo l'utente, dovrebbe
‫essere per questo utente che ha appena effettuato l'accesso.
‫Quindi non sto cercando di aggiornare
‫e, naturalmente, nessun aggiornamento è stato ancora implementato e quindi non funzionerà.
‫Tutto quello che voglio vedere è l'errore
‫che dovrebbe verificarsi perché ho specificato questa proprietà password qui sul corpo.
‫Quindi proviamolo.
‫E qui otteniamo questo tipo di errore dall'aspetto strano, ma
‫immagino sia semplicemente perché non abbiamo effettivamente aggiornato
‫il percorso qui,
‫quindi ricorda che ho appena copiato un percorso, quindi l'URL,
‫e l'ho appena incollato qui.
‫Ma ovviamente, deve essere updateME.
‫Quindi proviamo di nuovo.
‫E così ora otteniamo effettivamente quell'errore che abbiamo specificato.
‫"Questo percorso non è per gli aggiornamenti della password.
‫"Utilizzare /updateMyPassowrd. "Così fantastico,
‫quella parte funziona, e
‫funziona anche che dobbiamo essere autenticati.
‫Perché diciamo che non abbiamo autenticazione, quindi
‫diciamo che: No Auth.
‫E quindi proviamoci di nuovo adesso.
‫E così infatti, "Non sei loggato!
‫"Effettua il login per ottenere l'accesso. "Quindi, solo
‫per dimostrarti che la nostra autenticazione sta effettivamente
‫facendo il suo lavoro anche qui.
‫Ma ovviamente, vogliamo il nostro token
‫Bearer, e quindi ora otteniamo quell'altro errore.
‫Ottimo, quindi ora andiamo avanti
‫implementando il resto della funzionalità per il gestore updateMe.
‫Quindi aggiornando il documento dell'utente, e potremmo provare
‫a farlo con l'utente. sicuro.
‫Quindi, proprio come prima, in pratica ottenendo l'utente,
‫quindi aggiornando le proprietà e quindi, alla
‫fine, salvando il documento.
‫Ma il problema è che ci sono
‫alcuni campi obbligatori che non aggiorniamo e quindi
‫a causa di
‫ciò, si verificherà un errore.
‫E quindi, solo per dimostrartelo rapidamente, lascia
‫che lo faccia davvero.
‫Ok, molto velocemente, portando qui l'utente.
‫Quindi findbyId, quindi richiesta. utente come già sappiamo, . ID.
‫E poi diciamo, utente. name = 'Jonas' e quindi attendere
‫l'utente. Salva.
‫Ma di nuovo vedi che questo ci darà un errore allora.
‫Ma per ora, ovviamente, dichiariamola anche
‫come funzione asincrona.
‫E va bene.
‫Quindi testiamolo ora,
‫ma dovremmo aspettarci di vedere un errore ora.
‫Quindi, ovviamente, liberiamoci di
‫questo, e infatti otteniamo: "Conferma la tua password".
‫E questo perché passwordConfirm è un campo obbligatorio ma
‫ovviamente non lo abbiamo specificato.
‫E quindi il metodo sicuro non è davvero l'opzione
‫corretta in questo caso.
‫Quindi, invece, quello che
‫possiamo fare ora è usare effettivamente findById e update.
‫Quindi non potevamo usarlo prima per tutti i motivi
‫che ti ho spiegato più volte ormai.
‫Ma ora dal momento che non abbiamo
‫a che fare con le password, ma solo con questi dati non
‫sensibili come nome o e-mail, ora possiamo usare findById e update.
‫Quindi, liberiamoci di questo.
‫Chiamiamolo anche qui aggiornatoUser.
‫E poi qui dentro, dobbiamo passare non solo l'ID,
‫ma anche i dati che dovrebbero essere aggiornati,
‫e poi alcune opzioni.
‫Quindi i dati, per ora chiamiamoli x qui, e ti
‫sto dicendo perché in
‫un secondo, e poi le opzioni che vogliamo passare.
‫E quindi è proprio come prima,
‫la nuova opzione impostata su true, in modo che
‫restituisca il nuovo oggetto,
‫quindi fondamentalmente l'oggetto aggiornato invece di quello vecchio.
‫E anche runValidators è impostato su true.
‫Perché in effetti vogliamo che i modelli convalidino il nostro documento.
‫Quindi, ad esempio, se inseriamo un indirizzo email non valido, questo
‫dovrebbe essere rilevato dal Validator e restituire un errore.
‫Ora perché metto x qui e non semplicemente richiesta. corpo?
‫Bene, questo perché in realtà non
‫vogliamo aggiornare tutto ciò che è nel
‫corpo, perché diciamo che l'utente inserisce, nel corpo, il
‫ruolo per esempio.
‫Potremmo avere un corpo. ruolo impostato su admin, ad esempio,
‫e quindi questo consentirebbe a qualsiasi utente
‫di modificare il ruolo, ad esempio, in amministratore.
‫E ovviamente questo non può essere permesso.
‫Oppure l'utente potrebbe anche cambiare il proprio token
‫di ripristino, o quando il token di
‫ripristino scade, e tutto ciò non dovrebbe essere consentito, ovviamente.
‫Quindi fare una cosa del genere
‫sarebbe ovviamente un grosso errore.
‫E quindi dobbiamo assicurarci che l'oggetto
‫che passiamo qui, quindi di
‫nuovo quell'oggetto che conterrà i dati che verranno
‫aggiornati, contenga solo
‫nome ed email, perché per ora questi
‫sono gli unici campi che vogliamo
‫consentire di aggiornare .
‫E quindi fondamentalmente vogliamo filtrare il corpo
‫in modo che alla fine contenga solo nome ed
‫email e nient'altro.
‫Quindi, se l'utente prova a cambiare il ruolo, questo
‫verrà filtrato in modo
‫che non trovi mai la strada per il nostro database.
‫Quindi quello che vogliamo fare è fondamentalmente creare una
‫variabile e
‫diciamo filteredBody, e poi creeremo una funzione in un secondo,
‫ma usiamola già qui, solo così
‫puoi vedere come funzionerà.
‫E poi qui
‫passiamo i dati, quindi l'oggetto che
‫vogliamo filtrare, quindi req. body, perché è lì che si trovano
‫tutti i dati, quindi passiamo un paio di argomenti.
‫Uno per ciascuno dei campi che vogliamo
‫mantenere nell'oggetto.
‫Quindi vogliamo mantenere il campo chiamato nome
‫e il campo chiamato email.
‫E ancora, un po' più tardi potremmo aggiungere più campi
‫qui, ad esempio in seguito potremmo
‫consentire all'utente di caricare un'immagine.
‫E ovviamente dobbiamo anche aggiornare
‫il database.
‫Ma per ora, tutto ciò
‫che vogliamo tenere nel corpo è nome ed e-mail e filtrare tutto il resto.
‫E quindi qui, ora usiamo filteredBody,
‫invece di x ovviamente.
‫E quindi ora ciò che dobbiamo fare
‫è implementare effettivamente questa funzione che si occuperà di filtrare l'oggetto.
‫Quindi facciamolo qui.
‫FilterObj,
‫che prenderà un oggetto e quindi
‫i restanti parametri per tutti i campi consentiti.
‫E quindi questo creerà fondamentalmente
‫un array contenente tutti gli argomenti che abbiamo passato.
‫Quindi in pratica sono stati passati dopo questo primo.
‫Quindi, in tal caso, è un array contenente nome ed e-mail.
‫Quindi quello che dobbiamo
‫fare ora è fondamentalmente scorrere l'oggetto e per ogni elemento controlla
‫se è uno dei campi
‫consentiti, e se lo è, aggiungilo semplicemente a un
‫nuovo oggetto, che alla fine torneremo .
‫E probabilmente ci sono modi più efficienti o
‫migliori per implementarlo,
‫ma facciamolo molto velocemente qui.
‫Quindi eseguiremo il
‫loop dell'oggetto dicendo Object. chiavi dell'oggetto che passiamo.
‫Quindi questo è uno dei modi più semplici per
‫scorrere un oggetto in JavaScript.
‫Quindi, questo qui restituisce sostanzialmente un array contenente tutti
‫i nomi delle chiavi,
‫quindi i nomi dei campi di questo
‫oggetto, e quindi possiamo scorrerli.
‫Quindi la nostra funzione di callback.
‫E per ogni elemento, questo è quello che faremo.
‫Quindi, se l'array di campi consentito include l'elemento
‫corrente, quindi il nome del campo corrente, allora vogliamo aggiungerlo
‫a un nuovo oggetto.
‫Quindi creiamolo rapidamente qui,
‫quindi const newObj che è vuoto
‫per ora, e
‫alla fine è quello che restituiremo.
‫Quindi nuovoOggetto.
‫Quindi, se il campo corrente è uno dei
‫campi consentiti, allora newObj con il nome del campo corrente, dovrebbe essere
‫uguale a qualunque cosa sia nell'oggetto nell'elemento corrente, quindi
‫il nome del campo corrente.
‫Quindi non se questo sembra un po
‫'confuso, questo è di nuovo solo JavaScript
‫standard, non ha nulla a che fare con JS o eXpress o
‫qualcosa del genere.
‫Quindi, di nuovo, tutto ciò che facciamo qui è
‫fondamentalmente scorrere tutti i campi che sono nell'oggetto e
‫quindi per ogni campo,
‫controlliamo se è uno dei campi consentiti.
‫E se lo è, allora creiamo un nuovo campo nel nuovo
‫oggetto, ovviamente con
‫lo stesso nome, quindi ancora name element, con lo
‫stesso identico valore che ha nell'oggetto originale.
‫E poi alla fine, ovviamente, restituiamo quello.
‫E quindi ora dovrebbe funzionare tutto qui.
‫Quindi tutto ciò che dobbiamo
‫fare alla fine è inviare l'utente aggiornato al client.
‫Quindi, utente.
‫Ora, ovviamente, dobbiamo mettere udatedUser qui, salvarlo di
‫nuovo e quindi ora dovrebbe funzionare.
‫Se davvero quello che abbiamo fatto qui è stato..
‫aggiorna l'utente per ultimo
‫e, prima di farlo, abbiamo effettivamente filtrato i nomi
‫dei campi indesiderati che non possono essere aggiornati.
‫Quindi proviamolo ora.
‫E questo utente qui è un utente normale, quindi lo abbiamo
‫appena creato, ricorda
‫con il nome di J.
‫E quindi diamo rapidamente un'occhiata a Compass.
‫Quindi è un utente normale, con un nome di J.
‫E quindi ora aggiorniamo
‫il nome e proviamo anche ad aggiornare il
‫ruolo, che di nuovo non è consentito.
‫Ma per vedere se il nostro codice funziona, proviamolo.
‫Quindi c'è già il nome, e diciamo che siamo
‫un utente malintenzionato
‫che cerca di cambiare il nostro ruolo in amministratore.
‫Quindi, immagino che sia tutto
‫corretto, quindi inviamo questo
‫ora, e infatti ecco il nostro oggetto aggiornato.
‫Quindi otteniamo il nostro nuovo nome, che è Jonas Schmedtmann,
‫e poi il ruolo, che è ancora utente.
‫Non ha aggiornato il ruolo in admin.
‫Perfetto. È esattamente quello che volevamo.
‫Quindi, salva questo e torniamo indietro e in realtà
‫con questo abbiamo appena finito questo video.
‫Successivamente, implementeremo una funzionalità per
‫eliminare l'utente corrente.
‫Quindi abbiamo lavorato sull'aggiornamento, quindi vogliamo consentire a un utente
‫di cancellarsi praticamente da solo quando non vuole più
‫far parte della nostra applicazione.