‫Istruttore: Va bene, quindi ora creiamo
‫quei nuovi utenti, in base al modello che
‫abbiamo appena implementato nell'ultimo video.
‫Quindi, faremo la maggior parte delle cose relative all'utente
‫come la creazione di nuovi utenti, l'accesso
‫degli utenti o l'aggiornamento delle password nel controller di autenticazione.
‫Quindi tutto ciò che è realmente correlato all'autenticazione, non
‫sarà nel controller utente che abbiamo
‫effettivamente creato prima,
‫ma invece creeremo un controller di autenticazione.
‫Quindi tutte le
‫funzioni relative all'autenticazione andranno qui.
‫E questo avrà un po' più senso in
‫seguito, quando inizieremo a usare tutte le
‫funzioni che inserirò qui.
‫E ora, la prima cosa
‫che dobbiamo fare è importare il
‫nostro utente, quindi il nostro modello utente ovviamente,
‫e questo è a un livello superiore, quindi dovrebbe essere in modelli e
‫poi in userModel.
‫Tutto bene.
‫Quindi, creiamo ed esportiamo il nostro primissimo controller.
‫E chiamerò questa registrazione.
‫E così vedi che non lo chiamo creare utente,
‫come ho fatto in un
‫tour controller, ma in realtà lo chiamo
‫registrazione perché è il nome che ha un
‫po' più di significato nel contesto dell'autenticazione.
‫Quindi sarà ovviamente una funzione asincrona, perché
‫faremo alcune operazioni sul database.
‫Quindi richiedi, rispondi e poi come
‫sempre, e poi qui è dove creiamo il nuovo utente.
‫E quindi è molto simile a quello che abbiamo fatto prima.
‫Quindi questa volta si chiama newUser,
‫quindi ricorda come
‫creiamo un nuovo documento basato su un modello.
‫Quindi usiamo ovviamente il nome del
‫modello, che in questo caso è Utente, e
‫quindi su quello usiamo il metodo di creazione.
‫E poi tutto ciò
‫che dobbiamo fare è passare un oggetto con
‫i dati da cui dovrebbe essere creato l'utente.
‫E così, proprio come prima, quei dati sono effettivamente richiesti. corpo.
‫E quindi tutto questo restituirà una
‫promessa, quindi dobbiamo aspettarlo, e quindi questo è
‫il motivo per cui questa è una funzione asincrona.
‫E vedo che quassù abbiamo bisogno di esportazioni.
‫E ora, nel passaggio
‫successivo, invieremo effettivamente quel newUser al client.
‫Quindi ris. status, che è 201 per creato, e quindi
‫il nostro oggetto JSON.
‫Quindi questo è di nuovo
‫successo, e poi la nostra proprietà dei dati che
‫è di nuovo
‫chiamata busta qui, quindi una proprietà che conterrà i dati stessi.
‫E i dati ora si chiamano
‫user, quando prima si
‫chiamavano tour, quindi quello che invieremo qui è newUser.
‫Dagli un salvataggio e prima di
‫provarlo, ricorda che questa è una funzione asincrona,
‫quindi dobbiamo pensare alla gestione degli errori qui.
‫Allora cosa dobbiamo fare qui?
‫Bene, dobbiamo racchiudere l'intera funzione che
‫abbiamo appena creato nella funzione catchAsync che abbiamo
‫creato nell'ultima sezione.
‫Quindi ricorda come lo abbiamo fatto nel tourController, dove tutte
‫le funzioni asincrone sono racchiuse
‫in questa funzione catchAsync in modo da
‫non dover
‫scrivere il blocco try catch in ogni funzione qui.
‫Ricordi quello dell'ultima sezione?
‫Quindi in realtà vado
‫avanti e copio questa dichiarazione require qui.
‫Quindi un po' pigro
‫a volte, non mi va di scrivere lo
‫stesso codice più e più volte, quindi catchAsync, e
‫poi dobbiamo chiuderlo proprio qui alla fine.
‫E ora, tutto ciò
‫che dobbiamo fare è implementare effettivamente il percorso
‫in modo che questo gestore di registrazione qui possa essere chiamato.
‫E quindi andiamo al nostro
‫userRoutes, che in realtà abbiamo già creato qualche tempo prima,
‫e abbiamo già alcune rotte qui.
‫Ma in realtà ne creerò uno nuovo qui adesso.
‫E come ho detto proprio all'inizio di questo video, la
‫risorsa utente è un po' diversa da
‫tutte le altre risorse.
‫Di nuovo, perché ha davvero a che fare
‫con tutto ciò che riguarda l'autenticazione.
‫E quindi abbiamo un controller diverso
‫per quello, quindi anche authController, i nomi delle funzioni
‫hanno nomi diversi,
‫e quindi avremo anche un percorso speciale.
‫Diciamo router. post, quindi creeremo
‫un percorso per l'iscrizione, quindi /signup, ed è qui
‫che utilizzeremo quella funzione
‫che abbiamo appena creato prima.
‫E ovviamente prima
‫di poterlo fare, dobbiamo richiedere quel controller di autenticazione.
‫Quindi duplichiamo questa riga qui
‫e sostituiamo user in due posti, quindi qui abbiamo il
‫nostro authController, e quindi
‫usiamolo. Iscriviti.
‫Quindi, come
‫vedi, la registrazione è davvero una specie di endpoint speciale.
‫Non si adatta all'architettura REST di
‫cui abbiamo parlato prima, perché in questo caso
‫non ha molto senso.
‫E quindi ricorda come abbiamo detto che
‫in alcuni casi speciali,
‫possiamo ovviamente creare altri endpoint che non
‫si adattano al 100% alla filosofia REST che è sostanzialmente implementata qui.
‫Quindi questo qui ovviamente segue
‫al 100% la filosofia REST, in cui il nome dell'URL non ha nulla
‫a che fare con l'azione che viene effettivamente eseguita.
‫Mentre quassù, ovviamente, lo ha fatto.
‫Quindi il nome del percorso è
‫iscrizione perché stiamo iscrivendo utenti.
‫E anche quaggiù abbiamo implementato tutti questi
‫diversi warp HTTP ma qui
‫per l'iscrizione, abbiamo davvero solo bisogno di POST.
‫Quindi non possiamo davvero ottenere dati dalla registrazione, o
‫non possiamo patchare una registrazione, quindi non aggiornarla.
‫Non ha molto senso, quindi in questo caso tutto ciò
‫che vogliamo fare
‫è avere un percorso per l'iscrizione,
‫dove possiamo solo POSTARE i dati.
‫Perché, ancora una volta, ha senso
‫solo inviare effettivamente i dati a questo percorso,
‫in modo che venga quindi creato il nuovo utente.
‫E avremo percorsi diversi simili a questo, come
‫per l'accesso o per reimpostare
‫la password e ogni genere di cose del genere.
‫E manterremo anche questi percorsi
‫qui quindi quelli in un formato più REST,
‫perché c'è anche la possibilità che un amministratore
‫di sistema aggiorni o cancelli o
‫ottenga tutti gli utenti in base al loro ID.
‫Ma di questo ci occuperemo in seguito, per ora
‫vogliamo solo implementare tutte le funzioni
‫che riguardano l'autenticazione.
‫Quindi fondamentalmente funzioni che sono rilevanti solo
‫per l'utente stesso.
‫Quindi non è un amministratore che iscriverà un
‫utente, o non è un amministratore che accederà a
‫un utente, ma invece, è il
‫proprio utente che si iscriverà o accederà da solo.
‫Ok, ha senso?
‫Quindi dovremmo avere tutto a posto
‫ora, in modo che ora funzioni quando creiamo il nostro nuovo utente.
‫Quindi, quando ci iscriviamo fondamentalmente, per la nostra applicazione.
‫Quindi proviamolo ora.
‫Copiamo semplicemente questo URL,
‫gli utenti e quindi iscriviti.
‫Quindi dobbiamo specificare il
‫corpo, diciamo raw, e quindi JSON.
‫Oh e anche, ovviamente, non dimenticare di impostare questo
‫su POST.
‫Quindi, di quali dati abbiamo bisogno qui?
‫Ricorda, il primo è
‫il nome, poi l'e-mail, e
‫in realtà metto il mio qui, poi la password, e quindi
‫facciamo qualcosa qui, non importa davvero.
‫E ancora, parleremo della gestione delle password
‫un po' più
‫tardi, e proprio nel prossimo video.
‫Quindi ora questo qui dovrebbe essere lo stesso.
‫Quindi pass1234, solo come test.
‫E il ricordo della foto non è
‫obbligatorio, quindi non lo farò.
‫E quindi vediamo ora.
‫E ora riceviamo questo errore
‫qui, ed è perché ho sbagliato a scrivere la password qui.
‫Ok, questo sarebbe il modo tedesco di scriverlo.
‫E ora è giusto.
‫Ok, e in effetti qui abbiamo il nostro nuovo utente.
‫Perfetto.
‫Ora diciamo che abbiamo provato a farlo con un GET.
‫Cosa otterremmo?
‫Bene, "Questo
‫percorso non è ancora definito",
‫perché in realtà abbiamo già
‫definito questo percorso qui, quindi in pratica questa
‫parte qui del percorso, quindi lascia
‫che te lo mostri rapidamente, quindi non
‫è nel tourController, ma in il controller utente.
‫Quindi fondamentalmente abbiamo getUser qui e
‫poi "Questo percorso non è ancora definito. "Quindi è quello che stiamo ottenendo,
‫ma ovviamente
‫non ci interessa molto.
‫E ora andiamo avanti e salviamo questo qui, su
‫Postman in modo che possiamo riutilizzarlo facilmente.
‫Quindi registrati.
‫E ora
‫solo per confermare velocemente, apriamolo anche
‫in Compass qui, e vediamo che a questo punto
‫abbiamo solo tour, quindi andiamo qui ai natours, proviamo
‫a ricaricare questo, e probabilmente è qui sopra, e quindi infatti, ora otteniamo la
‫nostra raccolta di utenti qui.
‫Quindi apriamolo e, in effetti, ora otteniamo il
‫nostro primo documento qui.
‫Quindi l'utente che abbiamo appena creato.
‫Ora qui puoi vedere la
‫semplice password, e quindi ovviamente non è l'ideale.
‫E, naturalmente, questo non è l'ideale, quindi in
‫un'applicazione web, le password
‫non dovrebbero mai essere archiviate in modo semplice in un database.
‫Quindi c'è molta gestione delle password che deve
‫avvenire dietro le quinte, ed è esattamente ciò che
‫faremo nel prossimo video.