È il momento di iniziare il quarto e l'assegnazione finale di questo corso.
Ho progettato questo incarico per essere un consolidamento
di tutto ciò che hai imparato in questo corso.
Quindi questa assegnazione comporterà il routing utilizzando il router espresso.
Implicherà la progettazione di schemi nel modello,
per i nostri MongoDB e Mongoose,
e poi guarderà brevemente all'autenticazione dell'utente.
Cosa facciamo esattamente in questo incarico?
Questa assegnazione si basa sulla possibilità per un utente
di salvare e recuperare un elenco di piatti come piatti preferiti sul lato server.
Se avessi seguito i corsi precedenti di questa specializzazione, in
particolare i corsi di sviluppo di app mobili ibridi, che
si tratti di script ionico o nativo,
hai visto che abbiamo progettato le app per avere la capacità di
consentire all'utente di salvare piatti nella lista dei loro preferiti piatti
e anche recuperare i piatti da quella lista dei loro piatti preferiti.
Quando abbiamo implementato che nei corsi precedenti,
avevamo implementato che utilizzando lo storage locale sul dispositivo specifico.
In questo compito, estenderai
il lato server per essere in grado di supportare esattamente questo.
In questo modo, l'utente può salvare il proprio elenco di piatti preferiti
sul lato server e accedere a questo elenco da
qualsiasi dispositivo da cui accederanno al proprio server.
Ciò significa che abbiamo bisogno di progettare un nuovo percorso per il nostro server,
che chiameremo come il/favorites route.
Su questo percorso, dovremo progettare il router espresso per supportare le
operazioni get, post ed delete su questo percorso e
anche progettare lo schema per memorizzare i piatti preferiti
e il modello Mangusta corrispondente e
collegare i due insieme in modo che le informazioni possano essere salvate e recuperato da MongoDB.
Useremo anche la popolazione Mangusta al fine di trarre le informazioni dal
modello utente e dal modello di piatti quando mettiamo
insieme quell'elenco di piatti preferiti per il nostro utente.
Le informazioni sui piatti preferiti che memorizzi
in realtà non conterranno né le informazioni dell'utente né le informazioni del piatto.
Invece, esso conterrà puntatori ai documenti per il documento piatto e per
il documento utente e poi pubblicheremo queste informazioni
quando stiamo inviando indietro queste informazioni in risposta a una richiesta get.
Diamo un'occhiata a come implementiamo
questo compito finale e anche le varie attività in questo compito finale.
Per aiutarti a capire cosa è richiesto
nell'assegnazione finale o cosa implementerai nell'assegnazione finale,
fammi dimostrare cosa dovrebbe fare il tuo server alla fine di questa assegnazione,
e quindi elencherò le tre attività che devi eseguire in questo assegnazione.
Per iniziare, abbiamo bisogno di una serie di piatti già sul
lato server in modo che l'utente possa contrassegnare alcuni di loro come i loro piatti preferiti.
Sono andato avanti e ho aggiunto in quattro piatti alla mia lista di piatti sul lato server.
Sai già come farlo.
Devi accedere come amministratore e poi pubblicare
queste informazioni piatto sul lato server uno per uno.
Per consentire di ottenere le informazioni per ciascuno di questi piatti,
ti ho già fornito il file db.json che contiene
i documenti JSON corrispondenti a ciascuno di questi piatti nelle risorse di assegnazione.
È possibile aprire, tagliare e incollare le informazioni da lì e quindi
creare un elenco di piatti sul lato server.
Qui, vedrai che ho già eseguito l'operazione get sul
localhost: 3000/piatti e poi
vedrai che ho già ottenuto l'elenco dei piatti qui.
Ciò che è importante per noi notare è che ogni piatto avrà il proprio ID piatto qui.
Quando è necessario contrassegnare qualsiasi piatto come preferito,
è necessario accedere all'ID piatto per ciascuno di questi piatti.
È possibile copiare questi quattro ID piatti e poi salvarli in modo che quando si
eseguono le operazioni per aggiungere questi piatti all'elenco dei piatti,
allora si sarà in grado di utilizzare questo ID piatto.
Quindi ho intenzione di copiare questi quattro ID piatto e poi
salvarli in un documento di testo in modo che io possa farne uso.
Prima di poter aggiungere piatti alla mia lista di piatti,
ovviamente ho bisogno di accedere come utente.
Lasciatemi andare avanti e accedere come uno degli utenti.
Per fare ciò, lasciami fare un post sul localhost: 3000/utenti/login.
E nel corpo del messaggio,
lasciami digitare uno degli utenti registrati.
Non voglio accedere come amministratore ma come uno degli altri utenti normali.
Quindi lasciami fare questo post su https://localhost:3443.
Ora tutte queste operazioni,
questo è meglio farlo sull'endpoint HTTPS piuttosto che sull'endpoint HTTP.
Faremo un post a questo endpoint e accederemo al nostro servizio
e, in risposta, dovresti essere in grado di entrare in possesso del token web JSON.
Quindi facciamo una copia di questo token web JSON perché avremo bisogno di questo per
eseguire una qualsiasi delle operazioni per aggiungere piatti al nostro elenco di preferiti.
Permettetemi di copiare questo token e salvarlo nel mio documento di testo.
Ora, come posso aggiungere un piatto alla mia lista di preferiti?
Per fare ciò, il primo passo è che dobbiamo
accedere all'endpoint /favorites.
Se vuoi aggiungere un piatto specifico all'elenco dei preferiti,
diciamo semplicemente /favorites e poi aggiungiamo l'ID del piatto nell'URL qui.
Lasciami incollare in un ID piatto che voglio aggiungere alla mia lista di preferiti.
Qui, ho incollato nel mio ID piatto alla lista dei preferiti.
Il corpo di questo messaggio host
non conterrà nulla perché tutto ciò di cui ho bisogno è già nell'URL.
E per l'intestazione,
ho bisogno di impostare l'intestazione di autorizzazione,
e nell'intestazione di autorizzazione,
ho bisogno del token.
Quindi lasciami copiare il token qui e poi nell'intestazione di autorizzazione,
diciamo portatore e incolla nell'intestazione di autorizzazione.
Puoi anche fare la stessa cosa per ottenere il token.
Puoi anche eseguire il login tramite Facebook e quindi ottenere il token web JSON.
Ho illustrato di ottenere il token web JSON utilizzando
l'autenticazione locale standard utilizzando il nome utente e la password,
ma non importa in che modo hai ottenuto il token web JSON.
Finché si dispone del token web JSON,
si dovrebbe essere in grado di eseguire tutte queste operazioni.
Permettetemi di eseguire l'operazione post su questo endpoint e ricordare che questo
è l'ID piatto per il piatto specifico che voglio aggiungere alla mia lista di preferiti.
Quando pubblico l'elenco dei preferiti,
vedrai che il mio server risponderà con questo documento qui nel corpo della risposta.
Ora, esaminiamo questo documento per vedere cosa contiene esattamente.
Questo documento, come puoi vedere, contiene un ID,
ma ovviamente perché questo è un documento JSON,
inoltre contiene un
campo qui chiamato utente.
Ora cosa memorizza questo campo utente?
Questo campo utente è l'ID oggetto dell'utente
corrispondente al quale si trova questo particolare elenco di preferiti.
E guarda i piatti.
I piatti sono una matrice ed è una serie di ID piatto.
E in questo caso, ho appena aggiunto il primo piatto alla mia lista di preferiti.
Quindi, è per questo che ho solo un piatto nella gamma di piatti nella mia lista di preferiti.
Quindi, questo dovrebbe suggerirti immediatamente come progettare lo schema per i tuoi preferiti.
Quindi, piatti contiene gli ID oggetto di ciascuno dei piatti
e l'utente contiene l'ID oggetto corrispondente all'utente.
Avete già visto come uso
le informazioni per fare popolazione delle informazioni quando faccio un'operazione get.
Lo abbiamo già fatto con commenti.
Quindi, questo dovrebbe darti un grande suggerimento su come progettare lo schema che contiene
l'utente e l'array di piatti nella mia lista di piatti qui.
Ora, abbiamo fatto il post su questo.
Otteniamo la lista dei preferiti.
Quindi, per ottenere l'elenco dei preferiti,
ho bisogno di eseguire un'operazione get.
Ora, per l'operazione get,
ovviamente ho bisogno di avere anche le informazioni di autorizzazione qui perché
vuoi che un utente sia in grado di recuperare solo il loro elenco di preferiti
e nessun altro utente può recuperare l'elenco dei preferiti per un utente diverso.
Quindi, questo è molto importante.
Quindi, questo ti suggerisce che è necessario
verificare l'autenticità dell'utente anche per l'operazione get.
Ora, in che modo la post-operazione
ottiene automaticamente questo ID oggetto corrispondente all'utente?
Ricorda che quando includi l'intestazione di autorizzazione qui,
dall'intestazione di autorizzazione,
dal modo in cui esegui l'autorizzazione dell'utente,
indirizza le proprietà utente già caricate sull'oggetto richiesta.
E così è lì che si otterrà l'accesso all'ID oggetto dell'utente.
Quindi, un altro suggerimento su come riempirai queste informazioni.
Quindi, questo è il motivo per cui notare che quando ho eseguito il post,
non ho mai specificato l'utente perché
le informazioni dell'utente dovrebbero essere automaticamente
derivate da ciò che abbiamo fornito qui nell'intestazione di autorizzazione.
Quindi, un altro suggerimento su come andresti a implementare questo.
Quindi, è per questo che ho detto che questo incarico è un consolidamento
di tutti gli argomenti che avete esplorato in questo corso.
Ora, non sostengo un'operazione get su un ID piatto specifico.
Non ha senso sostenerlo sui preferiti,
in un ID piatto specifico.
Invece, siamo in grado di eseguire un'operazione get su host locale 3443/preferiti.
E poi eseguiamo l'operazione get.
Si noterà immediatamente che il documento restituito contiene
le informazioni dell'utente già popolate dall'operazione get qui.
Quindi, le informazioni dell'utente.
Quindi, invece dell'ID utente lì,
le informazioni dell'utente sono già presenti in lì.
Questo viene fatto attraverso la popolazione di Mongo.
Quindi, questo è un altro grande suggerimento su come dovresti implementare l'operazione get.
Non solo le informazioni dell'utente sono compilate.
Ora perché dovrei volere che le informazioni dell'utente siano compilate?
Perché potrebbe essere utile quando visualizzo informazioni.
Questo potrebbe non essere necessario,
ma lo sto facendo solo per motivi di completezza
perché se stai recuperando l'elenco dei preferiti per un particolare utente,
sai automaticamente chi è l'utente
e quel particolare utente sta accedendo comunque.
Ma nel caso in cui si desidera che le informazioni dell'utente, è
possibile eseguire questa operazione per entrare in possesso delle informazioni dell'utente.
Quindi, solo per illustrarvi che la popolazione di Mongo può essere utilizzata,
ho illustrato non solo che nella lista dei piatti qui,
le informazioni su ogni piatto sono già popolate in questa matrice.
Quindi, se hai un sacco di piatti,
le informazioni di ciascuno di questi piatti dovrebbero essere popolate in questa matrice.
Quindi, questo è un altro uso della popolazione di Mongo
che si sta vedendo per riempire le informazioni sui piatti.
Proprio dal modo in cui imposti lo schema per i tuoi preferiti,
questo dovrebbe essere automaticamente possibile per te usando
solo il punto popolare nell'elenco dei piatti qui.
Quindi, questa è la seconda parte.
Ora che siamo in grado di recuperare il metodo get dish,
lascia che ti mostri come puoi eseguire un'operazione post in cui puoi
aggiungere un sacco di piatti nella tua lista di preferiti.
Ora, tornando a questo post,
se hai bisogno di aggiungere non solo uno ma un set di piatti alla tua lista di preferiti,
ora perché vorresti questo?
Forse dal lato del cliente potresti avere un pulsante che, quando
cliccato, ti permetterà di selezionare un set di piatti dall'elenco dei piatti,
e quindi aggiungerli in un colpo solo nella tua lista dei preferiti.
Quindi, per supportare questo tipo di operazione,
potresti voler consentire che un post venga eseguito sui preferiti della barra qui.
Ora, quando il post viene eseguito sui preferiti della barra, di nuovo,
avrai ancora bisogno dell'intestazione di autorizzazione.
Ma nel corpo del messaggio,
stiamo andando a memorizzare l'elenco dei piatti come una matrice di questo formato.
Quindi, questo è un documento JSON qui,
quindi lasciami fare in modo che nella mia intestazione,
il tipo di contenuto sia già presente lì.
Ora, questo documento
conterrà una serie di piatti come questo.
Quindi, ogni piatto sarà identificato
dicendo punti di sottolineatura ID,
e poi qui avranno l'ID piatto,
e quindi questo non sarebbe altro che una serie di piatti.
Quindi, lasciatemi aggiungere due piatti alla mia lista di preferiti qui solo per illustrare il punto.
Quindi, lasciami incollare gli ID di un paio di piatti in questo.
Quindi, quando si esegue un post sull'host locale 3443/preferiti,
questo è il modo in cui si compone il corpo del messaggio post qui.
Quindi, ogni piatto che vuoi aggiungere sarà incluso in questo formato qui.
Ora, quando li includi in questo formato,
e poi pubblichi su quel lato server,
il server in cambio invierà indietro l'elenco aggiornato dei preferiti per te.
Quindi, quando si riceve l'elenco aggiornato dei preferiti dal lato server,
si vedrà che le informazioni dell'utente sono già lì,
ma si noti come i piatti preferiti sono memorizzati in questa matrice di ID oggetto piatto.
Quindi, il primo che avevamo già aggiunto nell'operazione precedente.
Così i restanti due,
abbiamo appena aggiunto alla lista dei nostri preferiti.
Quindi, questi due ID oggetto vengono aggiunti anche nel
mio array di piatti nel mio documento preferito qui.
Allora, ecco a te. Quindi, questo è il modo in cui dovresti eseguire
il post dei preferiti sull'endpoint in questo modo.
Ora, cerchiamo di nuovo eseguire un'operazione get
sui preferiti solo per vedere ciò che le caratteristiche di operazione get per noi.
Quindi, quando eseguiamo l'operazione GET,
noterai immediatamente che nel documento dei preferiti di ritorno,
hai le informazioni dell'utente lì,
e poi giù qui sotto,
i piatti non sono altro che una serie di documenti Json qui,
ognuno corrispondente a un piatto.
Ora questo viene automaticamente curato dalla mangusta
popolata che abbiamo fatto sul lato server.
Quindi tutte queste informazioni dovrebbero essere popolate automaticamente sul lato server.
Quindi è così che funzionano le operazioni di post sui due endpoint.
Ora lascia che ti mostri come eseguiresti un'operazione DELETE.
Ora per cancellare un piatto specifico.
Quindi lasciami eseguire un'operazione di eliminazione su un endpoint specifico.
Quindi torneremo a questo endpoint,
e poi lasciatemi copiare uno di questi,
e poi cancellerò uno dei piatti.
Quindi, per eseguire l'operazione di eliminazione su uno
dei piatti, ovviamente, come vedi,
non abbiamo ancora bisogno del corpo,
e non abbiamo bisogno del contenuto qui.
Tutto quello che dobbiamo fare è eseguire un'operazione di eliminazione su questo endpoint.
Quindi qui vedi che sto facendo localhost: 3443/favoriti/ e poi l'ID del piatto.
E poi lasciami postare questo.
Quindi, quando elimino un piatto specifico dal mio elenco di preferiti,
noti immediatamente che
il mio elenco aggiornato dei preferiti viene inviato al lato client dal server.
Quindi hai l'utente qui,
ma nota che nell'array di piatti ho solo due piatti ora.
Quello che ho appena cancellato è sparito da quella lista di piatti.
Quindi, se esegui un GET ora,
il tuo array di piatti continuerà a piatti lì dentro.
Ora, supponiamo di eseguire un DELETE sui preferiti qui.
Quindi, se eseguo DELETE direttamente sull'endpoint preferito,
allora quello che sta per fare è eliminare tutti i miei preferiti e
anche eliminare completamente il mio documento preferito dal lato server.
Quindi lasciami eseguire quell'operazione di eliminazione sul lato server,
e quindi restituirà il fatto che ha eliminato questo particolare documento,
quindi restituisce comunque questo documento.
Ma ora se eseguo un'operazione GET sul mio elenco di preferiti,
recupererò un null lì.
Significato che non ho questo documento sul lato server.
Quindi il documento dei preferiti è completamente sparito,
quando eseguo l'operazione DELETE sulla colonna host locale tre dai preferiti precedentemente slash.
Ora di nuovo, quando aggiungo un nuovo piatto alla
mia lista di preferiti, il mio documento preferito verrà nuovamente impostato.
Va benissimo per noi operare.
Quindi con questa dimostrazione ti ho mostrato
tutte le varie operazioni che devi eseguire sul lato server.
Tutte le varie operazioni sui vari endpoint di route
che è necessario eseguire o implementare sul lato server.
Ora che hai visto
tutte le varie operazioni che il lato server dovrebbe supportare sui preferiti della barra
e i preferiti della
barra, gli endpoint dell'ID del piatto della barra,
fammi elencare le tre attività che devi completare in questo compito.
Il primo compito, ovviamente, è quello di implementare lo schema e il modello preferiti.
Questo implementerai nella cartella dei modelli in un file chiamato NodeJS preferito.
Lì implementerai lo schema preferito.
Ricordare che lo schema preferito memorizzerà
il riferimento all'ID oggetto documento dell'utente
e una matrice di piatti ID oggetto documento.
Questo è il grande suggerimento su come dovresti
progettare lo schema e il modello per i tuoi preferiti.
La seconda attività dell'assegnazione consiste nell'implementare le
operazioni GET, POST e DELETE sull'endpoint dei preferiti della barra.
GET ti porterà tutta la lista dei preferiti,
popolata automaticamente dal popolamento di Mongo,
il POST dovrebbe contenere un elenco di piatti come specificato
nel formato che ti ho appena dimostrato nel corpo del messaggio POST.
E così un sacco di piatti verrà aggiunto nel tuo elenco di preferiti,
e l'operazione DELETE sull'endpoint dei preferiti barra
eliminerà completamente il documento preferito dal lato server.
Ora, se esegui un'operazione POST sull'ID piatto barra preferita,
allora il piatto particolare verrà aggiunto al tuo elenco di preferiti.
Se il tuo documento preferito non esiste,
ovviamente devi creare quel documento preferito.
Quindi questo è anche parte di quell'operazione POST.
Quindi, se in qualsiasi momento si scopre che il documento preferito non esiste,
è necessario prima creare il documento preferito e
quindi aggiungere questo piatto nel documento preferito.
Quindi questo è un punto importante anche da notare.
Quando si esegue un POST sull'endpoint dei preferiti della barra,
se il documento preferito non esiste,
è necessario creare un documento preferito e quindi aggiungere i piatti al documento preferito.
Se esiste già,
aggiorni solo quel documento preferito.
Quindi questo è un altro suggerimento su come dovresti implementare le operazioni POST.
Se si esegue un'operazione DELETE sull'ID della barra dei preferiti della barra,
il piatto specifico verrà eliminato dall'elenco dei preferiti.
Ora nell'esecuzione delle operazioni POST e DELETE,
dovresti assicurarti di non aggiungere duplicati all'ID del piatto.
Quindi, prima di aggiungere un ID oggetto piatto all'elenco dei piatti,
controlla sempre se l'ID del piatto esiste già nell'elenco dei piatti.
Ora questo è dove è possibile utilizzare il metodo array indexOf per verificare
se un ID documento esiste già in una matrice di documenti.
Quindi questo è un altro grande suggerimento su come implementerai quella parte.
E il terzo compito, naturalmente, è quello di montare
il router preferito sugli endpoint preferiti barra aggiornando il file app.js.
Il router preferito stesso sarà implementato
nella cartella route nel file favoriterouter.js.
Quindi con questo ho descritto cosa
dovresti implementare nel quarto e ultimo incarico.
E spero che questo incarico ti aiuti
a consolidare tutto ciò che hai imparato nel corso,
dalla progettazione di router express,
al fare MongoDB e anche allo schema e ai modelli di Mongo,
e anche all'esecuzione dell'autenticazione utente appropriata.
E come ho già detto,
solo un utente autenticato avrà accesso al suo elenco di preferiti.
Anche l'operazione GET può essere eseguita solo da
un utente autenticato sull'endpoint dei preferiti della barra.
E dovresti solo recuperare i preferiti per quel particolare utente.
Non è possibile consentire a un utente diverso di accedere ai preferiti di un altro utente.
Quindi, ancora una volta, questo ti dice anche come dovresti eseguire
l'autenticazione sui diversi endpoint del percorso.
Con questo completo la descrizione delle attività nel quarto incarico.
Divertiti a completare questo incarico.