1
00:00:03,920 --> 00:00:09,645
Wie wir aus dem vorherigen Vortrag in dieser Lektion verstanden haben,

2
00:00:09,645 --> 00:00:12,585
besteht unser Ziel in dieser Lektion darin,

3
00:00:12,585 --> 00:00:16,590
den bereits entwickelten REST-API-Server

4
00:00:16,590 --> 00:00:20,525
zusammen mit dem Zugriff auf die MongoDB-Datenbank zu integrieren.

5
00:00:20,525 --> 00:00:24,060
Wir beginnen also mit dem REST-API-Server

6
00:00:24,060 --> 00:00:27,480
, den wir in der allerersten Lektion in diesem Modul erstellt

7
00:00:27,480 --> 00:00:31,770
haben, und nachdem wir gelernt haben, wie wir von

8
00:00:31,770 --> 00:00:37,220
unserer Knotenanwendung mit Mongoose zum MongoDB-Server interagieren,

9
00:00:37,220 --> 00:00:43,865
werden wir unseren REST API-Server weiter entwickeln, um

10
00:00:43,865 --> 00:00:50,749
den gesamten Pfad zwischen der Clientanforderung, die in den Server kommt,

11
00:00:50,749 --> 00:00:53,840
bis zur entsprechenden Datenbankoperation, die ausgeführt werden soll,

12
00:00:53,840 --> 00:01:00,880
und dann das Erstellen und Senden der Antwort an diesen Client von unserer Server-Site.

13
00:01:00,880 --> 00:01:04,125
Um zu beginnen,

14
00:01:04,125 --> 00:01:08,300
gehen Sie natürlich zuerst zu dem Verwirrungsserver-Ordner, den wir bereits in

15
00:01:08,300 --> 00:01:15,215
der ersten Übung dieses Moduls in der REST-API-Lektion erstellt haben

16
00:01:15,215 --> 00:01:17,915
, und dann

17
00:01:17,915 --> 00:01:22,310
haben wir im Verwirrungsordner bereits den REST-API-Server aufgebaut.

18
00:01:22,310 --> 00:01:26,630
Nun, was wir tun würden, ist,

19
00:01:26,630 --> 00:01:32,035
die Modelle zu leihen, die wir in der vorherigen Übung entwickelt haben,

20
00:01:32,035 --> 00:01:36,050
die Datei dishes.js, die wir in der vorherigen Übung entwickelt, in

21
00:01:36,050 --> 00:01:41,220
das Verwirrungsserver-Projekt kopiert haben,

22
00:01:41,220 --> 00:01:44,430
und auch Bluebird Mongoose installieren,

23
00:01:44,430 --> 00:01:51,225
und ein anderes Modul namens Mongoose Währung, zu unserem Projekt.

24
00:01:51,225 --> 00:01:54,275
Also, wenn wir zu unserem Knoten JS-Ordner gehen,

25
00:01:54,275 --> 00:01:57,050
gehen wir zuerst in den Knoten Mongoose Ordner,

26
00:01:57,050 --> 00:02:01,970
und wir sehen, dass

27
00:02:01,970 --> 00:02:03,810
wir im Unterordner des Knotens Mongoose Ordner die Datei dishes.js haben.

28
00:02:03,810 --> 00:02:07,354
Ich werde nur den Models-Ordner kopieren

29
00:02:07,354 --> 00:02:10,490
und dann zum Verwirrungsserver-Ordner gehen

30
00:02:10,490 --> 00:02:13,910
und dann einfach den Models-Ordner darin durchstechen.

31
00:02:13,910 --> 00:02:15,690
Also, sobald wir das tun,

32
00:02:15,690 --> 00:02:22,540
dann ist die Datei dishes.js, die das Schema und das Modell für das Geschirr Dokument enthält,

33
00:02:22,540 --> 00:02:28,155
in unseren REST API-Server integriert.

34
00:02:28,155 --> 00:02:30,890
Um dies zu nutzen,

35
00:02:30,890 --> 00:02:34,400
müssen wir natürlich das Mongoose-Knotenmodul

36
00:02:34,400 --> 00:02:40,990
und ein neues Knotenmodul, das als Mongoose-Währung bezeichnet wird, in unser Projekt installieren.

37
00:02:40,990 --> 00:02:47,510
Gehen Sie also zum Terminal im Confusion-Server-Projekt,

38
00:02:47,510 --> 00:02:52,640
stellen Sie sicher, dass sich Ihr Terminal oder das Befehlsfenster

39
00:02:52,640 --> 00:02:57,480
im Confusion-Server-Projekt befindet, in dem Sie die REST-API früher entwickeln,

40
00:02:57,480 --> 00:03:01,070
und lassen Sie uns in diesem Projekt installieren.

41
00:03:01,070 --> 00:03:06,165
Also, wir tun npm installieren Mongoose,

42
00:03:06,165 --> 00:03:13,110
und dann, ein neues Knotenmodul als Mongoose Währung genannt.

43
00:03:13,250 --> 00:03:16,630
Das Mungo Währungsknotenmodul,

44
00:03:16,630 --> 00:03:21,800
und in anderen Schema-Typ zu unserer Mungo Anwendung gesehen,

45
00:03:21,800 --> 00:03:23,770
so dass die Mungo selbst,

46
00:03:23,770 --> 00:03:26,390
hat sicherlich bereits integrierte Schema-Typen.

47
00:03:26,390 --> 00:03:29,505
Wir haben die Verwendung der Zahl, der

48
00:03:29,505 --> 00:03:35,550
Zeichenfolge und der Boolean, und das Array gesehen.

49
00:03:35,550 --> 00:03:39,760
Jetzt fügt die Mungo Währung zur Unterstützung der Währung hinzu.

50
00:03:39,760 --> 00:03:42,385
Warum sollten wir diese Währungsunterstützung brauchen?

51
00:03:42,385 --> 00:03:49,040
So dass Mongoose Währungsmodul fügt einen neuen Typ als Währungstyp genannt,

52
00:03:49,040 --> 00:03:53,140
die uns ermöglicht, einen Währungswert zu speichern.

53
00:03:53,140 --> 00:03:56,650
Da unser Gericht einen Preis enthalten

54
00:03:56,650 --> 00:04:00,760
wird, werde ich deshalb hier das Mongoose-Währungsmodul verwenden.

55
00:04:00,760 --> 00:04:04,590
Nun, die Übung hier,

56
00:04:04,590 --> 00:04:07,545
werden wir die Verwendung des Mongoose-Währungsmoduls veranschaulichen,

57
00:04:07,545 --> 00:04:11,880
Sie können mehr Details über das Mongoose-Währungsknotenmodul lesen, auch

58
00:04:11,880 --> 00:04:19,010
in der Dokumentation, dass ein Link zu dem in den zusätzlichen Ressourcen zur Verfügung gestellt wird.

59
00:04:19,010 --> 00:04:22,489
Also, jetzt, da wir diese Knotenmodule installiert haben,

60
00:04:22,489 --> 00:04:24,890
Mongoose und Mongoose Währung,

61
00:04:24,890 --> 00:04:33,920
lassen Sie uns zu unserer Anwendung gehen und es einrichten, um mit dem MongoDB-Server zu kommunizieren. Stellen

62
00:04:33,920 --> 00:04:37,570
Sie nun sicher, dass Ihr MongoDB-Server betriebsbereit ist.

63
00:04:37,570 --> 00:04:40,070
Hier sehen Sie, dass

64
00:04:40,070 --> 00:04:44,730
mein MongoDB-Server in einem anderen Terminal Tab auf meinem Computer läuft.

65
00:04:44,730 --> 00:04:46,670
Wenn Sie es auf einem Windows-Computer ausführen,

66
00:04:46,670 --> 00:04:54,005
stellen Sie sicher, dass es in einem anderen Befehl Fenster Ihres Windows-Computers ausgeführt wird. Wenn wir

67
00:04:54,005 --> 00:04:58,525
zu unserer Anwendung im Editor gehen,

68
00:04:58,525 --> 00:05:01,685
werden wir zuerst mit der Datei app.js beginnen.

69
00:05:01,685 --> 00:05:03,460
Jetzt in der Datei app.js,

70
00:05:03,460 --> 00:05:07,590
hier haben wir unsere Express-Anwendung früher aufgebaut.

71
00:05:07,590 --> 00:05:12,935
Aber jetzt ist diese zusätzliche Suck-Negation nicht mit dem Back-End-MongoDB-Server verbunden.

72
00:05:12,935 --> 00:05:18,085
Wir werden das Mongoose-Modul nutzen,

73
00:05:18,085 --> 00:05:20,430
um die Verbindung mit dem Server herzustellen.

74
00:05:20,430 --> 00:05:22,385
Also, hier reingehen,

75
00:05:22,385 --> 00:05:29,540
werde ich das Mungo Modul hier hinzufügen.

76
00:05:29,540 --> 00:05:35,850
Also sagen wir: „Const Mongoose braucht Mungo.“

77
00:05:38,120 --> 00:05:43,280
Und dann auch, da wir über den Models-Ordner kopiert haben,

78
00:05:43,280 --> 00:05:46,520
der die Gerichte Datei enthält,

79
00:05:46,520 --> 00:05:51,220
die das Geschirr Schema und das Modell deklariert.

80
00:05:51,220 --> 00:05:56,645
Also, lassen Sie mich das Geschirr importieren.

81
00:05:56,645 --> 00:06:04,930
Also, wir werden sagen, „erforderlich.Slash Modelle Gerichte.“

82
00:06:04,930 --> 00:06:07,640
Also, sobald wir das abgeschlossen haben,

83
00:06:07,640 --> 00:06:11,000
müssen wir jetzt natürlich die Verbindung mit dem Server herstellen.

84
00:06:11,000 --> 00:06:13,560
Also, richten Sie

85
00:06:14,120 --> 00:06:24,960
URL mongodb// localhost7017/Verwirrung,

86
00:06:27,340 --> 00:06:31,150
genau wie wir es mit der Mungo Übung getan haben,

87
00:06:31,150 --> 00:06:33,140
und dann werden wir sagen,

88
00:06:33,140 --> 00:06:44,040
„Const connect, Mongos connect URL“.

89
00:06:44,040 --> 00:06:51,450
Dies ist also genau der gleiche Code, den wir in der vorherigen Übung verwendet haben.

90
00:06:51,450 --> 00:06:53,640
Dann stellen wir die Verbindung her.

91
00:06:53,640 --> 00:07:01,695
Also, wir werden sagen, „connect“ und dann sagen wir,

92
00:07:01,695 --> 00:07:11,610
„DB tun es Konsolenprotokoll.“

93
00:07:11,610 --> 00:07:19,030
Sprich: „Richtig mit dem Server verbunden“.

94
00:07:21,020 --> 00:07:26,260
Und wir werden auch den Fehler hier behandeln.

95
00:07:33,980 --> 00:07:40,855
Wir werden einfach ein Konsolenprotokoll des Fehlers hier machen, das war's.

96
00:07:40,855 --> 00:07:49,110
Dadurch wird die Verbindung zum Server aus unserer Datei app.js hergestellt.

97
00:07:49,110 --> 00:07:52,375
Also, sobald wir die Verbindung zum Server hergestellt

98
00:07:52,375 --> 00:07:58,615
haben, öffnen wir die Datei dishes.js von unseren Modellen.

99
00:07:58,615 --> 00:08:00,995
Jetzt, in der Datei dishes.js,

100
00:08:00,995 --> 00:08:02,970
um

101
00:08:02,970 --> 00:08:11,760
das Knotenmodul zu verwenden, das wir gerade installiert haben.

102
00:08:11,760 --> 00:08:18,990
Also sagen wir: „Erfordert Mungo Währung“ und sagen:

103
00:08:18,990 --> 00:08:26,500
„Lade den Typ und Mungo.“

104
00:08:26,500 --> 00:08:32,670
Also, was das tun wird, ist, diesen neuen Währungstyp in Mongoose zu laden.

105
00:08:32,670 --> 00:08:39,970
Danach können wir sagen const,

106
00:08:39,970 --> 00:08:48,705
Währung Mongoose Typen Währung.

107
00:08:48,705 --> 00:08:51,720
Das war's. Also, dieser neue Typ,

108
00:08:51,720 --> 00:08:57,880
der Währungstyp wird in Mungo hinzugefügt und das wird in einem neuen Typ namens

109
00:08:57,880 --> 00:09:00,160
Währung hinzufügen und dann werde ich

110
00:09:00,160 --> 00:09:04,840
diese konstante Währung als die Mungo Typen Währung deklarieren.

111
00:09:04,840 --> 00:09:11,630
Damit ich dies bei der Definition des Schemas in meiner Anwendung nutzen kann.

112
00:09:11,630 --> 00:09:14,270
Nun, in diesem Fall

113
00:09:14,270 --> 00:09:17,970
bleibt das gemeinsame Schema genau das gleiche wie zuvor, aber

114
00:09:17,970 --> 00:09:24,060
das Dish-Schema, wie Sie sich aus der Datei db.json erinnern.

115
00:09:24,060 --> 00:09:28,050
Wenn Sie sich die Struktur eines Geschirrdokuments ansehen,

116
00:09:28,050 --> 00:09:35,630
sehen Sie, dass das Dokument den Namen und das Bild enthält, das, wie Sie hier sehen, eine Zeichenfolge,

117
00:09:35,630 --> 00:09:38,570
eine Kategorie, ein Etikett,

118
00:09:38,570 --> 00:09:42,555
ein Preis ist, der hier ein String-Typ ist.

119
00:09:42,555 --> 00:09:46,865
Aber wir werden dies als Währungstyp deklarieren,

120
00:09:46,865 --> 00:09:51,495
ein Feature, das, wie Sie erwarten, ist eine boolesche Variable,

121
00:09:51,495 --> 00:09:55,015
und eine Beschreibung, die eine Zeichenfolge ist und dann Kommentare

122
00:09:55,015 --> 00:09:59,755
, die nichts anderes als ein Array von Kommentaren Typ ist.

123
00:09:59,755 --> 00:10:05,790
Nun, was wir jetzt tun werden, ist, das Dish-Schema zu erweitern, um

124
00:10:05,790 --> 00:10:12,865
all diese verschiedenen Eigenschaften oder verschiedene Felder in meinem json-Dokument zu unterstützen.

125
00:10:12,865 --> 00:10:15,225
Also haben wir schon den Namen.

126
00:10:15,225 --> 00:10:18,505
So haben wir bereits die Beschreibung an Ort und Stelle.

127
00:10:18,505 --> 00:10:23,730
Also müssen wir in den nächsten paar dort hinzufügen, haben wir bereits die Kommentare,

128
00:10:23,730 --> 00:10:27,185
das Array von Kommentaren des Kommentarschematyps gibt.

129
00:10:27,185 --> 00:10:30,075
Also werden wir in den nächsten paar hinzufügen.

130
00:10:30,075 --> 00:10:34,150
Der nächste, den wir hinzufügen werden, ist der Bildtyp

131
00:10:34,150 --> 00:10:37,640
,

132
00:10:37,640 --> 00:10:44,300
der vom Typ String sein würde und

133
00:10:44,300 --> 00:10:49,140
wir sagen, erforderlich wahr.

134
00:10:49,200 --> 00:10:52,240
Dies fügt also den Bildtyp hinzu.

135
00:10:52,240 --> 00:11:00,460
Die nächste, die ich hinzufügen werde, ist Kategorie,

136
00:11:00,460 --> 00:11:03,865
die auch der String-Typ ist.

137
00:11:03,865 --> 00:11:07,990
Die nächste ist die Bezeichnung,

138
00:11:07,990 --> 00:11:10,720
die auch dieser String-Typ ist.

139
00:11:10,720 --> 00:11:14,560
Da alle diese vom gleichen Typ sind und benötigt werden,

140
00:11:14,560 --> 00:11:16,625
kopiere ich sie hier rein.

141
00:11:16,625 --> 00:11:18,464
Dann

142
00:11:18,464 --> 00:11:21,275
würde ich für das Label sagen, dass dies nicht erforderlich ist, aber

143
00:11:21,275 --> 00:11:26,945
stattdessen kann ich auch einen Standardwert angeben, wenn ich möchte.

144
00:11:26,945 --> 00:11:29,465
So kann ich einen Standardwert wie diesen angeben.

145
00:11:29,465 --> 00:11:31,965
Der Standardwert ist eine leere Zeichenfolge.

146
00:11:31,965 --> 00:11:37,245
Also, wenn ich nicht erforderlich spezifiziere, kann ich hier einfach einen Standardwert angeben.

147
00:11:37,245 --> 00:11:46,300
Nun, das nächste Feld, das ich einführen werde, ist das Preisfeld.

148
00:11:47,070 --> 00:11:53,575
Das Preisfeld Ich deklariere den Typ als Währung.

149
00:11:53,575 --> 00:11:57,085
Erinnern Sie sich, dass wir den Währungstyp früher

150
00:11:57,085 --> 00:12:00,380
hier deklariert hatten, indem wir zuerst

151
00:12:00,380 --> 00:12:03,960
das Währungsmodul Mongoose und dann den Währungstyp deklarieren.

152
00:12:03,960 --> 00:12:09,435
Also, so würden Sie den Währungstyp in unserer Anwendung verwenden.

153
00:12:09,435 --> 00:12:16,170
Also werden wir sagen, Preisart Währung und

154
00:12:16,170 --> 00:12:24,610
erforderlich ist wahr und dann kann ich auch den Mindestwert angeben, der Null wäre.

155
00:12:24,610 --> 00:12:29,590
Dann ist das nächste Feld

156
00:12:29,590 --> 00:12:35,830
das Featured Feld, das vom Typ Boolean sein würde,

157
00:12:35,830 --> 00:12:40,900
und der Standardwert ist false.

158
00:12:40,900 --> 00:12:43,625
Also, wenn mein Dokument das fehlt,

159
00:12:43,625 --> 00:12:47,940
dann wird der Standardwert hier in das Dokument eingefügt.

160
00:12:47,940 --> 00:12:50,470
Beachten Sie also, dass ich nun

161
00:12:50,470 --> 00:12:56,825
das Schema-Schema erweitert habe, indem ich den Bildtyp, die Kategorie, das

162
00:12:56,825 --> 00:13:01,710
Etikett, den Preis und die Funktion hinzufüge, um

163
00:13:01,710 --> 00:13:07,925
die Struktur des Dokumentbeispiels, das ich Ihnen gerade gezeigt habe, übereinstimmte.

164
00:13:07,925 --> 00:13:13,795
Also jetzt, mein Geschirr Schema ist alles bereit, verwendet zu werden.

165
00:13:13,795 --> 00:13:20,185
Also, lasst uns jetzt anfangen, an meinem Router zu arbeiten.

166
00:13:20,185 --> 00:13:21,915
Also, wo ist der Router?

167
00:13:21,915 --> 00:13:29,530
Sie erinnern sich, dass der Router, der die REST-API-Endpunkte für die Schrägschrägschalen,

168
00:13:29,530 --> 00:13:32,110
REST-API-Endpunkt und

169
00:13:32,110 --> 00:13:35,170
Schrägschrägschüssel-ID-Endpunkt unterstützt, im Dish Router ist.

170
00:13:35,170 --> 00:13:41,295
Also, wir werden zu Gericht router.jsfile gehen und dann werden wir das Gericht router.js Datei erweitern.

171
00:13:41,295 --> 00:13:46,735
Also, im Dish Router zusammen mit Express und BodyParser,

172
00:13:46,735 --> 00:13:55,310
werde ich jetzt Mongoose einschließen.

173
00:13:56,640 --> 00:14:03,370
Also werden wir sagen, erfordern Mungo und

174
00:14:03,370 --> 00:14:10,944
dann werden wir Gerichte Modell benötigen.

175
00:14:10,944 --> 00:14:12,400
Wo ist das Geschirr Modell?

176
00:14:12,400 --> 00:14:20,080
Es ist drin. /Modelle/Geschirr.

177
00:14:20,080 --> 00:14:22,405
Also ist es da drin.

178
00:14:22,405 --> 00:14:24,470
Beachten Sie also, dass wir uns im Ordner des Routers befinden,

179
00:14:24,470 --> 00:14:27,610
also müssen Sie eine Ebene nach oben gehen und dann in

180
00:14:27,610 --> 00:14:31,460
den Ordner des Modells gehen und dann ist die Datei dishes.js genau dort.

181
00:14:31,460 --> 00:14:34,010
Das ist es, was wir hier importieren.

182
00:14:34,010 --> 00:14:41,039
Jetzt kann ich meinen Dish Router aktualisieren, um

183
00:14:41,039 --> 00:14:46,330
mit dem MongoDB-Server mit

184
00:14:46,330 --> 00:14:52,175
Mongoose interagieren zu können und wir haben das Geschirr Modell bereits in meinen Geschirrrouter importiert.

185
00:14:52,175 --> 00:14:57,720
Also, es ist Zeit für mich zu gehen und alle Methoden hier zu aktualisieren.

186
00:14:57,720 --> 00:14:59,465
Also für den Teller Router,

187
00:14:59,465 --> 00:15:03,665
der Schrägstrich, was bedeutet, dass der Schrägstrich Geschirr Endpunkt.

188
00:15:03,665 --> 00:15:07,880
Ich werde das alles von hier entfernen, stattdessen

189
00:15:07,880 --> 00:15:12,040
werde ich alle verschiedenen Endpunkte explizit deklarieren.

190
00:15:12,040 --> 00:15:16,995
Um Post setzen und löschen zu lassen, werde ich jeden von ihnen unabhängig behandeln.

191
00:15:16,995 --> 00:15:19,135
Also in der Get-Methode

192
00:15:19,135 --> 00:15:24,360
werde ich das ausschneiden und dann in der Get-Methode, was muss ich tun?

193
00:15:24,360 --> 00:15:32,760
Daran erinnern, dass wir Methode von Mongoose definiert hatten, die uns erlaubt, alle Gerichte zu finden.

194
00:15:32,760 --> 00:15:36,365
Wenn Sie also eine Get-Operation auf dem Schrägschrägschüssel-Endpunkt durchführen,

195
00:15:36,365 --> 00:15:39,600
erwarten Sie, dass alle Gerichte

196
00:15:39,600 --> 00:15:44,005
an den Client als Antwort auf die Get-Anfrage zurückgegeben werden.

197
00:15:44,005 --> 00:15:49,890
Also werde ich zum Geschirr gehen und dann die Suchoperation durchführen.

198
00:15:49,890 --> 00:15:53,040
Jetzt sehen Sie, dass

199
00:15:53,040 --> 00:15:58,585
ich von meinem Express-Server auf meine MongoDB zugreife.

200
00:15:58,585 --> 00:16:06,520
Also, wird eine Suche machen und in der Suche werde ich jetzt die Anfrage behandeln.

201
00:16:06,520 --> 00:16:08,310
Also kann ich sagen, Gerichte finden,

202
00:16:08,310 --> 00:16:13,885
da das ein Versprechen zurückgeben wird,

203
00:16:13,885 --> 00:16:16,765
dann kann ich das hier drinnen regeln.

204
00:16:16,765 --> 00:16:24,520
Also, ich werde sagen Gericht und so, wenn das Versprechen richtig aufgelöst wird,

205
00:16:24,520 --> 00:16:33,529
werde ich es in der dann bekommen und so werde ich sagen Gericht und dann werden wir res

206
00:16:33,960 --> 00:16:41,125
Statuscode behandeln 200 und dann sagen wir

207
00:16:41,125 --> 00:16:48,920
res set Header Inhaltstyp.

208
00:16:53,100 --> 00:16:57,830
Da wir den Wert als JSON zurückgeben werden,

209
00:16:57,830 --> 00:17:00,770
setzen wir das auf Anwendung json.

210
00:17:00,770 --> 00:17:03,580
Okay, das wird eine Reihe von Gerichten zurückgeben.

211
00:17:03,580 --> 00:17:07,955
Also kann ich einfach Gerichte sagen und dann sagen wir res.json.

212
00:17:07,955 --> 00:17:12,650
Also wird die res.json als Eingabe in json-Zeichenfolge nehmen

213
00:17:12,650 --> 00:17:17,680
und sie dann an meinen Client zurücksenden.

214
00:17:17,680 --> 00:17:21,785
Also, wenn Sie res.json aufrufen und den Wert angeben und dann wird es einfach

215
00:17:21,785 --> 00:17:27,650
den Parameter nehmen, den Sie hier geben, und dann senden Sie ihn als JSON-Antwort zurück.

216
00:17:27,650 --> 00:17:30,365
Es wird dieses Geschirr in den Text

217
00:17:30,365 --> 00:17:33,835
der Antwortnachricht geben und dann an den Server zurücksenden.

218
00:17:33,835 --> 00:17:39,560
Jetzt können wir den Fehler

219
00:17:39,560 --> 00:17:47,370
hier behandeln, indem wir nächsten Fehler sagen.

220
00:17:48,100 --> 00:17:59,140
Wir können auch einen Catch-Fehler nur aus Gründen der vollständigen tun.

221
00:17:59,140 --> 00:18:03,290
Ich werde hier nur beides einführen,

222
00:18:03,290 --> 00:18:05,960
damit beide als solches behandelt werden.

223
00:18:05,960 --> 00:18:08,305
Wenn also ein Fehler zurückgegeben wird

224
00:18:08,305 --> 00:18:11,740
, wird der Fehler einfach an

225
00:18:11,740 --> 00:18:15,260
den allgemeinen Fehlerbehandler für meine Anwendung übergeben

226
00:18:15,260 --> 00:18:18,985
und sich darum kümmern, wie mit dem Fehler umzugehen ist.

227
00:18:18,985 --> 00:18:21,490
Also werden wir es dahin schicken.

228
00:18:21,490 --> 00:18:28,610
Sie sehen also, wie ich die Suchoperation verwende und dann die Anfrage hier durchführe.

229
00:18:28,610 --> 00:18:30,595
Nun, für den Beitrag,

230
00:18:30,595 --> 00:18:32,904
wie Sie bereits erwartet hätten,

231
00:18:32,904 --> 00:18:37,100
werde ich dishes.create tun,

232
00:18:38,790 --> 00:18:43,425
weil wir hier ein neues Gericht erstellen werden.

233
00:18:43,425 --> 00:18:47,195
Also, erinnern Sie sich, dass wir bereits gesehen haben, dass die Gerichte die

234
00:18:47,195 --> 00:18:52,400
Methodenverwendung früher erstellen und denken Sie daran, dass der Body

235
00:18:52,400 --> 00:18:56,950
Parser bereits alles analysiert hätte, was sich im Körper der Nachricht befindet und es

236
00:18:56,950 --> 00:19:01,510
auf die Körpereigenschaft der Anfrage geladen hat.

237
00:19:01,510 --> 00:19:08,650
Also, ich werde nur den Anforderungskörper nehmen und ihn dann als Parameter für meine

238
00:19:08,650 --> 00:19:16,120
dishes.create-Methode analysieren und den Rückgabewert behandeln.

239
00:19:16,120 --> 00:19:21,325
Also, dann sagen wir, und das würde

240
00:19:21,325 --> 00:19:26,755
ein Gericht zurückgeben und wir werden das hier drinnen erledigen.

241
00:19:26,755 --> 00:19:35,220
Also werden wir sagen, wenn das Geschirr richtig zurückkehren und wenn Gerichte richtig geschrieben, wird es sagen.

242
00:19:36,060 --> 00:19:43,045
Okay, lasst uns eine console.log für unsere eigene Verwendung machen.

243
00:19:43,045 --> 00:19:52,330
Auf der Server-Seite werden wir hier ein console.log sagen „Dish Created“ Gericht machen.

244
00:19:52,330 --> 00:20:02,125
Lassen Sie uns das Gericht in die Konsole einloggen und dann sagen wir diese beiden Ruhestatus-Code.

245
00:20:02,125 --> 00:20:09,820
Wir kopieren einfach diesen Code und fügen ihn dort ein und in diesem Fall

246
00:20:09,820 --> 00:20:12,445
geben wir das Gericht zurück.

247
00:20:12,445 --> 00:20:16,480
Das Gericht, das hier als Parameter hereingekommen ist und dann

248
00:20:16,480 --> 00:20:22,825
den Kunden mit diesem Wert auf der Client-Seite umgehen lassen,

249
00:20:22,825 --> 00:20:24,985
was auch immer in der Schüssel zurückgegeben wird.

250
00:20:24,985 --> 00:20:27,745
Nun, auch sie werden in

251
00:20:27,745 --> 00:20:41,770
diesem hier und dann den Fang hinzufügen.

252
00:20:41,770 --> 00:20:44,860
So behandeln wir die Post.

253
00:20:44,860 --> 00:20:47,830
Für die PUT, weil PUT nicht erlaubt ist,

254
00:20:47,830 --> 00:20:50,365
so werden wir es als solche verlassen.

255
00:20:50,365 --> 00:20:54,250
Für DELETE werden wir alle Gerichte löschen.

256
00:20:54,250 --> 00:21:02,240
Also sagen wir: „Gerichte.Entfernen.“

257
00:21:03,990 --> 00:21:08,185
Dies ist im Wesentlichen eine gefährliche Operation.

258
00:21:08,185 --> 00:21:11,080
So entfernen Sie alle Gerichte vom

259
00:21:11,080 --> 00:21:18,610
Server und so werden wir sagen,

260
00:21:18,610 --> 00:21:25,600
„Gerichte.Entfernen Sie dann“ und die „dann“ wird eine Antwort zu bekommen.

261
00:21:25,600 --> 00:21:32,200
Also werden wir einfach sagen, „resp hier“ und die Art und Weise, wie wir mit

262
00:21:32,200 --> 00:21:40,550
dieser Antwort umgehen würden, ist einfach, diesen Wert zu nehmen und ihn dann an den Client zurückzugeben.

263
00:21:40,620 --> 00:21:48,550
Also werden wir sagen, „Res.StatusCode 200 Inhaltstyp Anwendung json“, und

264
00:21:48,550 --> 00:21:56,660
dann senden wir einfach die Antwort zurück an den Client und wir werden den Fehler

265
00:22:06,000 --> 00:22:08,830
wie zuvor behandeln.

266
00:22:08,830 --> 00:22:10,390
Das ist der DELETE-Vorgang.

267
00:22:10,390 --> 00:22:14,110
Sie sehen also, dass wir jetzt die GET,

268
00:22:14,110 --> 00:22:17,545
POST, PUT und die DELETE-Operation machen.

269
00:22:17,545 --> 00:22:26,425
Jetzt werden wir das gleiche mit dem Endpunkt /dishid fortsetzen.

270
00:22:26,425 --> 00:22:28,270
Also in diesem Fall

271
00:22:28,270 --> 00:22:34,040
sind wir speziell Motiv, ein bestimmtes Gericht zu bekommen.

272
00:22:34,040 --> 00:22:39,480
Wir werden diesen spezifischen Wert zurückgeben.

273
00:22:39,480 --> 00:22:41,445
Also in der GET,

274
00:22:41,445 --> 00:22:51,275
was wir tun, ist, dass wir sagen „dishes.findById.

275
00:22:51,275 --> 00:22:57,965
Die FindById ist also eine Methode, die sowohl vom MongoDB-Treiber als auch vom MongoDB-Treiber zur Verfügung steht.

276
00:22:57,965 --> 00:23:02,020
Also sagen wir:“ Req.params.dishid.“

277
00:23:03,600 --> 00:23:11,030
Daran erinnern, dass wir bereits wissen, dass die Schale ID in der params Eigenschaft vorhanden ist.

278
00:23:11,030 --> 00:23:14,140
Sie haben bereits früher davon erfahren.

279
00:23:14,140 --> 00:23:20,260
Also werde ich sagen, „findById (req.params.dishid)“ und

280
00:23:20,260 --> 00:23:24,565
dann und das andere.

281
00:23:24,565 --> 00:23:30,520
Also werde ich das dann und sonst von

282
00:23:30,520 --> 00:23:38,170
dort kopieren und dann runter zum DishRouter kommen und

283
00:23:38,170 --> 00:23:46,150
das dann einfach hier einfügen.

284
00:23:46,150 --> 00:23:49,190
Also sagen wir, "res.StatusCode200

285
00:23:49,440 --> 00:23:55,585
Anwendung json.res.jsondish und dann die Fehlerbehandlung.

286
00:23:55,585 --> 00:24:05,350
Für den POST werden wir natürlich nicht den Beitrag für einen /dishid-Endpunkt behandeln.

287
00:24:05,350 --> 00:24:07,635
Also werden wir es als solche verlassen.

288
00:24:07,635 --> 00:24:12,740
Für PUT werden wir

289
00:24:12,740 --> 00:24:17,975
ein bestimmtes Gericht aktualisieren, das durch seine Schalen-ID identifiziert wird.

290
00:24:17,975 --> 00:24:25,270
Dies ist also, wo wir dishes.findByIdandUpdate verwenden.

291
00:24:25,270 --> 00:24:27,690
Dies ist also die Methode, die wir verwenden werden,

292
00:24:27,690 --> 00:24:35,539
findByIdanduUpdate und dies nimmt als erster Parameter

293
00:24:37,410 --> 00:24:44,410
req.params.dishid und der zweite Wert ist

294
00:24:44,410 --> 00:24:53,290
der Satz und das Update

295
00:24:53,290 --> 00:24:55,150
wird im Hauptteil der Nachricht sein.

296
00:24:55,150 --> 00:24:57,580
Also werde ich das einfach aus

297
00:24:57,580 --> 00:25:05,410
dem Req-Körper abrufen und dann auch die andere Flagge, die ich haben werde.

298
00:25:05,410 --> 00:25:10,840
Also wird sagen, „new: true“, so dass diese FindById-Methode

299
00:25:10,840 --> 00:25:18,730
das aktualisierte Gericht als JSON-Zeichenfolge in der Antwort zurückgibt.

300
00:25:18,730 --> 00:25:23,650
Also, das ist, was ich hier bekommen werde, und wenn dieser Wert kommt,

301
00:25:23,650 --> 00:25:26,230
werde ich einfach das Gericht nehmen und

302
00:25:26,230 --> 00:25:39,040
dann einfach das Gericht an die Kundenseite zurückgeben.

303
00:25:39,040 --> 00:25:47,095
Also werde ich res.jason (Gericht) sagen und dann werden wir den Fehler entsprechend behandeln.

304
00:25:47,095 --> 00:25:49,090
Endlich für die DELETE.

305
00:25:49,090 --> 00:25:54,880
Für die DELETE wieder

306
00:25:54,880 --> 00:26:01,165
ist die entsprechende Methode, die wir verwenden werden, die Mongo-Methode namens FindByIdAndRemove.

307
00:26:01,165 --> 00:26:03,760
So können Sie sehen, dass wir diese Methode namens

308
00:26:03,760 --> 00:26:08,080
findByIdAndRemove und diese findByIdAndRemove haben,

309
00:26:08,080 --> 00:26:18,355
wird req.params.dishid nehmen, weil das das Gericht ist, das wir zu entfernen versuchen.

310
00:26:18,355 --> 00:26:20,970
Dann, wenn dies gelöscht wird,

311
00:26:20,970 --> 00:26:23,940
so genau wie wir dies hier behandelt haben,

312
00:26:23,940 --> 00:26:30,830
also werde ich nur diesen Code aus den Gerichten zu kopieren.Entfernen.

313
00:26:30,830 --> 00:26:34,350
Ist das Gleiche, was ich auch hier tun werde.

314
00:26:34,350 --> 00:26:38,750
Also FindByIdAndRemove und welche Antwort ich bekomme,

315
00:26:38,750 --> 00:26:41,970
werde ich es an meinen Client zurückgeben.

316
00:26:41,970 --> 00:26:45,490
Damit haben wir den DishRouter aktualisiert.

317
00:26:45,490 --> 00:26:49,960
Lassen Sie uns alle Änderungen speichern, die wir

318
00:26:49,960 --> 00:26:57,185
bisher gemacht haben, und dann gehen wir und starten unseren Server und sehen dann, was er tut.

319
00:26:57,185 --> 00:27:01,370
Gehen Sie also zum Terminal oder zum Befehlsfenster, starten Sie den Server.

320
00:27:01,370 --> 00:27:06,045
Also werde ich sagen „npm start“ und der Server ist jetzt einsatzbereit.

321
00:27:06,045 --> 00:27:12,030
Wir werden den Postboten benutzen, um mit diesem Server zu kommunizieren.

322
00:27:12,030 --> 00:27:15,700
Gehen wir also zum Postboten und führen dann bestimmte Operationen durch.

323
00:27:15,700 --> 00:27:19,030
Hier siehst du meinen Postboten hier rauf und rennt.

324
00:27:19,030 --> 00:27:26,450
Lassen Sie mich also eine GET-Operation auf dem localhost machen: 3000/Gerichte.

325
00:27:28,300 --> 00:27:31,875
Wenn Sie also eine GET-Operation ausführen, wie Sie sehen,

326
00:27:31,875 --> 00:27:33,205
wird eine leere Zeichenfolge zurückgegeben.

327
00:27:33,205 --> 00:27:36,715
Meine Datenbank ist jetzt leer, so dass ich nichts dort habe.

328
00:27:36,715 --> 00:27:40,205
Also werde ich nur eine leere Zeichenfolge zurückgegeben werden.

329
00:27:40,205 --> 00:27:45,600
Lassen Sie uns ein Gericht posten.

330
00:27:46,020 --> 00:27:48,340
Also, wenn Sie ein Gericht veröffentlichen,

331
00:27:48,340 --> 00:27:50,254
offensichtlich im Körper,

332
00:27:50,254 --> 00:27:58,175
werden Sie ein Gericht umschließen und der Körper wird auf den Anwendungs-JSON-Typ eingestellt.

333
00:27:58,175 --> 00:28:00,785
Nun, um ein Gericht zu posten,

334
00:28:00,785 --> 00:28:06,770
habe ich Ihnen bereits die Datei db.json in den Übungsressourcen gegeben.

335
00:28:06,770 --> 00:28:10,880
Öffnen Sie einfach die Datei db.json und kopieren Sie dann das erste Gericht von

336
00:28:10,880 --> 00:28:15,390
dort und dann fügen wir es hier ein und posten Sie das Gericht.

337
00:28:15,390 --> 00:28:18,735
Also, lassen Sie mich zur Datei db.jason gehen.

338
00:28:18,735 --> 00:28:21,550
Lassen Sie mich das allererste Gericht von hier kopieren.

339
00:28:21,550 --> 00:28:22,810
Also werde ich nur

340
00:28:22,810 --> 00:28:32,765
das ganze Gericht den ganzen Weg bis dorthin kopieren und dann werde ich dieses Gericht posten.

341
00:28:32,765 --> 00:28:36,610
Dies enthält viele der Felder, die wir hier bereits haben.

342
00:28:36,610 --> 00:28:39,895
Lassen Sie uns dieses Gericht auf dem Server posten und sehen, was passiert.

343
00:28:39,895 --> 00:28:44,605
Also komm zurück zum Postboten.

344
00:28:44,605 --> 00:28:47,620
Hier, in den Formulardaten,

345
00:28:47,620 --> 00:28:51,535
im Körper, lassen Sie mich das Gericht an Ort und Stelle einfügen.

346
00:28:51,535 --> 00:28:54,760
Also, wir haben die vollständigen Details des Gerichts dort.

347
00:28:54,760 --> 00:28:58,010
Lassen Sie uns dieses Gericht auf den Server POSTEN.

348
00:28:58,320 --> 00:29:01,780
Dann, sobald das Gericht auf dem Server veröffentlicht wurde,

349
00:29:01,780 --> 00:29:06,580
sehen Sie, dass der Postman hat,

350
00:29:06,580 --> 00:29:09,700
lassen Sie mich dies einfach verkleinern,

351
00:29:09,700 --> 00:29:18,370
und dann sehen Sie unten, dass dieses spezielle Gericht

352
00:29:18,370 --> 00:29:20,290
von meinem Server in die Datenbank, in die MongoDB-Datenbank gepostet wurde.

353
00:29:20,290 --> 00:29:23,560
Sie sehen also, dass der zurückgegebene Wert

354
00:29:23,560 --> 00:29:30,760
hier zeigt, wann das Gericht in diesen Server eingefügt wurde.

355
00:29:30,760 --> 00:29:35,020
Sie haben also die CreateDat und UpdateDat hinzugefügt.

356
00:29:35,020 --> 00:29:39,880
Sie sehen, dass alle verbleibenden Felder dort gespeichert sind.

357
00:29:39,880 --> 00:29:45,865
Beachten Sie insbesondere, wie der Preiswert dort gespeichert wird.

358
00:29:45,865 --> 00:29:49,820
Auf diese Weise speichert die Währung den Preiswert.

359
00:29:50,630 --> 00:29:53,825
Wenn Sie also den Rückgabewert erhalten,

360
00:29:53,825 --> 00:29:59,370
müssen Sie dies auf Ihrer Clientseite entsprechend interpretieren, was das bedeutet.

361
00:29:59,370 --> 00:30:08,510
Beachten Sie auch, dass die ID zu meinem Gericht hinzugefügt wurde und für jeden Kommentar selbst,

362
00:30:08,510 --> 00:30:11,445
da jeder der Kommentare selbst ein Unterdokument ist.

363
00:30:11,445 --> 00:30:14,370
Sie werden die UpdateDat und CreateDat hinzugefügt,

364
00:30:14,370 --> 00:30:21,115
und die ID für jeden der Kommentare werden ebenfalls automatisch von meiner Datenbank hinzugefügt.

365
00:30:21,115 --> 00:30:23,080
Da gehst du. Nun

366
00:30:23,080 --> 00:30:26,875
wurde dieses Gericht meiner Datenbank hinzugefügt.

367
00:30:26,875 --> 00:30:29,589
Lassen Sie uns erneut die GET-Operation durchführen,

368
00:30:29,589 --> 00:30:32,244
und offensichtlich

369
00:30:32,244 --> 00:30:37,135
sollte der Server an diesem Punkt das eine bestimmte Gericht zurückgeben, das hinzugefügt wurde.

370
00:30:37,135 --> 00:30:39,775
So wird es hier eine Reihe von Gerichten zurückgeben,

371
00:30:39,775 --> 00:30:42,190
so wie Sie sehen können, gibt es eine Reihe von Gerichten zurück.

372
00:30:42,190 --> 00:30:44,050
Natürlich enthält dieses Array nur ein Gericht

373
00:30:44,050 --> 00:30:47,245
oder dieses spezielle Gericht wurde hierher zurückgegeben.

374
00:30:47,245 --> 00:30:49,585
So weit, so gut.

375
00:30:49,585 --> 00:30:54,895
Also, lasst uns einen PUT auf das Geschirr machen und sehen, was passiert.

376
00:30:54,895 --> 00:30:56,980
Wenn Sie eine PUT tun, offensichtlich, es sagt,

377
00:30:56,980 --> 00:31:02,255
„PUT-Operation nicht auf Geschirr unterstützt“, wie wir erwarten.

378
00:31:02,255 --> 00:31:03,770
Lassen Sie uns ein DELETE machen.

379
00:31:03,770 --> 00:31:05,575
Wenn Sie eine DELETE-Operation ausführen,

380
00:31:05,575 --> 00:31:09,030
gibt es diese Antwort zurück, die besagt:

381
00:31:09,030 --> 00:31:10,890
„N ist gleich eins“, okay,

382
00:31:10,890 --> 00:31:13,570
eine bedeutet, dass es ein Gericht gelöscht hat.

383
00:31:13,570 --> 00:31:15,660
Lassen Sie uns jetzt wieder eine GET-Operation durchführen,

384
00:31:15,660 --> 00:31:22,850
und dann würden Sie sehen, dass mein Geschirr leer ist, wie wir erwartet haben.

385
00:31:22,980 --> 00:31:25,930
Sie sehen also, dass die

386
00:31:25,930 --> 00:31:28,405
Operationen GET, PUT, POST und DELETE korrekt funktionieren.

387
00:31:28,405 --> 00:31:31,225
Nun, lassen Sie mich das Gericht wieder

388
00:31:31,225 --> 00:31:36,110
auf den Server posten, weil ich ein Gericht im Server haben möchte.

389
00:31:36,270 --> 00:31:38,725
Also, lassen Sie mich dieses Gericht POSTEN,

390
00:31:38,725 --> 00:31:41,425
und Sie würden feststellen, dass sich die ID jetzt geändert hat.

391
00:31:41,425 --> 00:31:44,110
Also, lassen Sie mich diese ID auswählen,

392
00:31:44,110 --> 00:31:50,630
und dann werden wir ein GET mit der ID an Ort und Stelle tun.

393
00:31:51,990 --> 00:31:55,405
Wenn Sie ein GET mit der ID durchführen,

394
00:31:55,405 --> 00:32:02,300
sehen Sie, dass es dieses spezifische Gericht wie erwartet zurückgibt.

395
00:32:02,760 --> 00:32:07,630
Gehen wir zum Terminal und sehen, was

396
00:32:07,630 --> 00:32:12,125
auf dem Terminal oder Ihrem Befehlsfenster gedruckt wird. Wenn Sie

397
00:32:12,125 --> 00:32:15,300
also zum Terminal oder zu Ihrem Befehlsfenster gehen,

398
00:32:15,300 --> 00:32:19,360
sehen Sie, dass es all diese Dinge im Befehlsfenster ausdruckt.

399
00:32:19,360 --> 00:32:21,540
Also, als wir die erste GET-Operation gemacht haben,

400
00:32:21,540 --> 00:32:22,640
heißt es, GET /Gerichte.

401
00:32:22,640 --> 00:32:24,375
Also, das ist wieder,

402
00:32:24,375 --> 00:32:28,155
Morgan macht diese Arbeit für Sie, es druckt aus,

403
00:32:28,155 --> 00:32:31,170
verfolgt diese Informationen und es sagt,

404
00:32:31,170 --> 00:32:34,575
dass Gericht erstellt wurde und dann diese spezielle Gericht Information gedruckt wurde,

405
00:32:34,575 --> 00:32:38,190
und dann sagt es POST/Gerichte, GET /Gerichte,

406
00:32:38,190 --> 00:32:41,130
und dann, wenn Sie einen PUT gemacht haben, gab es eine 403

407
00:32:41,130 --> 00:32:44,170
dort zurück und du hast wieder Gerichte erstellt und so weiter.

408
00:32:44,170 --> 00:32:47,145
Sie sehen also, dass Ihr Server tatsächlich die ganze Arbeit macht,

409
00:32:47,145 --> 00:32:53,110
und diese Dinge werden wie erwartet in Ihre MongoDB-Datenbank eingefügt.

410
00:32:53,110 --> 00:32:58,540
Nun, zurück zum Postboten,

411
00:32:58,540 --> 00:33:00,850
lassen Sie uns einen POST über das Geschirr machen.

412
00:33:00,850 --> 00:33:03,605
Dies wird auf der Serverseite nicht unterstützt,

413
00:33:03,605 --> 00:33:04,750
daher sollte Ihr Server sagen:

414
00:33:04,750 --> 00:33:10,225
„POST-Operation wird auf diesem bestimmten Endpunkt nicht unterstützt“, wie Sie es vielleicht erwarten.

415
00:33:10,225 --> 00:33:13,070
Lassen Sie uns eine PUT-Operation machen.

416
00:33:14,430 --> 00:33:17,190
Wenn Sie eine PUT-Operation ausführen,

417
00:33:17,190 --> 00:33:20,955
was ich in der PUT-Operation tun werde, ist, dass ich

418
00:33:20,955 --> 00:33:26,860
das Etikett dort ersetzen werde.

419
00:33:26,860 --> 00:33:29,550
Also, in meinem Körper der Nachricht. Denken Sie

420
00:33:29,550 --> 00:33:34,570
daran, dass, wenn Sie sich die Datei db.json ansehen,

421
00:33:34,570 --> 00:33:38,180
das Label dafür neu wäre,

422
00:33:38,180 --> 00:33:51,160
und daher werde ich dieses Label in heiß ändern.

423
00:33:51,160 --> 00:33:53,040
Da dies in Json sein muss,

424
00:33:53,040 --> 00:33:57,895
so beschriften Sie auch in Anführungszeichen Json Label hot,

425
00:33:57,895 --> 00:34:02,810
und dann lassen Sie uns einen PUT auf diesem bestimmten Endpunkt machen.

426
00:34:04,080 --> 00:34:07,615
Der PUT-Vorgang war erfolgreich,

427
00:34:07,615 --> 00:34:12,280
und Sie sehen, dass, wenn der PUT-Vorgang ausgeführt wurde,

428
00:34:12,280 --> 00:34:19,150
dann würden Sie feststellen, dass die Beschriftung jetzt von neu zu heiß hier geändert wurde,

429
00:34:19,150 --> 00:34:22,630
und beachten Sie insbesondere den

430
00:34:22,630 --> 00:34:28,900
CreateDat-Wert und den UpdateDat-Wert.

431
00:34:28,900 --> 00:34:31,990
Beachten Sie also, dass dieser Datensatz

432
00:34:31,990 --> 00:34:36,970
zu diesem Zeitpunkt erstellt wurde und ein wenig später aktualisiert wurde.

433
00:34:36,970 --> 00:34:40,000
Also, das Update wurde durch die PUT-Operation durchgeführt, die ich gerade

434
00:34:40,000 --> 00:34:43,450
an diesem bestimmten Gericht durchgeführt habe.

435
00:34:43,450 --> 00:34:46,240
Lassen Sie uns das Gericht löschen.

436
00:34:46,240 --> 00:34:49,795
Das ist erlaubt. Also, wir werden das Gericht löschen,

437
00:34:49,795 --> 00:34:54,100
und dann wird das Gericht gelöscht und der Wert wird zurückgegeben.

438
00:34:54,100 --> 00:34:58,930
Wenn Sie nun eine GET-Operation auf dem

439
00:34:58,930 --> 00:35:04,615
Endpunkt der Gerichte durchführen, werden Sie sehen, dass dies eine leere zurückgibt.

440
00:35:04,615 --> 00:35:09,385
So haben Sie es gerade geschafft, das Gericht aus unserer Datenbank zu löschen.

441
00:35:09,385 --> 00:35:14,095
Was ich tun werde, ist

442
00:35:14,095 --> 00:35:20,630
eine GET-Operation an einem nicht vorhandenen Gericht durchzuführen und zu sehen, was passiert.

443
00:35:20,630 --> 00:35:23,905
Wenn ich eine GET-Operation auf nicht vorhandenem Gericht durchführe,

444
00:35:23,905 --> 00:35:27,300
gibt es null zurück, da dieses Gericht nicht existiert.

445
00:35:27,300 --> 00:35:31,570
Es gibt also einen Nullwert zurück, der besagt, dass das Gericht nicht existiert.

446
00:35:31,570 --> 00:35:40,525
Lassen Sie mich nun eine GET-Operation für eine Nicht-ObjectID ausführen und sehen, was passiert.

447
00:35:40,525 --> 00:35:44,980
Es kehrt zurück, wie Sie sehen.

448
00:35:44,980 --> 00:35:46,465
Lassen Sie mich eine Vorschau darauf.

449
00:35:46,465 --> 00:35:51,840
Also, es heißt: „Die Umwandlung in ObjectID ist für den Wert hier am Pfad fehlgeschlagen.“

450
00:35:51,840 --> 00:35:53,840
Also, ich werde offensichtlich sein, dass dies keine

451
00:35:53,840 --> 00:35:57,565
gültige ObjectID ist, also habe ich es gerade geschafft, einen Teil davon zu löschen

452
00:35:57,565 --> 00:36:02,050
und dann den Vorgang auszuführen, so dass es einen Fehler gibt, der besagt,

453
00:36:02,050 --> 00:36:04,915
so dass Sie sehen, dass es 500 interne Serverfehler gibt.

454
00:36:04,915 --> 00:36:09,505
Der Server konnte dies nicht verarbeiten und dann diesen Wert hier zurückgeben.

455
00:36:09,505 --> 00:36:11,925
Es heißt also: „Nein,

456
00:36:11,925 --> 00:36:13,230
das ist nicht erlaubt.“

457
00:36:13,230 --> 00:36:18,385
Also, weil das keine gültige ObjectID ist.

458
00:36:18,385 --> 00:36:22,275
So werden auch Fehler entsprechend behandelt, wie Sie hier sehen.

459
00:36:22,275 --> 00:36:26,050
Also, lassen Sie mich noch einmal, machen Sie eine GET-Operation auf dem Geschirr,

460
00:36:26,050 --> 00:36:27,975
und Ihr Server läuft immer noch,

461
00:36:27,975 --> 00:36:30,650
und es wird hier einen leeren Wert zurückgeben.

462
00:36:30,650 --> 00:36:34,465
So haben wir gesehen, wie wir

463
00:36:34,465 --> 00:36:40,900
unseren REST API-Server geändert haben, um mit dem MongoDB-Server interagieren zu können.

464
00:36:40,900 --> 00:36:45,775
Wir haben jetzt einen vollwertigen REST-API-Server, der in der Lage ist,

465
00:36:45,775 --> 00:36:48,090
verschiedene Operationen

466
00:36:48,090 --> 00:36:51,220
auf den Daten zu speichern, abzurufen und auszuführen, die auf meinem MongoDB-Server gespeichert sind.

467
00:36:51,220 --> 00:36:54,535
Damit schließen wir diese Übung ab.

468
00:36:54,535 --> 00:36:56,290
In dieser Übung

469
00:36:56,290 --> 00:37:05,200
haben wir gesehen, wie wir in der Lage sind, mit unserem REST-API-Server

470
00:37:05,200 --> 00:37:07,560
und wiederum mit dem MongoDB-Server zu interagieren,

471
00:37:07,560 --> 00:37:12,400
und dann nutzen wir den MongoDB-Server, um Daten vom Server zu speichern und abzurufen.

472
00:37:12,400 --> 00:37:14,770
Sie können mit

473
00:37:14,770 --> 00:37:20,225
Mongoose von unserer Express-Anwendung aus mit dem MongoDB-Server interagieren.

474
00:37:20,225 --> 00:37:24,700
Dies ist ein guter Zeitpunkt für Sie, ein GIT Commit mit der Meldung

475
00:37:24,700 --> 00:37:31,550
„Express REST API with Mongoose Part One“ durchzuführen.