1
00:00:03,920 --> 00:00:09,645
Come abbiamo capito dalla lezione precedente di questa lezione, il

2
00:00:09,645 --> 00:00:12,585
nostro obiettivo in questa lezione è quello di

3
00:00:12,585 --> 00:00:16,590
integrare il server API REST che abbiamo già sviluppato,

4
00:00:16,590 --> 00:00:20,525
insieme all'accesso al database MongoDB.

5
00:00:20,525 --> 00:00:24,060
Quindi, inizieremo con il server API REST

6
00:00:24,060 --> 00:00:27,480
che abbiamo costruito nella prima lezione in questo modulo,

7
00:00:27,480 --> 00:00:31,770
e poi dopo aver imparato come interagire dalla

8
00:00:31,770 --> 00:00:37,220
nostra applicazione nodo al server MongoDB utilizzando Mongoose,

9
00:00:37,220 --> 00:00:43,865
stiamo andando a sviluppare il nostro server API REST ulteriormente per integrare

10
00:00:43,865 --> 00:00:50,749
l'intero percorso tra la richiesta del client che entra nel server,

11
00:00:50,749 --> 00:00:53,840
fino alla corrispondente operazione di database da eseguire,

12
00:00:53,840 --> 00:01:00,880
e quindi costruire e inviare la risposta a quel client dal nostro sito server.

13
00:01:00,880 --> 00:01:04,125
Per iniziare, naturalmente, prima,

14
00:01:04,125 --> 00:01:08,300
vai alla cartella del server confusione che abbiamo già creato

15
00:01:08,300 --> 00:01:15,215
nel primo esercizio di questo modulo nella lezione API REST,

16
00:01:15,215 --> 00:01:17,915
e poi, nella cartella confusione,

17
00:01:17,915 --> 00:01:22,310
abbiamo già costruito il server API REST.

18
00:01:22,310 --> 00:01:26,630
Ora, quello che dovremmo fare è prendere in prestito

19
00:01:26,630 --> 00:01:32,035
i modelli che abbiamo sviluppato nell'esercizio precedente,

20
00:01:32,035 --> 00:01:36,050
il file dishes.js che abbiamo sviluppato nell'esercizio precedente,

21
00:01:36,050 --> 00:01:41,220
copiato nel progetto del server di confusione,

22
00:01:41,220 --> 00:01:44,430
e anche installare Bluebird Mongoose,

23
00:01:44,430 --> 00:01:51,225
e un altro modulo chiamato come Mongoose valuta, al nostro progetto.

24
00:01:51,225 --> 00:01:54,275
Quindi, andando alla nostra cartella nodo JS,

25
00:01:54,275 --> 00:01:57,050
prima andiamo nella cartella nodo Mongoose,

26
00:01:57,050 --> 00:02:01,970
e vediamo che nella sottocartella modelli della cartella nodo Mongoose,

27
00:02:01,970 --> 00:02:03,810
abbiamo il file dishes.js.

28
00:02:03,810 --> 00:02:07,354
Ho solo intenzione di copiare la cartella dei modelli,

29
00:02:07,354 --> 00:02:10,490
quindi andare alla cartella del server di confusione,

30
00:02:10,490 --> 00:02:13,910
e quindi semplicemente perforare la cartella dei modelli lì dentro.

31
00:02:13,910 --> 00:02:15,690
Quindi, una volta fatto ciò,

32
00:02:15,690 --> 00:02:22,540
il file dishes.js che contiene lo schema e il modello per il documento piatti,

33
00:02:22,540 --> 00:02:28,155
sono integrati nel nostro server API REST.

34
00:02:28,155 --> 00:02:30,890
Naturalmente, al fine di fare uso di questo,

35
00:02:30,890 --> 00:02:34,400
abbiamo bisogno di installare il modulo nodo Mongoose,

36
00:02:34,400 --> 00:02:40,990
e un nuovo modulo nodo chiamato come Mongoose valuta nel nostro progetto.

37
00:02:40,990 --> 00:02:47,510
Quindi, andando al terminale nel progetto del server di confusione,

38
00:02:47,510 --> 00:02:52,640
assicurati che il tuo terminale o la finestra di comando si

39
00:02:52,640 --> 00:02:57,480
trovi nel progetto del server di confusione in cui sviluppi l'API REST in precedenza

40
00:02:57,480 --> 00:03:01,070
e in questo progetto, installiamo.

41
00:03:01,070 --> 00:03:06,165
Quindi, faremo npm installare Mongoose,

42
00:03:06,165 --> 00:03:13,110
e poi, un nuovo modulo nodo chiamato come valuta Mongoose.

43
00:03:13,250 --> 00:03:16,630
Il modulo nodo valuta Mongoose,

44
00:03:16,630 --> 00:03:21,800
e visto in altri tipi di schema per la nostra applicazione Mongoose,

45
00:03:21,800 --> 00:03:23,770
quindi la stessa Mongoose,

46
00:03:23,770 --> 00:03:26,390
ha certamente già tipi di schema incorporati.

47
00:03:26,390 --> 00:03:29,505
Abbiamo visto l'uso del numero,

48
00:03:29,505 --> 00:03:35,550
la stringa e il booleano, e l'array.

49
00:03:35,550 --> 00:03:39,760
Ora, la moneta Mangusta aggiunge il supporto per la valuta.

50
00:03:39,760 --> 00:03:42,385
Ora, perché dovremmo avere bisogno di questo supporto monetario?

51
00:03:42,385 --> 00:03:49,040
In modo che il modulo di valuta Mongoose aggiunge un nuovo tipo chiamato come il tipo di valuta,

52
00:03:49,040 --> 00:03:53,140
che ci permette di memorizzare un valore di valuta.

53
00:03:53,140 --> 00:03:56,650
Dal momento che il nostro piatto sta per contenere un prezzo,

54
00:03:56,650 --> 00:04:00,760
è per questo che ho intenzione di utilizzare il modulo valuta Mongoose qui.

55
00:04:00,760 --> 00:04:04,590
Ora, l'esercizio qui,

56
00:04:04,590 --> 00:04:07,545
illustreremo l'uso del modulo valuta Mongoose,

57
00:04:07,545 --> 00:04:11,880
è possibile leggere ulteriori dettagli sul modulo nodo valuta Mongoose anche,

58
00:04:11,880 --> 00:04:19,010
nella documentazione di che un link a cui è fornito nelle risorse aggiuntive.

59
00:04:19,010 --> 00:04:22,489
Così, ora che abbiamo installato questi moduli nodo,

60
00:04:22,489 --> 00:04:24,890
Mongoose e Mongoose valuta,

61
00:04:24,890 --> 00:04:33,920
andiamo alla nostra applicazione e impostarlo per comunicare con il server MongoDB.

62
00:04:33,920 --> 00:04:37,570
Ora, assicurati che il tuo server MongoDB sia attivo e funzionante.

63
00:04:37,570 --> 00:04:40,070
Quindi, qui, vedi che

64
00:04:40,070 --> 00:04:44,730
il mio server MongoDB è in esecuzione in un'altra scheda terminale sul mio computer.

65
00:04:44,730 --> 00:04:46,670
Se lo si esegue su un computer Windows,

66
00:04:46,670 --> 00:04:54,005
assicurarsi che sia in esecuzione in un altro comando Finestra del computer Windows.

67
00:04:54,005 --> 00:04:58,525
Andando alla nostra applicazione nell'editor,

68
00:04:58,525 --> 00:05:01,685
inizieremo prima con il file app.js.

69
00:05:01,685 --> 00:05:03,460
Ora nel file app.js,

70
00:05:03,460 --> 00:05:07,590
questo è dove abbiamo costruito la nostra applicazione espressa in precedenza.

71
00:05:07,590 --> 00:05:12,935
Ma ora, questa negazione extra suck non è connessa al server back-end MongoDB.

72
00:05:12,935 --> 00:05:18,085
Stiamo per fare uso del modulo Mongoose,

73
00:05:18,085 --> 00:05:20,430
al fine di stabilire la connessione con il server.

74
00:05:20,430 --> 00:05:22,385
Quindi, andando qui,

75
00:05:22,385 --> 00:05:29,540
ho intenzione di aggiungere il modulo richiede il modulo Mangusta qui.

76
00:05:29,540 --> 00:05:35,850
Quindi diremo: «Const Mangusta richiede Mangusta».

77
00:05:38,120 --> 00:05:43,280
E poi anche, dal momento che abbiamo copiato sopra la cartella dei modelli,

78
00:05:43,280 --> 00:05:46,520
che contiene il file piatti,

79
00:05:46,520 --> 00:05:51,220
che dichiara lo schema dei piatti e il modello.

80
00:05:51,220 --> 00:05:56,645
Quindi, fammi importare i piatti.

81
00:05:56,645 --> 00:06:04,930
Quindi, diremo, «richiedere.Slash modelli piatti.»

82
00:06:04,930 --> 00:06:07,640
Quindi, una volta completato questo, ora ovviamente,

83
00:06:07,640 --> 00:06:11,000
dobbiamo stabilire la connessione con il server.

84
00:06:11,000 --> 00:06:13,560
Quindi, imposta

85
00:06:14,120 --> 00:06:24,960
l'URL mongodb// localhost7017/confusione,

86
00:06:27,340 --> 00:06:33,140
proprio come abbiamo fatto con l'esercizio

87
00:06:33,140 --> 00:06:44,040
Mangusta, e poi diremo, «Const connect, Mongo connect URL».

88
00:06:44,040 --> 00:06:51,450
Quindi, questo è esattamente lo stesso codice che abbiamo usato nell'esercizio precedente.

89
00:06:51,450 --> 00:06:53,640
Quindi, stabiliamo la connessione.

90
00:06:53,640 --> 00:07:01,695
Quindi, diremo, «connect» e poi diremo,

91
00:07:01,695 --> 00:07:11,610
«DB do it console log».

92
00:07:11,610 --> 00:07:19,030
Dicendo: «Connesso correttamente al server».

93
00:07:21,020 --> 00:07:26,260
E gestiremo anche l'errore qui.

94
00:07:33,980 --> 00:07:40,855
Faremo semplicemente un registro della console dell'errore qui, il gioco è fatto.

95
00:07:40,855 --> 00:07:49,110
Ciò stabilirà la connessione al server dal nostro file app.js.

96
00:07:49,110 --> 00:07:52,375
Quindi, una volta stabilita la connessione al server,

97
00:07:52,375 --> 00:07:58,615
quindi, apriamo il file dishes.js dai nostri modelli.

98
00:07:58,615 --> 00:08:00,995
Ora, nel file dishes.js,

99
00:08:00,995 --> 00:08:02,970
per fare uso

100
00:08:02,970 --> 00:08:11,760
del modulo nodo che abbiamo appena installato.

101
00:08:11,760 --> 00:08:18,990
Quindi, diremo, «Richiedi valuta Mangusta» e diciamo,

102
00:08:18,990 --> 00:08:26,500
«Carica il tipo e la mangusta».

103
00:08:26,500 --> 00:08:32,670
Quindi, ciò che questo farà è caricare questo nuovo tipo di valuta in Mongoose.

104
00:08:32,670 --> 00:08:39,970
Successivamente, possiamo dire const,

105
00:08:39,970 --> 00:08:48,705
valuta Mongoose tipi di valuta.

106
00:08:48,705 --> 00:08:51,720
Questo è tutto. Quindi, questo nuovo tipo,

107
00:08:51,720 --> 00:08:57,880
il tipo di valuta viene aggiunto in Mongusta e che aggiungerà un nuovo tipo chiamato

108
00:08:57,880 --> 00:09:00,160
valuta e quindi così ho intenzione di dichiarare

109
00:09:00,160 --> 00:09:04,840
questa valuta costante come valuta dei tipi di Mongusta.

110
00:09:04,840 --> 00:09:11,630
In modo da poter fare uso di questo nella definizione dello schema nella mia applicazione.

111
00:09:11,630 --> 00:09:14,270
Ora, in questo caso,

112
00:09:14,270 --> 00:09:17,970
lo schema comune rimarrà esattamente lo stesso di prima, ma

113
00:09:17,970 --> 00:09:24,060
lo schema piatto come si ricorda dal file db.json.

114
00:09:24,060 --> 00:09:28,050
Quando si guarda la struttura di un documento piatto,

115
00:09:28,050 --> 00:09:35,630
si vede che il documento piatto contiene nome e immagine che come si vede qui è una stringa,

116
00:09:35,630 --> 00:09:38,570
una categoria, un'etichetta,

117
00:09:38,570 --> 00:09:42,555
un prezzo, che è un tipo di stringa qui.

118
00:09:42,555 --> 00:09:46,865
Ma dichiareremo questo come un tipo di valuta,

119
00:09:46,865 --> 00:09:51,495
una caratteristica che come ci si aspetta è una variabile booleana,

120
00:09:51,495 --> 00:09:55,015
e una descrizione che è una stringa e quindi commenti

121
00:09:55,015 --> 00:09:59,755
che non è altro che un array di tipi di commenti.

122
00:09:59,755 --> 00:10:05,790
Ora, quindi quello che faremo ora è estendere lo schema piatto per

123
00:10:05,790 --> 00:10:12,865
supportare tutte queste varie proprietà o vari campi nel mio documento json.

124
00:10:12,865 --> 00:10:15,225
Quindi abbiamo gia' il nome.

125
00:10:15,225 --> 00:10:18,505
Quindi abbiamo già la descrizione in atto.

126
00:10:18,505 --> 00:10:23,730
Quindi abbiamo bisogno di aggiungere nei prossimi lì abbiamo già i commenti,

127
00:10:23,730 --> 00:10:27,185
la matrice di commenti del tipo di schema di commento lì.

128
00:10:27,185 --> 00:10:30,075
Quindi aggiungeremo nei prossimi.

129
00:10:30,075 --> 00:10:34,150
Quindi il prossimo che aggiungeremo è il tipo di immagine,

130
00:10:34,150 --> 00:10:37,640
che sarebbe

131
00:10:37,640 --> 00:10:44,300
della stringa di tipo e

132
00:10:44,300 --> 00:10:49,140
diremo richiesto true.

133
00:10:49,200 --> 00:10:52,240
Quindi questo aggiunge il tipo di immagine.

134
00:10:52,240 --> 00:11:00,460
Il prossimo che aggiungerò è la categoria,

135
00:11:00,460 --> 00:11:03,865
che è anche il tipo di stringa.

136
00:11:03,865 --> 00:11:07,990
Il prossimo è l'etichetta,

137
00:11:07,990 --> 00:11:10,720
che è anche questo tipo di stringa.

138
00:11:10,720 --> 00:11:14,560
Dal momento che tutti questi sono dello stesso tipo e richiesti,

139
00:11:14,560 --> 00:11:16,625
li sto solo copiando qui.

140
00:11:16,625 --> 00:11:18,464
Quindi per l'etichetta,

141
00:11:18,464 --> 00:11:21,275
direi che questo non è richiesto, ma

142
00:11:21,275 --> 00:11:26,945
invece posso anche specificare un valore predefinito se voglio.

143
00:11:26,945 --> 00:11:29,465
Quindi posso specificare un valore predefinito come quello.

144
00:11:29,465 --> 00:11:31,965
Il valore predefinito è una stringa vuota.

145
00:11:31,965 --> 00:11:37,245
Quindi, se non specifico richiesto, posso semplicemente specificare un valore predefinito qui.

146
00:11:37,245 --> 00:11:46,300
Ora, in aggiunta, il prossimo campo che ho intenzione di introdurre è il campo dei prezzi.

147
00:11:47,070 --> 00:11:53,575
Il campo prezzo dichiarerò il tipo come valuta.

148
00:11:53,575 --> 00:11:57,085
Ricordiamo che avevamo dichiarato il tipo di valuta in precedenza

149
00:11:57,085 --> 00:12:00,380
qui richiedendo prima

150
00:12:00,380 --> 00:12:03,960
il modulo di valuta Mongoose e quindi dichiarando il tipo di valuta.

151
00:12:03,960 --> 00:12:09,435
Quindi, è così che useresti il tipo di valuta nella nostra applicazione.

152
00:12:09,435 --> 00:12:16,170
Quindi diremo tipo di prezzo valuta e

153
00:12:16,170 --> 00:12:24,610
richiesto è vero e quindi posso anche specificare il valore minimo che sarebbe zero.

154
00:12:24,610 --> 00:12:29,590
Quindi il campo successivo è

155
00:12:29,590 --> 00:12:35,830
il campo in primo piano che sarebbe del tipo booleano,

156
00:12:35,830 --> 00:12:40,900
e il valore predefinito sarà falso.

157
00:12:40,900 --> 00:12:43,625
Quindi, se il mio documento manca,

158
00:12:43,625 --> 00:12:47,940
allora il valore predefinito verrà aggiunto nel documento qui.

159
00:12:47,940 --> 00:12:50,470
Quindi notare che ora ho ampliato

160
00:12:50,470 --> 00:12:56,825
lo schema piatto aggiungendo il tipo di immagine, la categoria,

161
00:12:56,825 --> 00:13:01,710
l'etichetta, il prezzo e la caratteristica per abbinare

162
00:13:01,710 --> 00:13:07,925
la struttura dell'esempio di documento piatto che vi ho appena mostrato in precedenza.

163
00:13:07,925 --> 00:13:13,795
Così ora, il mio schema di piatti è tutto pronto per essere utilizzato.

164
00:13:13,795 --> 00:13:20,185
Quindi, iniziamo ora a lavorare sul mio router.

165
00:13:20,185 --> 00:13:21,915
Allora, dov'è il router?

166
00:13:21,915 --> 00:13:29,530
Si ricorda che il router che supporta gli endpoint API REST per le slash dish,

167
00:13:29,530 --> 00:13:32,110
endpoint API REST e piatti barra,

168
00:13:32,110 --> 00:13:35,170
endpoint dell'ID piatto barra è nel router piatto.

169
00:13:35,170 --> 00:13:41,295
Quindi, andremo a piatto router.jsfile e poi estenderemo il file piatto router.js.

170
00:13:41,295 --> 00:13:46,735
Quindi, nel router piatto insieme a Express e BodyParser,

171
00:13:46,735 --> 00:13:55,310
ora includerò Mongoose.

172
00:13:56,640 --> 00:14:03,370
Quindi diremo richiedono Mangusta e

173
00:14:03,370 --> 00:14:10,944
poi avremo bisogno di piatti modello.

174
00:14:10,944 --> 00:14:12,400
Dov'è il modello dei piatti?

175
00:14:12,400 --> 00:14:20,080
È dentro. /modelli/piatti.

176
00:14:20,080 --> 00:14:22,405
Quindi è lì dentro.

177
00:14:22,405 --> 00:14:24,470
Quindi nota che siamo nella cartella del router,

178
00:14:24,470 --> 00:14:27,610
quindi devi salire di un livello e quindi andare nella

179
00:14:27,610 --> 00:14:31,460
cartella del modello e quindi il file dishes.js è proprio lì.

180
00:14:31,460 --> 00:14:34,010
Questo è ciò che stiamo importando qui.

181
00:14:34,010 --> 00:14:41,039
Così ora, posso aggiornare il mio router piatto per essere in grado di interagire

182
00:14:41,039 --> 00:14:46,330
con il server MongoDB usando

183
00:14:46,330 --> 00:14:52,175
Mongoose e abbiamo già importato il modello di piatti nel mio router piatto.

184
00:14:52,175 --> 00:14:57,720
Quindi, è tempo per me di andare e aggiornare tutti i metodi qui dentro.

185
00:14:57,720 --> 00:14:59,465
Quindi, per il router piatto,

186
00:14:59,465 --> 00:15:03,665
la barra che significa che la barra piatti endpoint.

187
00:15:03,665 --> 00:15:07,880
Ho intenzione di rimuovere tutto questo da qui, invece,

188
00:15:07,880 --> 00:15:12,040
ho intenzione di dichiarare esplicitamente tutti i vari endpoint.

189
00:15:12,040 --> 00:15:16,995
Per ottenere post put ed delete gestirò ognuno di loro in modo indipendente.

190
00:15:16,995 --> 00:15:19,135
Quindi nel metodo get,

191
00:15:19,135 --> 00:15:24,360
ho intenzione di ritagliarlo e poi nel metodo get, cosa devo fare?

192
00:15:24,360 --> 00:15:32,760
Ricordiamo che avevamo definito il metodo da Mangusta che ci permette di trovare tutti i piatti.

193
00:15:32,760 --> 00:15:36,365
Quindi, quando si esegue un'operazione get sull'endpoint slash dish,

194
00:15:36,365 --> 00:15:39,600
ci si aspetta che tutti i piatti vengano restituiti

195
00:15:39,600 --> 00:15:44,005
al client in risposta alla richiesta get.

196
00:15:44,005 --> 00:15:49,890
Quindi, vado ai piatti e poi eseguirò l'operazione di ricerca.

197
00:15:49,890 --> 00:15:53,040
Quindi ora lo vedi dal mio server Express,

198
00:15:53,040 --> 00:15:58,585
sto accedendo al mio MongoDB.

199
00:15:58,585 --> 00:16:06,520
Quindi, farò una scoperta e nel ritrovamento ora gestirò la richiesta.

200
00:16:06,520 --> 00:16:08,310
Quindi posso dire che i piatti trovano,

201
00:16:08,310 --> 00:16:13,885
dato che sta per restituire una promessa,

202
00:16:13,885 --> 00:16:16,765
allora posso gestirlo qui dentro.

203
00:16:16,765 --> 00:16:24,520
Quindi, dirò piatto e quindi se la promessa si risolve correttamente,

204
00:16:24,520 --> 00:16:33,529
lo farò in poi e così dirò piatto e poi così gestiremo il

205
00:16:33,960 --> 00:16:41,125
codice di stato res è 200 e poi diremo

206
00:16:41,125 --> 00:16:48,920
res impostare tipo di contenuto intestazione.

207
00:16:53,100 --> 00:16:57,830
Dal momento che stiamo andando a restituire il valore come un json,

208
00:16:57,830 --> 00:17:00,770
quindi lo imposteremo su applicazione json.

209
00:17:00,770 --> 00:17:03,580
Ok, questo restituira' una serie di piatti.

210
00:17:03,580 --> 00:17:07,955
Quindi posso semplicemente dire piatti e poi diremo res.json.

211
00:17:07,955 --> 00:17:12,650
Quindi il res.json prenderà come input nella stringa json

212
00:17:12,650 --> 00:17:17,680
e quindi lo invierà al mio client.

213
00:17:17,680 --> 00:17:21,785
Quindi, quando chiami res.json e fornisci il valore e poi

214
00:17:21,785 --> 00:17:27,650
prenderà semplicemente il parametro che fornisci qui e poi lo invii come risposta json.

215
00:17:27,650 --> 00:17:30,365
Inserirà questi piatti nel corpo del

216
00:17:30,365 --> 00:17:33,835
messaggio di risposta e quindi lo invierà nuovamente al server.

217
00:17:33,835 --> 00:17:39,560
Ora, possiamo gestire l'errore

218
00:17:39,560 --> 00:17:47,370
qui dicendo il prossimo errore.

219
00:17:48,100 --> 00:17:59,140
Possiamo anche fare un errore di cattura solo per il bene del completo.

220
00:17:59,140 --> 00:18:03,290
Ho intenzione di mettere entrambi questi a posto qui, in

221
00:18:03,290 --> 00:18:05,960
modo che entrambi saranno gestiti come tali.

222
00:18:05,960 --> 00:18:08,305
Quindi, se viene restituito un errore,

223
00:18:08,305 --> 00:18:11,740
questo passerà semplicemente l'errore al

224
00:18:11,740 --> 00:18:15,260
gestore degli errori generale per la mia applicazione

225
00:18:15,260 --> 00:18:18,985
e il lasciar che si preoccupi di come gestire l'errore.

226
00:18:18,985 --> 00:18:21,490
Quindi lo manderemo a quello.

227
00:18:21,490 --> 00:18:28,610
Quindi vedi come sto usando l'operazione di ricerca e quindi eseguo la richiesta qui.

228
00:18:28,610 --> 00:18:30,595
Ora, per il post,

229
00:18:30,595 --> 00:18:32,904
come ti saresti già aspettato,

230
00:18:32,904 --> 00:18:37,100
ho intenzione di fare piatti.create

231
00:18:38,790 --> 00:18:43,425
perché stiamo andando a creare un nuovo piatto qui.

232
00:18:43,425 --> 00:18:47,195
Quindi, ricorda che abbiamo già visto i piatti creano l'

233
00:18:47,195 --> 00:18:52,400
utilizzo del metodo in precedenza e ricorda che il parser del corpo avrebbe

234
00:18:52,400 --> 00:18:56,950
già analizzato tutto ciò che è nel corpo del messaggio e lo ha caricato

235
00:18:56,950 --> 00:19:01,510
sulla proprietà body della richiesta.

236
00:19:01,510 --> 00:19:08,650
Quindi, ho intenzione di prendere il corpo della richiesta e quindi analizzarlo come parametro per il mio

237
00:19:08,650 --> 00:19:16,120
metodo dishes.create e gestire il valore restituito.

238
00:19:16,120 --> 00:19:21,325
Quindi, diremo allora e questo restituirebbe

239
00:19:21,325 --> 00:19:26,755
un piatto e ce ne occuperemo qui.

240
00:19:26,755 --> 00:19:35,220
Quindi diremo se i piatti tornano correttamente e se i piatti postati correttamente, dirà res.

241
00:19:36,060 --> 00:19:43,045
Ok facciamo un console.log per il nostro utilizzo.

242
00:19:43,045 --> 00:19:52,330
Sul lato server faremo un console.log dicendo piatto «Dish Created» qui.

243
00:19:52,330 --> 00:20:02,125
Registriamo quel piatto sulla console e poi diremo questi due codici di stato di riposo.

244
00:20:02,125 --> 00:20:09,820
Copieremo quel codice e lo incolleremo lì dentro e in questo caso,

245
00:20:09,820 --> 00:20:12,445
restituiremo il piatto qui.

246
00:20:12,445 --> 00:20:16,480
Il piatto che è arrivato come parametro qui e poi lascia che

247
00:20:16,480 --> 00:20:22,825
il cliente si occupi di quel valore sul lato client,

248
00:20:22,825 --> 00:20:24,985
qualunque cosa venga restituito nel piatto.

249
00:20:24,985 --> 00:20:27,745
Ora, anche loro aggiungeranno in

250
00:20:27,745 --> 00:20:41,770
questo qui e poi la cattura.

251
00:20:41,770 --> 00:20:44,860
Quindi questo è il modo in cui gestiamo il post.

252
00:20:44,860 --> 00:20:47,830
Per il PUT, perché PUT non è consentito,

253
00:20:47,830 --> 00:20:50,365
quindi lo lasceremo come tale.

254
00:20:50,365 --> 00:20:54,250
Per DELETE, stiamo per eliminare tutti i piatti.

255
00:20:54,250 --> 00:21:02,240
Quindi diremo, «piatti.Rimuovere».

256
00:21:03,990 --> 00:21:08,185
Questa è essenzialmente un'operazione pericolosa.

257
00:21:08,185 --> 00:21:11,080
Così si sta rimuovendo tutti i piatti

258
00:21:11,080 --> 00:21:18,610
dal server e così diremo,

259
00:21:18,610 --> 00:21:25,600
«piatti.Rimuovere allora» e il «allora» otterrà una certa risposta.

260
00:21:25,600 --> 00:21:32,200
Quindi diremo semplicemente «resp here» e il modo in cui gestiremmo

261
00:21:32,200 --> 00:21:40,550
quella risposta è semplicemente prendere quel valore e poi restituirlo al client.

262
00:21:40,620 --> 00:21:48,550
Quindi diremo, «res.statusCode 200 content type application json», e

263
00:21:48,550 --> 00:21:56,660
quindi invieremo semplicemente la risposta al client e gestiremo l'errore

264
00:22:06,000 --> 00:22:08,830
proprio come abbiamo fatto in precedenza.

265
00:22:08,830 --> 00:22:10,390
Questa è l'operazione DELETE.

266
00:22:10,390 --> 00:22:14,110
Quindi vedete che ora stiamo facendo l'

267
00:22:14,110 --> 00:22:17,545
operazione GET, POST, PUT e DELETE.

268
00:22:17,545 --> 00:22:26,425
Ora continueremo lo stesso con il punto finale /dishID.

269
00:22:26,425 --> 00:22:28,270
Quindi in questo caso,

270
00:22:28,270 --> 00:22:34,040
siamo specificamente motivo ottenere un piatto specifico.

271
00:22:34,040 --> 00:22:39,480
Restituiremo quel valore specifico del piatto.

272
00:22:39,480 --> 00:22:41,445
Quindi nel GET,

273
00:22:41,445 --> 00:22:51,275
quello che facciamo è diremo «piatti.FindById.

274
00:22:51,275 --> 00:22:57,965
Quindi il findById è un metodo che è disponibile da mongo e dal driver MongoDB.

275
00:22:57,965 --> 00:23:02,020
Quindi diremo,» req.params.dishid.»

276
00:23:03,600 --> 00:23:11,030
Ricordiamo che sappiamo già che l'ID piatto è presente nella proprietà params.

277
00:23:11,030 --> 00:23:14,140
Avete già imparato a questo proposito in precedenza.

278
00:23:14,140 --> 00:23:20,260
Quindi dirò, «findById (req.params.dishId)» e

279
00:23:20,260 --> 00:23:24,565
poi e il resto.

280
00:23:24,565 --> 00:23:30,520
Quindi ho intenzione di copiare quello poi e altro da proprio

281
00:23:30,520 --> 00:23:38,170
lì e poi scendere al DishRouter e

282
00:23:38,170 --> 00:23:46,150
poi semplicemente incollarlo qui.

283
00:23:46,150 --> 00:23:49,190
Quindi diremo, "res.statusCode200

284
00:23:49,440 --> 00:23:55,585
applicazione json.res.jsondish e quindi la gestione degli errori.

285
00:23:55,585 --> 00:24:05,350
Per il POST, ovviamente non gestiremo il post per un endpoint /dishID.

286
00:24:05,350 --> 00:24:07,635
Quindi lo lasceremo come tale.

287
00:24:07,635 --> 00:24:12,740
Per PUT, stiamo per aggiornare

288
00:24:12,740 --> 00:24:17,975
un piatto specifico che è identificato dal suo ID piatto.

289
00:24:17,975 --> 00:24:25,270
Quindi questo è dove useremo dishes.FindByidAndUpdate.

290
00:24:25,270 --> 00:24:27,690
Quindi questo è il metodo che useremo,

291
00:24:27,690 --> 00:24:35,539
findByidAndUpdate e questo prende come primo parametro

292
00:24:37,410 --> 00:24:44,410
req.params.dishId e il secondo valore è

293
00:24:44,410 --> 00:24:53,290
l'insieme e l'aggiornamento

294
00:24:53,290 --> 00:24:55,150
sarà nel corpo del messaggio.

295
00:24:55,150 --> 00:24:57,580
Quindi ho intenzione di recuperarlo

296
00:24:57,580 --> 00:25:05,410
dal corpo req e poi anche dall'altra bandiera che ho intenzione di avere.

297
00:25:05,410 --> 00:25:10,840
Quindi dirà «new: true», in modo che questo metodo findById restituisca

298
00:25:10,840 --> 00:25:18,730
il piatto aggiornato come stringa json nella risposta.

299
00:25:18,730 --> 00:25:23,650
Quindi questo è quello che ho intenzione di ottenere qui e poi quando quel valore entra in gioco,

300
00:25:23,650 --> 00:25:26,230
ho solo intenzione di prendere il piatto e

301
00:25:26,230 --> 00:25:39,040
poi semplicemente di restituire il piatto al lato cliente.

302
00:25:39,040 --> 00:25:47,095
Quindi dirò res.jason (piatto) e poi gestiremo l'errore in modo corrispondente.

303
00:25:47,095 --> 00:25:49,090
Finalmente per il DELETE.

304
00:25:49,090 --> 00:25:50,695
Per il DELETE di nuovo,

305
00:25:50,695 --> 00:25:54,880
il metodo corrispondente che stiamo per

306
00:25:54,880 --> 00:26:01,165
utilizzare è il metodo di Mongo chiamato FindByIdAndRemove.

307
00:26:01,165 --> 00:26:03,760
Quindi puoi vedere che abbiamo questo metodo chiamato

308
00:26:03,760 --> 00:26:08,080
findByidAndRemove e questo findByidAndRemove,

309
00:26:08,080 --> 00:26:18,355
prenderà req.params.dishID perché questo è il piatto che stiamo cercando di rimuovere.

310
00:26:18,355 --> 00:26:20,970
Quindi, quando questo viene eliminato,

311
00:26:20,970 --> 00:26:23,940
così come abbiamo gestito questo qui,

312
00:26:23,940 --> 00:26:30,830
quindi ho intenzione di copiare questo codice dai dishes.Remove.

313
00:26:30,830 --> 00:26:34,350
E' la stessa cosa che faro' anche qui.

314
00:26:34,350 --> 00:26:38,750
Quindi findByidAndRemove e qualunque risposta

315
00:26:38,750 --> 00:26:41,970
ottengo, lo restituirò al mio cliente.

316
00:26:41,970 --> 00:26:45,490
Con questo abbiamo aggiornato il DishRouter.

317
00:26:45,490 --> 00:26:49,960
Salviamo tutte le modifiche che abbiamo fatto

318
00:26:49,960 --> 00:26:57,185
finora e poi andremo ad avviare il nostro server e poi vedere cosa fa.

319
00:26:57,185 --> 00:27:01,370
Quindi andando al terminale o alla finestra di comando, avvia il server.

320
00:27:01,370 --> 00:27:06,045
Quindi dirò «npm start» e il server è ora attivo e funzionante.

321
00:27:06,045 --> 00:27:12,030
Useremo il postino per comunicare con questo server.

322
00:27:12,030 --> 00:27:15,700
Quindi andiamo al postino e poi eseguiamo alcune operazioni.

323
00:27:15,700 --> 00:27:19,030
Quindi qui vedete il mio postino che corre qui.

324
00:27:19,030 --> 00:27:26,450
Quindi fammi fare un'operazione GET sul localhost: 3000/piatti.

325
00:27:28,300 --> 00:27:31,875
Quindi, quando esegui un'operazione GET come vedi,

326
00:27:31,875 --> 00:27:33,205
restituirà una stringa vuota.

327
00:27:33,205 --> 00:27:36,715
Il mio database è ora vuoto, quindi non ho nulla lì.

328
00:27:36,715 --> 00:27:40,205
Quindi mi verrà restituita una stringa vuota.

329
00:27:40,205 --> 00:27:45,600
Mettiamo un piatto.

330
00:27:46,020 --> 00:27:48,340
Quindi, quando pubblichi un piatto,

331
00:27:48,340 --> 00:27:50,254
ovviamente nel corpo,

332
00:27:50,254 --> 00:27:58,175
racchiuderai un piatto e il corpo sarà impostato per essere il tipo json dell'applicazione.

333
00:27:58,175 --> 00:28:00,785
Ora, per pubblicare un piatto,

334
00:28:00,785 --> 00:28:06,770
ti ho già dato il file db.json nelle risorse di esercizio.

335
00:28:06,770 --> 00:28:10,880
Quindi apri il file db.json e poi copia il primo piatto da

336
00:28:10,880 --> 00:28:15,390
lì e poi lo incolleremo qui e poi pubblicheremo quel piatto.

337
00:28:15,390 --> 00:28:18,735
Quindi, lasciami andare al file db.jason.

338
00:28:18,735 --> 00:28:21,550
Fammi copiare il primo piatto da qui.

339
00:28:21,550 --> 00:28:22,810
Quindi ho intenzione di copiare

340
00:28:22,810 --> 00:28:32,765
l'intero piatto fino a lì e poi ho intenzione di postare questo piatto.

341
00:28:32,765 --> 00:28:36,610
Questo contiene molti dei campi che abbiamo già qui.

342
00:28:36,610 --> 00:28:39,895
Diamo questo piatto al server e vediamo cosa succede.

343
00:28:39,895 --> 00:28:44,605
Quindi tornando al postino.

344
00:28:44,605 --> 00:28:47,620
Qui, nei dati del modulo,

345
00:28:47,620 --> 00:28:51,535
nel corpo, lasciami incollare il piatto in posizione.

346
00:28:51,535 --> 00:28:54,760
Quindi, abbiamo i dettagli completi del piatto lì.

347
00:28:54,760 --> 00:28:58,010
POSSIAMO questo piatto al server.

348
00:28:58,320 --> 00:29:01,780
Poi, una volta che il piatto è stato pubblicato sul server,

349
00:29:01,780 --> 00:29:06,580
vedi che il Postman ha,

350
00:29:06,580 --> 00:29:09,700
fammi solo ridurre questo,

351
00:29:09,700 --> 00:29:18,370
e poi vedi in fondo che questo particolare piatto è stato pubblicato nel database,

352
00:29:18,370 --> 00:29:20,290
nel database MongoDB dal mio server.

353
00:29:20,290 --> 00:29:23,560
Quindi, vedi che il valore restituito

354
00:29:23,560 --> 00:29:30,760
qui mostra quando il piatto è stato inserito in quel server.

355
00:29:30,760 --> 00:29:35,020
Quindi, hai aggiunto CreateDat e UpdateDat.

356
00:29:35,020 --> 00:29:39,880
Si vede che i campi rimanenti sono tutti memorizzati lì.

357
00:29:39,880 --> 00:29:45,865
Nota in particolare come il valore del prezzo viene memorizzato lì.

358
00:29:45,865 --> 00:29:49,820
Questo è il modo in cui valuta memorizza il valore del prezzo.

359
00:29:50,630 --> 00:29:53,825
Quindi, quando ottieni il valore di ritorno,

360
00:29:53,825 --> 00:29:59,370
devi interpretarlo in modo appropriato sul lato client cosa significa.

361
00:29:59,370 --> 00:30:08,510
Si noti inoltre che l'ID è stato aggiunto al mio piatto e per ogni commento stesso,

362
00:30:08,510 --> 00:30:11,445
perché ognuno dei commenti è di per sé è un sottodocumento.

363
00:30:11,445 --> 00:30:14,370
Avrai aggiunto UpdateDat e CreateDat

364
00:30:14,370 --> 00:30:21,115
e l'ID per ciascuno dei commenti anche aggiunto automaticamente dal mio database.

365
00:30:21,115 --> 00:30:23,080
Ecco a te. Quindi ora,

366
00:30:23,080 --> 00:30:26,875
questo piatto è stato aggiunto al mio database.

367
00:30:26,875 --> 00:30:29,589
Eseguiamo di nuovo l'operazione GET,

368
00:30:29,589 --> 00:30:32,244
e ovviamente a questo punto,

369
00:30:32,244 --> 00:30:37,135
il server dovrebbe restituire quel piatto particolare che è stato aggiunto in.

370
00:30:37,135 --> 00:30:39,775
Quindi, restituirà una serie di piatti qui,

371
00:30:39,775 --> 00:30:42,190
quindi, come puoi vedere, restituisce una serie di piatti.

372
00:30:42,190 --> 00:30:44,050
Naturalmente, questa matrice contiene solo un piatto

373
00:30:44,050 --> 00:30:47,245
o quel piatto particolare è stato restituito qui.

374
00:30:47,245 --> 00:30:49,585
Finora, così bene.

375
00:30:49,585 --> 00:30:54,895
Quindi, facciamo un PUT sui piatti e vediamo cosa succede.

376
00:30:54,895 --> 00:30:56,980
Quando fai un PUT, ovviamente, dice,

377
00:30:56,980 --> 00:31:02,255
«operazione PUT non supportata sui piatti», come ci aspettiamo.

378
00:31:02,255 --> 00:31:03,770
Facciamo un DELETE.

379
00:31:03,770 --> 00:31:05,575
Facendo un'operazione DELETE,

380
00:31:05,575 --> 00:31:09,030
restituisce questa risposta dicendo,

381
00:31:09,030 --> 00:31:10,890
«N è uguale a uno», ok,

382
00:31:10,890 --> 00:31:13,570
uno significa che ha cancellato un piatto.

383
00:31:13,570 --> 00:31:15,660
Facciamo ora di nuovo, eseguire un'operazione GET,

384
00:31:15,660 --> 00:31:22,850
e poi si vedrebbe che i miei piatti sono vuoti come ci aspettavamo.

385
00:31:22,980 --> 00:31:25,930
Quindi, vedi che le

386
00:31:25,930 --> 00:31:28,405
operazioni GET, PUT, POST e DELETE funzionano tutte correttamente.

387
00:31:28,405 --> 00:31:31,225
Ora, lasciami POST il piatto

388
00:31:31,225 --> 00:31:36,110
di nuovo sul server perché voglio avere un piatto nel server.

389
00:31:36,270 --> 00:31:38,725
Quindi, lasciami POST quel piatto,

390
00:31:38,725 --> 00:31:41,425
e noterai che l'ID è ora cambiato.

391
00:31:41,425 --> 00:31:44,110
Quindi, lasciami selezionare quell'ID,

392
00:31:44,110 --> 00:31:50,630
e poi faremo un GET con l'ID in atto.

393
00:31:51,990 --> 00:31:55,405
Quando fai un GET con l'ID in posizione,

394
00:31:55,405 --> 00:32:02,300
vedi che restituisce quel piatto specifico come te lo aspetti.

395
00:32:02,760 --> 00:32:07,630
Andiamo al terminale e vediamo cosa

396
00:32:07,630 --> 00:32:12,125
viene stampato sul terminale o sulla finestra di comando.

397
00:32:12,125 --> 00:32:15,300
Quindi, andando al terminale o alla finestra di comando,

398
00:32:15,300 --> 00:32:19,360
vedi che sta stampando tutte queste cose sulla finestra di comando.

399
00:32:19,360 --> 00:32:21,540
Quindi, quando abbiamo fatto la prima operazione GET,

400
00:32:21,540 --> 00:32:22,640
dice, GET /dish.

401
00:32:22,640 --> 00:32:24,375
Quindi, questo è di nuovo,

402
00:32:24,375 --> 00:32:28,155
Morgan sta facendo questo lavoro per te, sta stampando,

403
00:32:28,155 --> 00:32:31,170
tracciando queste informazioni e dice piatto creato

404
00:32:31,170 --> 00:32:34,575
e poi quella particolare informazione piatto è stata stampata,

405
00:32:34,575 --> 00:32:38,190
e poi dice POST /piatti, GET/piatti,

406
00:32:38,190 --> 00:32:41,130
e poi quando hai fatto un PUT ha restituito un 403

407
00:32:41,130 --> 00:32:44,170
lì e hai creato di nuovo piatti e così via.

408
00:32:44,170 --> 00:32:47,145
Quindi, vedi che il tuo server sta effettivamente facendo tutto il lavoro

409
00:32:47,145 --> 00:32:53,110
e queste cose vengono inserite nel tuo database MongoDB come ti aspettavi.

410
00:32:53,110 --> 00:32:58,540
Ora, tornando al postino,

411
00:32:58,540 --> 00:33:00,850
facciamo un POST sui piatti.

412
00:33:00,850 --> 00:33:03,605
Ora, questo non è supportato sul lato server,

413
00:33:03,605 --> 00:33:04,750
quindi il server dovrebbe dire

414
00:33:04,750 --> 00:33:10,225
«L'operazione POST non è supportata su quel particolare endpoint», come ci si può aspettare.

415
00:33:10,225 --> 00:33:13,070
Facciamo un'operazione PUT.

416
00:33:14,430 --> 00:33:17,190
Quando esegui un'operazione

417
00:33:17,190 --> 00:33:20,955
PUT, quello che farò nell'operazione PUT è che

418
00:33:20,955 --> 00:33:26,860
sostituirò l'etichetta lì dentro.

419
00:33:26,860 --> 00:33:29,550
Quindi, nel mio corpo del messaggio.

420
00:33:29,550 --> 00:33:34,570
Quindi, ricorda che se guardi il file db.json,

421
00:33:34,570 --> 00:33:38,180
l'etichetta per quello sarebbe nuova,

422
00:33:38,180 --> 00:33:51,160
e quindi cambierò quell'etichetta in hot.

423
00:33:51,160 --> 00:33:53,040
Dal momento che questo deve essere in Json,

424
00:33:53,040 --> 00:33:57,895
quindi etichetta anche tra virgolette etichetta Json hot,

425
00:33:57,895 --> 00:34:02,810
e quindi facciamo un PUT su quel particolare endpoint.

426
00:34:04,080 --> 00:34:07,615
L' operazione PUT ha avuto esito positivo

427
00:34:07,615 --> 00:34:12,280
e quindi si vede che quando l'operazione PUT è stata eseguita,

428
00:34:12,280 --> 00:34:19,150
si noterà che l'etichetta ora è cambiata da nuova a hot qui,

429
00:34:19,150 --> 00:34:22,630
e si noti in particolare, il valore

430
00:34:22,630 --> 00:34:28,900
CreatedAt e il valore UpdateDat.

431
00:34:28,900 --> 00:34:31,990
Quindi, si noti che questo record è stato creato

432
00:34:31,990 --> 00:34:36,970
in questo momento ed è stato aggiornato un po 'più tardi.

433
00:34:36,970 --> 00:34:40,000
Quindi, l'aggiornamento è stato fatto dall'operazione PUT che ho appena

434
00:34:40,000 --> 00:34:43,450
eseguito su quel piatto particolare.

435
00:34:43,450 --> 00:34:46,240
Cancelliamo il piatto.

436
00:34:46,240 --> 00:34:49,795
Questo è permesso. Quindi, cancelleremo il piatto,

437
00:34:49,795 --> 00:34:54,100
quindi il piatto verrà cancellato e il valore verrà restituito.

438
00:34:54,100 --> 00:34:58,930
Ora, se si esegue un'operazione GET

439
00:34:58,930 --> 00:35:04,615
sull'endpoint piatti, si vedrà che questo restituirà un vuoto.

440
00:35:04,615 --> 00:35:09,385
Quindi, sei appena riuscito a cancellare il piatto dal nostro database.

441
00:35:09,385 --> 00:35:14,095
Quello che ho intenzione di fare è eseguire

442
00:35:14,095 --> 00:35:20,630
un'operazione GET su un piatto inesistente e vedere cosa succede.

443
00:35:20,630 --> 00:35:23,905
Quando eseguo un'operazione GET su un piatto inesistente,

444
00:35:23,905 --> 00:35:27,300
restituisce null perché quel piatto non esiste.

445
00:35:27,300 --> 00:35:31,570
Quindi, restituisce un valore nullo che dice che il piatto non esiste.

446
00:35:31,570 --> 00:35:40,525
Ora, lasciami eseguire un'operazione GET su un non-ObjectID e vedere cosa succede.

447
00:35:40,525 --> 00:35:44,980
Ritorna come vedi.

448
00:35:44,980 --> 00:35:46,465
Fammi vedere in anteprima.

449
00:35:46,465 --> 00:35:51,840
Quindi, dice, «Cast to ObjectID fallito per valore qui al percorso.»

450
00:35:51,840 --> 00:35:53,840
Quindi, sarò ovviamente questo non è

451
00:35:53,840 --> 00:35:57,565
un ObjectID valido, quindi sono riuscito a eliminarne parte,

452
00:35:57,565 --> 00:36:02,050
e quindi eseguire l'operazione in modo che restituisca un errore dicendo,

453
00:36:02,050 --> 00:36:04,915
quindi vedi che c'è 500 errore interno del server.

454
00:36:04,915 --> 00:36:09,505
Il server non è stato in grado di gestire questo e quindi restituire questo valore qui.

455
00:36:09,505 --> 00:36:11,925
Quindi, dice: «No,

456
00:36:11,925 --> 00:36:13,230
questo non è permesso».

457
00:36:13,230 --> 00:36:18,385
Quindi, perché questo non è un ObjectID valido.

458
00:36:18,385 --> 00:36:22,275
Quindi, anche gli errori vengono gestiti in modo appropriato come vedi qui.

459
00:36:22,275 --> 00:36:26,050
Quindi, lasciami di nuovo, fai un'operazione GET sui piatti

460
00:36:26,050 --> 00:36:27,975
e il tuo server è ancora in esecuzione

461
00:36:27,975 --> 00:36:30,650
e restituirà un valore vuoto qui.

462
00:36:30,650 --> 00:36:34,465
Così, abbiamo visto come modificando

463
00:36:34,465 --> 00:36:40,900
il nostro server API REST per essere in grado di interagire con il server MongoDB.

464
00:36:40,900 --> 00:36:45,775
Ora abbiamo un server API REST a tutti gli effetti che è in grado di memorizzare

465
00:36:45,775 --> 00:36:48,090
, recuperare ed eseguire varie operazioni

466
00:36:48,090 --> 00:36:51,220
sui dati memorizzati sul mio server MongoDB.

467
00:36:51,220 --> 00:36:54,535
Con questo, completiamo questo esercizio.

468
00:36:54,535 --> 00:36:56,290
Quindi, in questo esercizio,

469
00:36:56,290 --> 00:37:05,200
abbiamo visto come siamo in grado di interagire con il nostro server API REST,

470
00:37:05,200 --> 00:37:07,560
e, a sua volta, con il server MongoDB,

471
00:37:07,560 --> 00:37:12,400
e quindi stiamo sfruttando il server MongoDB per memorizzare e recuperare i dati dal server.

472
00:37:12,400 --> 00:37:14,770
Sei in grado di interagire dalla

473
00:37:14,770 --> 00:37:20,225
nostra applicazione Express con il server MongoDB utilizzando Mongoose.

474
00:37:20,225 --> 00:37:24,700
Questo è un buon momento per fare un commit GIT con il messaggio,

475
00:37:24,700 --> 00:37:31,550
«API REST Express with Mongoose Part One».