La seconda parte di questo esercizio riguarda
le varie operazioni get put post ed eliminazione sui documenti secondari all'interno del documento.
Come abbiamo visto nell'esempio per i piatti,
abbiamo visto che i commenti sono inclusi all'interno del piatto stesso come sottodocumento,
nel modo in cui abbiamo definito sia lo schema dei commenti che lo schema dei piatti,
e quindi definire il modello del piatto includendo lo schema dei commenti
nello schema del piatto come una matrice di commenti.
E abbiamo visto nell'esercizio precedente come i commenti sono racchiusi all'interno di
un array sotto forma di un array di documenti all'interno di ogni documento piatto.
Quindi, come possiamo apportare modifiche ai commenti stessi?
Come otteniamo tutta la lista dei commenti per un piatto?
Come modifichiamo un commento specifico nel piatto e così via?
Quindi questo è quello che vedremo su come
supportarli utilizzando i vari get put post ed eliminare le operazioni sui
piatti piatti piatto barra ID barra commenti e i piatti
slash piatto ID slash commenti barra commento ID endpoint API REST.
Per iniziare a questo esercizio, di
nuovo, tornando al router piatto,
hanno già visto come gestiamo l'endpoint barra e l'endpoint ID piatto barra.
Ora, gran parte di questo lavoro che facciamo qui è già utile per noi,
quindi quello che ho intenzione di fare è copiare questo codice,
e poi modificheremo quel codice in modo appropriato per gestire i commenti e l'ID commento.
Quindi ho intenzione di copiare l'intero codice che abbiamo
qui sia per la barra che per l'ID piatto dorato barra,
e poi lo incolleremo di nuovo qui sotto.
E poi entreremo e modificheremo ognuno di loro.
Quindi abbiamo visto che se si guarda indietro,
il primo sta gestendo la barra che verrà montata sull'endpoint piatti barra.
E il prossimo è gestire l'ID piatto barra.
Quindi il terzo dovrebbe gestire i commenti della barra dell'ID del piatto.
Quindi, andando quaggiù,
questo percorso del router del terzo piatto sarebbe quello dei commenti della barra dell'ID del piatto.
E poi l'ultimo, ovviamente,
sarebbe slash dish ID slash
commenti e poi tagliare l'ID commento dei due punti.
Quindi, ora che abbiamo aggiornato questi percorsi qui,
ora il passo successivo è quello di entrare e correggere
il codice nel post get put ed eliminare le operazioni qui.
Quindi inizieremo con il piatto barra ID barra commenti endpoint.
Quindi, in caso di barra piatto ID barra commenti endpoint,
così faremo piatti trovare ma invece di dire piatti trovare,
faremo piatti trovare, faremo piatti trovare per
ID e così troveremo il piatto specifico che stiamo cercando.
Quindi qui, cercheremo che req params Dish ID,
quindi cercheremo prima il piatto,
e così questo restituirà un piatto specifico.
Quindi, quando restituisce quel piatto specifico qui,
allora quello che controlleranno qui dentro
è che se il piatto non è uguale a null.
È del tutto possibile che il piatto non esista,
quindi se cerchiamo un piatto specifico con un ID piatto,
quel piatto potrebbe non esistere,
quindi dobbiamo preoccuparci di gestire quella particolare situazione.
Quindi gestiamo quella parte qui dentro,
e quindi se non è nulla allora significa che il piatto esiste.
Quindi ho intenzione di tagliare questo e poi incollarlo lì dentro.
E poi in questo caso,
poiché il piatto non è nullo,
quindi restituiremo il codice di stato e l'intestazione del set e
poi questo qui restituiremo i commenti del piatto,
perché ci viene chiesto di restituire solo i commenti per quel piatto particolare, quindi diremo:
«I piatti trovano per ID,
quindi req parametri piatto ID e poi piatto.»
E così restituiremo i commenti del piatto qui.
Altrimenti, quindi questa è l'altra parte.
Quindi il che significa che il piatto non esiste.
Quindi, in questo caso,
costruiremmo un errore qui dicendo nuovi errori e poi diremo
piatto req params dish ID non trovato.
Quindi questo piatto particolare non è stato trovato,
quindi ovviamente non saremo in grado di restituire i commenti per il piatto non esistente.
Quindi, in questo caso,
quindi creeremo un nuovo oggetto errore e quindi
imposteremo lo stato nell'oggetto errore a 404.
Ancora una volta, questo è 404 non trovato,
e poi torneremo il prossimo errore.
Ora, perché lo facciamo?
Perché se restituisci questo come un errore, come ricorderai,
questo verrà gestito dal tuo file app.js,
quindi nel file app.js,
proprio in basso qui,
abbiamo il gestore degli errori qui.
Quindi, quando arriva qui,
questo imposterà il resto o lo stato sullo stato del punto di errore,
che avevamo impostato su 404,
quindi questo è ciò che verrà restituito,
e quindi prenderà semplicemente quell'errore e quindi renderà quell'errore qui.
In modo che si prenderà cura di rendere gli errori.
Quindi questo restituirà il messaggio di errore al nostro cliente.
Questo è ciò che stiamo invocando qui,
quindi se il piatto non esiste,
restituiremo quell'errore qui dall'operazione get.
Ora, per il post in caso di post,
ci aspettiamo che venga
restituito un ID piatto e poi cercheremo il piatto,
e poi prenderemo il set di commenti
dal corpo e poi lo spingeremo nel piatto lì.
Quindi diremo piatti, ancora una volta, qui,
dovremo fare il ritrovamento per id perché stiamo cercando il piatto specifico qui.
Quindi per il post, diremo piatto trovare per ID poi piatto,
e così dentro qui,
se il piatto esiste,
allora gestiremo il piatto in modo appropriato.
In caso contrario, dovremo inviare il messaggio di errore.
Quindi lasciami copiare questa parte dal get e poi,
sostituiremo questo qui.
Quindi, ovviamente, se il piatto non esiste,
allora stiamo andando a restituire questo errore qui,
ma se il piatto esiste, in tal caso,
restituiremo il codice di stato 200 set header.
Ma prima di passare indietro il valore,
quello che sto per fare è dire commenti piatto,
quindi stiamo postando una nuova serie di commenti per il piatto.
Quindi diremo commenti piatto spingere corpo req.
Perché il corpo del messaggio contiene tutti i commenti che devono essere spinti qui,
e poi, diremo, «Piatto salva».
E quindi se il salvataggio ritorna con successo con il piatto qui,
quindi invieremo il piatto aggiornato da qui.
Quindi questa parte in cui stiamo costruendo il codice di stato,
lo faremo dentro qui e poi invieremo indietro il
Res.JSON e il piatto che abbiamo ottenuto qui.
Quindi, quello che stiamo facendo è salvare il piatto qui.
Stiamo prima spingendo i commenti nel piatto lì,
la nuova serie di commenti nel piatto qui,
e poi stiamo salvando il piatto aggiornato qui.
Quindi, dopo il salvataggio,
restituiremo il piatto aggiornato all'utente qui.
Quindi se c'è un errore,
allora gestiremo l'errore proprio come abbiamo fatto qui.
Se il piatto non esiste, ovviamente,
restituiremo l'errore dicendo che il piatto non esiste.
Quindi, questo è per il post.
L' operazione PUT, ovviamente,
non è supportata sui piatti.
Quindi, in questo caso,
stiamo cercando di eseguire l'operazione PUT
sui piatti, req.params.dishid/commenti.
Quindi, questo non è permesso.
Quindi, questo è quello che stiamo dicendo per l'operazione PUT.
Per l'operazione di eliminazione,
quello che faremo è prima trovare il piatto.
Quindi, diremo piatto.FindByid.
Quindi, cancella significa che stiamo rimuovendo tutti i commenti dal piatto,
non dal piatto stesso,
ma stiamo rimuovendo tutti i commenti dal piatto.
Quindi, in questo caso,
quello che finiremmo per fare è il seguente: quindi se il piatto non è nullo,
ricordate che dobbiamo gestirlo dicendo poi piatto.
Se il piatto non è nullo,
allora rimuoveremo tutti i commenti dal piatto.
Quindi, ho intenzione di copiare quel codice e poi incollarlo qui,
e poi modificheremo questo codice, quindi cancelleremo.
Vedremo se il piatto non è nullo,
allora restituiranno il piatto qui.
Quindi, se il piatto non è nullo,
il wat che gestiremmo questo è il seguente.
Quindi, dovremo entrare e cancellare ciascuno dei commenti.
Quindi, diremo per (var i =
(dish.comments.length -1) i> = 0; i—).
Quindi, stiamo letteralmente entrando e rimuovendo ogni commento.
Quindi, diremo
dish.comments.id (dish.comments [i]. _id).
Diremo di rimuovere.
Quindi, stiamo andando a rimuovere ciascuno dei piatti,
uno sotto ciascuno dei commenti uno per uno.
Quindi, questo è ciò che faremo ai commenti.
Poi, una volta che abbiamo rimosso tutti i commenti per il piatto,
allora dovremo salvare il piatto e poi rimandare indietro.
Quindi, prima anche quando modifichiamo il piatto,
questo è quello che abbiamo fatto qui.
Quindi, ho intenzione di copiare questa parte,
e poi venire qui,
e poi dire dish.save,
poi restituiremo il piatto
qui per indicare il piatto aggiornato che viene restituito qui.
Quindi, questo è il modo in cui cancelleremo i commenti.
Quindi, qui stiamo entrando,
ora non c'è un modo semplice per estrarre letteralmente
tutti i commenti dall'array quando hai un sottodocumento.
Quindi, devi entrare ed eliminare ogni documento secondario uno per uno.
Quindi, questo è quello che sto facendo in questo ciclo for qui.
Quindi, sto dicendo per (var i = dish.comments.length).
Quindi, sto guardando la matrice di commenti e poi partendo
dall'ultimo commento in quell'array fino al primo commento,
sto entrando e poi cancellando commento per commento qui utilizzando
l'operazione di rimozione sul documento secondario.
Quindi, il modo in cui accederemo a un documento secondario è dicendo
piatto e poi commenti è il nome del campo e poi dico id qui.
Quindi, questo è il modo in cui accedi a un documento secondario,
e qui dentro specificherai l'id dei documenti secondari a cui stai tentando di accedere.
Quindi, tutta questa cosa ti darà accesso al documento secondario,
quindi chiamiamo il metodo di rimozione sul documento secondario
e in modo che il documento secondario venga rimosso dalla matrice di documenti secondari.
Poi dopo, dopo aver cancellato tutti i commenti,
salverò le modifiche e il gioco è fatto.
Quindi, tutti i miei commenti saranno cancellati da allora piatto.
Ora, ci occuperemo del prossimo punto finale che è dishidComments/: CommentId.
Quindi, in questo caso,
inizieremo localizzando prima il piatto e poi dopo aver localizzato il piatto,
quindi dobbiamo assicurarci che il piatto esista
e quindi occuparci del piatto.
Quindi, ho intenzione di eliminare questa parte,
e poi diremo di copiare questa parte dal git che avevamo prima
perché dobbiamo essere in grado di affrontare la situazione in
cui il piatto non esiste o il piatto esiste ma i commenti non esistono,
o il piatto stesso non esiste.
Quindi, ci sono tre condizioni che devo testare.
Quindi, diremo se (piatto! =
null && dish.comments.id (req.params.commentId)! =
null, il che significa che il piatto stesso esiste e anche i commenti esistono nel piatto,
solo allora possiamo rimandare un commento specifico che è stato chiesto.
Quindi, in tal caso,
diremo StatusCode è 200, applicazione SetHeader json,
e poi qui invieremo indietro dish.comments,
e stiamo inviando questo particolare commento.
Quindi, questo è il commento specifico che stiamo inviando max.
Quindi, questo ci permetterà di recuperare un commento specifico dal set di commenti.
Ora, diremo altro se piatto uguale a null.
Quindi i piatti nulli,
quindi ovviamente dovremo indicare che il piatto non esiste e
l'ultima condizione è se il commento stesso è nullo.
Quindi, in questo caso devo anche indicare che il commento stesso non esiste,
quel particolare ID commento non esiste quindi in quel caso,
dirò un nuovo
commento di errore req.params.CommentId non trovato.
Quindi, tre condizioni.
In primo luogo, devi assicurarti prima che il piatto esista e che i commenti del piatto
esistano, se lo fanno allora posso rimandare il commento specifico
, in caso contrario, se il piatto stesso non esiste sul lato server nel database,
allora indicherò che il piatto non esiste ma se
il piatto non esiste esiste ma il commento non esiste,
quindi invierò il messaggio dicendo che il commento non esiste.
Quindi, si noti che devono gestire tutte le possibili condizioni qui per GET.
Per il POST, ovviamente,
l'operazione post non è supportata su questo endpoint,
quindi diremo
commenti barra req.params.CommentId.
Quindi, l'operazione POST non è supportata su questo commento Id. Ora che mi dici di PUT?
PUT è un caso più interessante qui.
Quindi, ancora una volta anche per il put,
devo gestire tutte queste possibili condizioni,
quindi ho intenzione di guardare questo e dire, va bene per questo,
fammi copiare tutto questo codice perché dobbiamo gestire
tutte queste possibilità e poi ti dirò esattamente come gestiamo il caso PUT qui.
Quindi, in caso di PUT,
prima di tutto dobbiamo localizzare la carneficina.
Quindi diranno che i piatti trovano da Id req param Id,
quindi se il piatto esiste e il commento stesso esiste,
allora so che posso aggiornare il commento.
Altrimenti, queste due condizioni ovviamente devono essere curate,
quel commento non esiste o il piatto non esiste.
Questi due sono gia' gestiti da quel caso.
Ora, ecco la situazione speciale che abbiamo.
Quindi, se il piatto esiste e esiste anche il commento specifico che sto cercando,
allora quello che so è che nel corpo del messaggio,
viene specificato l'aggiornamento per il commento.
Quindi ho bisogno di aggiornarlo.
Quindi, da qualche parte qui faccio modifiche,
faccio un piatto salva qui,
quindi vado a copiare un po 'di questo codice da qui,
ovviamente questa non è la cosa giusta, ma ho solo bisogno di una parte del codice da lì,
quindi entrerò nel PUT.
Lascia che lo incolla qui e
poi ti dirò esattamente come gestiranno questo.
Perche' ho bisogno che il piatto salvi parte.
Quindi, come gestiamo l'aggiornamento a un commento specifico?
Quindi, per l'aggiornamento a un commento specifico,
quello che sappiamo è che questo commento deve essere aggiornato,
quindi sappiamo che il piatto esiste e il commento stesso esiste.
Voglio aggiornare i campi della corrente.
Ora, se esiste già un commento, non voglio
consentire all'utente di cambiare l'autore del commento,
l'autore dovrebbe mantenere.
Gli unici due campi che consentirei all'aggiornamento dell'utente è la valutazione.
Quindi all'interno del corpo del messaggio PUT in arrivo,
posso includere
la valutazione aggiornata
o il commento aggiornato.
Queste sono le uniche due cose che permetterò all'utente di cambiare.
Quindi, se la proprietà rating ies corpo indiretto chiamare che il corpo
conterrà l'aggiornamento che stiamo cercando di farlo in questo caso diremo piatto.
Quindi diremo commenti piatto,
quindi lasciatemi solo copiare questa parte.
Commento piatto commento Id.
Ora questo è un modo semplice per gestire questo problema qui.
Poiché non esiste un modo specifico di aggiornare
un commento specifico che si trova in un documento secondario,
non esiste un metodo specifico per farlo.
Quindi questa è la soluzione che ho trovato che sembra funzionare per noi,
quindi diremo commenti del piatto req parametro commento Id rating uguale a req body.rating.
Quindi aggiornerò la valutazione.
Allo stesso modo, se il commento esiste lì,
allora dirò req comment Id comment req body comment.
Quindi, questo è il modo in cui sto per aggiornare la valutazione e il commento,
e una volta dico su aggiornato la valutazione e il commento,
e salveranno il piatto,
e poi una volta che salverò il piatto, poi invierò indietro la risposta.
Quindi, nota che questo è l'unico modo che ho trovato che è abbastanza facile da
aggiornare un documento secondario incorporato all'interno di un documento di Mongoose.
Non esiste un modo esplicito che Mongoose supporti per l'aggiornamento di un documento incorporato.
Quindi questa è la soluzione che ho trovato che ci consente di eseguire questa operazione.
Ora per l'operazione di eliminazione.
Per l'operazione di eliminazione stiamo eliminando solo un
commento specifico, quindi prenderò queste informazioni
dal deleter per tutti i commenti
e invece di eliminare tutti i commenti,
cancellerò solo un commento specifico.
Quindi, lasciami copiare dalla cancellazione.
Lasciami incollare qui e poi aggiorneremo questo.
Quindi, se sto cancellando un commento specifico quindi troverò prima il piatto.
Se il piatto non è nullo,
ricorda che in questa situazione devo gestire sia il piatto che
non essendo nullo sia anche il commento non essendo nullo.
Quindi, dirò se il
piatto non è uguale a null e il parametro id dei commenti del piatto non è uguale a null,
allora so che ho un commento specifico che voglio eliminare.
Non sto cancellando tutti i commenti,
sto cancellando solo un commento specifico qui.
Quindi, dirò i commenti del piatto id e poi sto cancellando il commento specifico qui che
è req.params.CommentId e rimuovo
quel particolare commento e poi salverò il piatto aggiornato e poi andrò avanti con quello.
Ora, l'altra parte di cui ho bisogno per gestire entrambe le situazioni.
Quindi, lasciami copiare questa parte se il piatto non è uguale a null e
così via e poi sostituisci questo qui.
Quindi, se il piatto è nullo, ti rimanderò l'errore dicendo che il piatto non esiste.
Se il commento è nullo, ti rimanderò l'errore dicendo che il commento non esiste.
Quindi, questo è tutto,
questo è l'aggiornamento che sto facendo qui.
Per eliminare un commento specifico,
prima assicurerò che il piatto e il commento
esistano, quindi cancellerò il commento specifico e poi salverò
le modifiche al piatto e poi procederò
con la gestione del resto dei casi, il gioco è fatto.
Salviamo le modifiche e poi guardiamo come funziona.
Andando al terminale,
vedo che il server MongoDB non è attivo e funzionante, quindi iniziamo da lì.
Assicurati, ovviamente,
che il server MongoDB sia attivo e funzionante,
avviamo anche il nostro server express.
Una volta che il server espresso è attivo e funzionante,
quello che faremo è ora stiamo guardando specificamente
i commenti e quindi eseguendo operazioni sui commenti.
Quindi, andiamo al Postman e
poi controllare quello che abbiamo nel database e poi provare a modificare i commenti.
Quindi, eccomi qui a Postman,
quindi fammi prima prendere i piatti e ora vedo che i piatti sono tutti vuoti.
Quindi lasciatemi postare un piatto alla lista di piatti, quindi lasciatemi postare un piatto.
Ricordiamo che abbiamo questo piatto lei,
così nel mio postino avevo già fatto che per l'esercizio precedente.
Sto solo andando a selezionare quello e poi postare quel piatto e poi si
vede che quel piatto particolare è stato postato qui, giù qui sotto.
Puoi vedere che il piatto è stato creato proprio lì.
Fammi ora copiare quel particolare documento e poi vado a
prendere quel piatto qui.
Quindi, vedete che quel piatto in particolare esiste qui.
Per prima cosa, otteniamo tutti i commenti.
Quindi, se faccio un get sui commenti si nota che
tutti i commenti per quel piatto particolare sono stati restituiti.
Possiamo fare il post e l'eliminazione anche.
Facciamo un put su quello e ovviamente non puoi fare un put on
back in modo da notare che l'operazione put non funziona su quello.
Pubblichiamo un nuovo commento.
Quindi, per pubblicare un nuovo commento andremo nel corpo,
e poi lasciami tagliare tutti questi e poi modificheremo uno
dei commenti e poi
proveremo a postare quel commento.
Quindi, diremo voto tre e poi
diremo commento di prova, utente di prova.
Pubblichiamo questo commento.
Quando pubblichi questo commento,
vedi che il piatto di aggiornamento è stato restituito qui e vedi che all'interno di
questo piatto vedi che il nuovo commento è stato incluso in lì.
Quindi, copiamo tutta questa faccenda.
Ora, cercheremo di ottenere quel particolare commento che abbiamo appena inserito.
Per quel particolare commento questo è l'id di quel commento.
Quindi fammi copiare l'id per quel commento specifico.
Tornando a Postman,
fammi provare a recuperare quel commento specifico facendo un'operazione get.
Lì vedete che quel particolare commento è stato recuperato qui.
Ora, se stai cercando di fare un post su questo, che non funzionerà
quindi ovviamente vedi che l'operazione post non è consentita su questo.
Facciamo un'operazione put,
su quel particolare commento.
Quindi, se dovessi mettere l'operazione nel corpo,
sto per dire commento di test aggiornato.
Quindi, ho intenzione di aggiornare il campo di commento di quel commento.
Se stai dicendo di mettere su che vedrai che per il commento specifico,
il commento è stato aggiornato per riflettere il commento di test aggiornato.
Quindi, vedi che anche l'operazione put sul campo commenti funziona correttamente.
Eliminiamo quel commento,
quindi posso eliminare il commento e poi quando elimino il commento
vedrai che quel commento è scomparso dall'elenco dei commenti.
Quindi, vedi che anche l'operazione di eliminazione funziona.
Cancelliamo tutti i commenti.
Quindi ho intenzione di entrare e cancellare tutti i commenti.
Poi si vede che tutti i commenti sono stati eliminati,
e così si vede che l'area commenti è ora vuota.
Quindi, ora puoi vederli tutte le
operazioni get, put, post ed delete sui
piatti/dishid/commenti
e i dishid/commenti/commenti/commentId,
gli endpoint API REST funzionano come previsto.
Quindi con questo completiamo questo esercizio.
Quindi, in questo esercizio abbiamo completato l'implementazione dei piatti barra,
endpoint API REST e supportato fino a
consentirci di manipolare un singolo piatto,
la raccolta di piatti,
un singolo commento e anche la raccolta di commenti.
Questo è un buon momento per fare un commit git con il messaggio,
express, REST API con Mongoose parte due.