Wir hatten bereits einen vollwertigen
REST-API-Server entwickelt, der Express und MongoDB im Rahmen dieses Kurses verwendet.
Damit dieser Server sinnvoll mit unserem Kunden kommunizieren kann,
werden wir einige kleinere Anpassungen vornehmen, damit er die
richtigen Daten zurückgibt, damit
unsere Client-Implementierung
effizienter mit den Daten arbeiten kann, die von unserer Server-Site zurückgegeben werden.
Um dies zu tun,
lassen Sie uns in dieser Übung an ein paar Anpassungen unserer Server-Site arbeiten.
Bevor Sie mit dieser Übung beginnen,
gehe ich davon aus, dass Sie
die vorherige Lektion zur Integration des Winkelclients und
des Servers nicht durchgeführt haben, da Sie diese Lektion durch die Spezialisierung React ausführen.
Die Änderungen, die ich am Server vornehmen werde, gehen daher davon aus, dass
die Version des Servers, den Sie ändern, vor der vorherigen Lektion liegt.
Falls Sie diese Lektion auf dem Winkel-Client durchgeführt
haben, werden einige der Änderungen, die Sie an Ihrem Server vorgenommen haben,
in dieser Übung erneut wiederholt, sodass Sie diesen Teil der Änderungen überspringen können.
Gehen Sie zu unserem Server im Editor.
Bevor wir mit der Arbeit auf dem Server beginnen,
würde ich vorschlagen, dass Sie alle Bilder herunterladen, die ich
als ZIP-Datei in den Übungsressourcen namens images.zip bereitgestellt habe.
Entpacken Sie die Datei und erhalten Sie dann alle Bilder von dort und kopieren Sie diese Bilder
in den Ordner für öffentliche Bilder auf unserem Server.
Sie sehen also, dass ich hier alle Bilder in meinen öffentlichen Image-Ordner kopiert habe,
da unser Server derjenige ist, der
all diese Bilder für unsere Client-Anwendung bereitstellen wird.
Als nächstes gehen wir zum CORS und passen die Whitelist hier an.
Also, für unsere React-Client-Anwendung,
wenn wir mit dem garn-start-Befehl gestartet haben,
läuft es unter Ihrem Computername:3001.
Also, jede Anfrage, die von unserem Standort an
den Server kommt, trägt dies als Ursprung dort.
Deshalb werde ich das in meine Whitelist hinzufügen, damit
alle CORS-Probleme automatisch behoben werden.
Also, wenn ich hier in die Datei cors.js in meiner Whitelist gehe,
lassen Sie mich den
Namen des http://my Computers hinzufügen: 3001 und das ist
der
Ursprung, von dem mein Client die Anfragen, die an diesen Server kommen, stammt.
Auf diese Weise würde mein CORS keine Probleme für meinen Kunden verursachen.
Als nächstes müssen wir einige der Routen aktualisieren, um
die Abfrageparameter und auch einige kleinere andere Anpassungen zu behandeln.
Lassen Sie mich mit der Datei promoRouter.js beginnen.
Das ist einfach, aktualisiert zu werden.
Also, wenn wir in die Datei promoRouter.js gehen,
in der promOuter Datei für die get-Anfrage, die wir
hier bekommen, anstatt Promotions mit einem leeren JavaScript-Objekt
zu finden, hier würde ich die req.query als Parameter für die Promotions hier liefern,
dasselbe mit dem Leader Router auch.
Also, lassen Sie mich zur Datei leaderRouter.js gehen.
Im Leader Router auch
hier, wo Sie Leaders.Find mit dem leeren JavaScript-Objekt finden
, ersetzen Sie stattdessen das durch die req.query, so dass die Abfrageparameter übergeben werden.
Also, hier werden wir in der featured:true als Abfrageparameter hier übergeben.
Nun, nachdem wir diese beiden angepasst haben,
lassen Sie uns jetzt am Geschirrrouter arbeiten.
Also, gehen Sie in die Datei dishRouter.js,
sogar im Dish Router auch das gleiche Update hier.
Also, gehen Sie in dieses Gerichte.Finden Sie in der Get-Methode hier,
ändern Sie das zu req.query.
Damit wurde mein Dish Router-Update abgeschlossen.
Also, wir haben jetzt den Promo-Router, den Führer
und den Geschirrrouter aktualisiert,
dann werden wir den Lieblings-Router aktualisieren.
Nun hätten Sie den bevorzugten Router als Teil Ihrer vierten Aufgabe implementiert.
Jetzt, im Lieblings-Router,
werden Sie sehen, dass
ich Ihnen für den Lieblings-Router nicht den verbleibenden Teil zeige, weil
Sie das als Teil Ihrer Aufgabe hätten tun sollen.
Lassen Sie mich zunächst Ihre Aufmerksamkeit auf die get-Methode für die Favoriterouter.route:dishid lenken.
Jetzt werde ich diese Get-Methode verwenden, um sicherzustellen, dass
das spezifische Gericht mit der Schale Id bereits ein Favorit für den Benutzer ist.
Also, anstatt einfach getoperation.supported
zu sagen, werde ich nur das Vorhandensein dieser Get-Operation nutzen und dann werden wir sagen,
Favorites.Findone und wir sagen user: req.user. _id.
Also, wir werden die Favoriten für diesen bestimmten Benutzer finden und dann sagen wir dann
Favoriten und fangen Fehler als nächstes.
Dann ähnlich hier, werden wir in den Fehler hier hinzufügen, nächste Fehler hier.
Also, in diesem dann,
wenn wir die Favoriten bekommen,
dann werden wir überprüfen, ob nicht Favoriten.
Also, wenn es keine Favoriten für
diesen Benutzer gibt, dann existiert offensichtlich das Gericht, nach dem wir suchen, nicht,
also werden wir res.StatusCode 200,
setHeader, Content-Type,
application/json zurückgeben und dann sagen wir, dass existiert falsch.
Was wir hier angeben, ist, dass, wenn sie zu diesem Endpunkt mit einem Gericht Id gemacht wird,
diese existiert Flagge hier wird auf true gesetzt, wenn dieses Gericht Teil meiner Favoriten ist.
Wenn dieses Gericht nicht Teil meiner Favoriten ist,
werde ich dort existiert Flagge auf false setzen.
Also hier sehen Sie, dass da ich keine Favoriten habe, also
existiert automatisch falsch an dieser Stelle sein sollte.
Also, wir werden sagen existiert falsch und dann werden wir die Favoriten hier zurückgeben.
Nun, offensichtlich, in diesem Fall wären die Favoriten an dieser Stelle null.
Andernfalls, was bedeutet, dass Favoriten nicht null ist,
so dass wir sagen, wenn favorites.Dishes.indexOf.
Also, wir werden nach Req.params.dishid suchen.
Also, wir werden diese Favoriten Gerichte Array suchen, um zu
sehen, ob dieses Gericht dort existiert und wenn es nicht existiert,
offensichtlich wird dies hier einen negativen Index zurückgeben.
In diesem Fall
werde ich auch genau das gleiche wie hier zurückgeben.
Also, wenn es einen negativen Index zurückgibt, bedeutet das, dass,
obwohl dieser bestimmte Benutzer eine Reihe von Favoriten hat,
dieses spezifische Gericht nicht in
der Liste seiner Favoriten existiert, also deshalb wird es hier falsch zurückgeben.
Nun, sonst bedeutet das, dass das Gericht in der Liste der Favoriten existiert.
Also, in diesem Fall
werde ich Statuscode zurückgeben 200 existiert ist wahr.
Auf diese Weise, wenn der Benutzer eine Get-Operation auf diesem Endpunkt mit
der /Favorites/dishid ausführt, wo die Dish Id als Parameter hier angegeben wird,
als Anforderungsparameter hier,
dann werden wir prüfen, ob dieses Gericht in den Favoriten existiert.
Wenn keiner der Favoriten für diesen Benutzer vorhanden ist, geben wir eine existiert false zurück.
In ähnlicher Weise, wenn die Favoriten vorhanden sind
, aber dieses bestimmte Gericht nicht in den Favoriten existiert, werden wir false zurückgeben,
sonst werden wir true zurückgeben.
Also diese existiert Flagge kann von meinem Client verwendet werden, um zu überprüfen, ob dieses Gericht
Teil der Liste der Lieblingsgerichte für diesen Benutzer ist oder nicht.
Auch während wir in Favoriten sind,
wenn wir irgendwelche Änderungen an den Favoriten vornehmen,
wollen wir in der Lage sein, den Benutzer und Gerichte Informationen,
die Favoriten, zu füllen, bevor wir zurückkehren.
Zum Beispiel, in dem Beitrag, den wir tun,
wenn wir die Favoriten dann an dieser Stelle speichern,
möchten wir zuerst Favoriten machen.
FindById, also weil wir gerade die Änderungen vorgenommen haben, sagen
wir favorite_id und wir werden sowohl den Benutzer als auch
die Gerichte in den Favoriten füllen.
Wenn die Favoriten zurückgegeben werden,
werden wir stattdessen die Favoriten zurückgeben.
Also, lassen Sie mich diese Änderung hier vornehmen.
Also, wir werden das von hier ausschneiden und dann innerhalb der dann
werden wir die Favoriten zurückgeben.
Nachdem wir die Favoriten gespeichert haben,
suchen wir danach, nach
der FavoriteByID und geben dann diesen Favoriten
hier zurück, so dass wir dann Lieblings Return und Statuscode sagen.
Diese Änderung sollten wir vornehmen.
Wenn Sie dies bereits in Ihren Favoriten implementiert
haben, müssen Sie diese Änderung nicht vornehmen.
Aber was wir tun, ist, wenn wir Änderungen an den Favoriten vornehmen,
wir werden sowohl die Benutzer- als auch Gerichte Informationen füllen und dann diesen Wert zurückgeben,
weil unser React-Client erwartet, dass dies da ist.
Jetzt, die gleiche Art von Änderung,
müssen wir Variable b machen, speichern Sie die Änderungen.
Also in der Post hier,
werden wir eine Änderung daran vornehmen,
also sagen wir favorites.save und dann werden wir favorites.findById tun und diese Änderung vornehmen.
In ähnlicher Weise unter der Schüssel ID,
auch in der Post,
werden Sie ähnlich sein, wenn Sie Änderungen an den Favoriten vornehmen,
wird zuerst danach suchen und dann sowohl den Benutzer als auch die Gerichte füllen und dann zurückgeben,
und dann in ähnlicher Weise im anderen Teil.
Also, Sie müssen dies in Ihrem vierten Auftrag implementiert haben.
Nehmen Sie also diese zusätzliche Änderung vor, wo Sie
den Benutzer und Gerichte füllen, bevor Sie den Wert zurückgeben.
Auch mit dem Löschen
werden wir hier die gleichen Änderungen vornehmen.
Sie bemerken also, dass
ich im Löschen diese Änderung hier bereits vorgenommen habe.
Nachdem wir die Änderungen an den Favoriten gespeichert
haben, suchen wir dann nach den Favoriten und
kehren dann zurück, nachdem Sie sowohl den Benutzer als auch die Gerichte und die Favoriten ausgefüllt haben.
Das ist es, was unser React-Client von uns erwartet.
Also, auch für das Löschen,
werden wir die gleichen Änderungen vornehmen.
Nun, damit wird mein Lieblings-Router aktualisiert,
so dass wir fortfahren, users.js als nächstes zu aktualisieren.
Schließlich werden wir die Datei users.js aktualisieren.
Nun, in der Datei users.js müssen wir
hier in einem anderen Feld router.options hinzufügen,
weil manchmal eine Post-Anfrage, wie Sie
mit dem Login gesehen haben, zuerst die Optionen senden, um zu überprüfen,
insbesondere mit Autos, ob die Post-Anfrage erlaubt ist.
Deshalb werden wir den Kurs mit Optionen hier überprüfen und dann
werden wir einfach
eine Statusmeldung
von 200 als Antwort darauf zurückgeben.
Für jeden Endpunkt unter Benutzern, wenn wir die Optionen erhalten, geben
wir hier einfach den Status 200 zurück.
Jetzt die Login-Funktion, die wir früher implementiert hatten,
hatten wir einfach passport.authenticate
local hier gemacht und die wir nach den verbleibenden Werten hier überprüft.
Nun, diese passport.authenticate local,
wenn der Benutzer nicht authentifiziert wird,
gibt es einfach eine nicht autorisierte in der Antwortnachricht.
Nun, das
ist möglicherweise nicht sehr sinnvoll für die Client-Seite, um diese Informationen anzuzeigen, deshalb werden wir
diese Router-Post-Login-Methode
so verbessern, dass die Authentifizierung an dieser Stelle aussagekräftigere Informationen zurückgibt.
Also, um das zu tun,
werden wir nicht tun, den Pass.authenticate hier drin,
sondern wir nehmen.
Also, lassen Sie mich das von dort entfernen und dann werden Sie sehen,
wie ich den Routerpost hier aktualisieren werde.
Also, wir werden Kurs mit Optionen sehen und dann werden wir die req,
res und nächste hier einschließen.
In diesem req, res und weiter hier
wird passport.authenticate dies mit local aufrufen.
Nun, wenn wir dies mit lokalen aufrufen,
wenn Authentifizierungsfehler auftritt,
kann die passport.authenticate gemacht werden, um
den Fehlerwert zurückzugeben, und es wird auch den Benutzer zurückgeben, wenn es
keinen Fehler gibt und ein dritter Parameter namens
info, der zusätzliche Informationen enthält, die möglicherweise zurück zu der Benutzer.
Dieser Fehler wird zurückgegeben, wenn
ein echter Fehler in der passport.authenticate auftritt.
Aber wenn die Benutzerinformationen
in passport.authenticate gesendet werden, der Benutzer aber nicht existiert,
dann wird das nicht als Fehler gezählt.
Stattdessen wird es gezählt, als der Benutzer nicht existiert und
diese Informationen wieder im Info-Objekt analysiert werden, das eingeht.
Daher wird der Fehler zurückgegeben, wenn
ein echter Fehler auftritt, der während des Authentifizierungsprozesses auftritt,
aber die Informationen enthalten Informationen, wenn der Benutzer nicht existiert.
Also, passport.authenticate gibt eine Nachricht zurück, die besagt, dass
der Benutzer nicht existiert oder entweder der Benutzername
falsch ist oder das Passwort falsch ist und so weiter.
Diese Informationen werden also in der Info-Nachricht weitergegeben.
Jetzt werden wir sehen, wie das für
uns nützlich ist, wenn wir uns ein wenig später auf die Kundenseite schauen.
Also, in dieser Situation
werden wir dies wie folgt behandeln,
und nicht nur, dass, wenn wir diesen
Pass aufrufen.authenticate, wir müssen auch eine req,
res, als die drei Parameter zu ihm übergeben.
Also, dies ist die Struktur, wenn Sie passport.authenticate aufrufen müssen und erwarten, dass es
Ihnen Informationen wie diese als Callback-Methode hier zurückgibt,
also müssen Sie auch diese req, res, als
nächstes direkt dort angeben.
Nun, wenn dies geschieht,
so werden wir sagen, wenn irre,
also wenn es einen Fehler gibt, der auftritt,
sagen wir return next error und dann lassen Sie
den Fehler-Handler unseres Express-Routers und kümmern sich darum.
Jetzt werden wir andere Situationen betrachten, wenn nicht Benutzer.
Also, wenn wir diesen Punkt erreicht haben,
dann bedeutet das, dass es kein Fehler war, der aufgetreten ist,
sondern vielleicht konnte der Benutzer nicht gefunden werden.
Wenn der Benutzer nicht gefunden wird,
wird der Benutzer hier in diesem Fall auf null gesetzt.
In dieser Situation,
wenn der Benutzer nicht existiert,
müssen wir in der Lage sein, Informationen zurück an die Serverseite zu übergeben.
Also, was wir tun werden, ist, dass wir diese Informationen in diesem Format übergeben werden.
Also, ich werde das von hier aus ausschneiden und
es dann hier einfügen und dann werden wir das bearbeiten.
Also, wenn der Benutzer null ist,
dann werden wir einen Statuscode als 401 zurücksenden, was
nicht autorisiert bedeutet, und dann werden wir Informationen Erfolg falsch zurücksenden,
und dann werden wir das Token nicht
zurückgeben, wir werden die Statusmeldung zurückgeben.
Also, hier werden wir sagen
„Login nicht erfolgreich“ und dann die dritte Information,
wir werden diese Informationen das Objekt übergeben, das wir hier als
der dritte Teil in der Antwortnachricht erhalten haben, die wir von unserem Server hier zurücksenden.
Das Erfolgsflag wird also auf false gesetzt,
der Status wird Login fehlgeschlagen gesetzt und
die Fehlerinformationen, die in der Info übergeben werden, werden zurückgegeben.
Beachten Sie nun, dass diese Situation auftritt
, wenn entweder der Benutzername und das Kennwort falsch sind.
Dies ist also kein Fehler im Fehlersinn, aber die Tatsache, dass
die Authentifizierung weder den Benutzer noch das Kennwort des Benutzers finden konnte, ist falsch.
Also, diese Informationen werden in die Info codiert, die hereinkommt und so dass ich
als Fehler an meine Client-Seite weitergebe.
Der ansonsten Teil
wird als Req.login behandelt.
Also, wenn dies erfolgreich ist,
die passport.authenticate werden wir diese Methode namens Req.login zum Benutzer hinzufügen.
Also, an diesem Punkt
werden wir einfach das Benutzerobjekt übergeben, das wir erhalten haben.
Also hier, wenn wir diesen Punkt erreicht haben,
dann bedeutet das, dass das Benutzerobjekt nicht null ist und auch kein Fehler aufgetreten ist,
so dass der Benutzer angemeldet werden kann.
Also, wir werden sagen, irren,
wir werden versuchen, den Benutzer anzumelden.
Also, wir werden sagen, wenn irre und
dann werden wir die gleiche Art von Fehlerinformationen zurückgeben, die wir hier gemacht haben.
Also in diesem Fall, wenn Fehler,
dann werden wir einen Statuscode als 401 übergeben und wir werden sagen, Erfolg
ist falsch und Status als Login nicht erfolgreich,
und dann die Fehlerinformationen,
statt der Info,
werden wir in übergeben „Konnte nicht in Benutzer anmelden“.
Also, das ist die Nachricht, die wir hier zurückgeben werden, wenn der Fehler auftritt.
Sonst wären wir hier unten.
Also, an diesem Punkt,
würden wir in der Lage sein, das Token zu generieren.
Also, wenn wir bis zu diesem Punkt erreicht haben,
bedeutet das, dass der Benutzer sich erfolgreich angemeldet hat,
und so können wir jetzt das Token generieren.
Also werden wir das Token basierend auf der ID des Benutzers generieren,
und dann übergeben wir das Token an den Benutzer zurück.
Also, hier werden wir var Token sagen,
und dann können wir sagen res.StatusCode ist 200 und dann res.json Erfolg wahr,
also, was bedeutet, dass der Benutzer erfolgreich angemeldet ist.
Also, der Status wäre Login erfolgreich.
Dann, der dritte Teil,
anstelle des Fehlers,
werde ich das Token zurück an den Benutzer übergeben.
Also, wir sagen Token,
dieses Token, das wir gerade früher erhalten haben. Dieses
Token wird also als Token-Eigenschaft der Antwortnachricht übergeben.
Beachten Sie hier also, dass der Erfolg auf true gesetzt ist,
was bedeutet, dass sich der Benutzer erfolgreich angemeldet hat,
und so kann der Benutzer an dieser Stelle weiter fortfahren.
Dies muss innerhalb der Req.login hier getan werden.
Also, an dieser Stelle
werden wir die Req.login schließen.
Beachten Sie also, dass dies in diesem Req.login hier ist.
Also, da drin, werden wir diese drei zurückgeben.
Also, lassen Sie mich einfach diese drei Zeilen einrücken.
So würden wir die Protokollierungsmethode des Benutzers behandeln.
Also, wieder, überprüfen Sie diesen Code noch einmal.
Also, wir werden Router-Post tun,
aber anstatt Pass authentifizieren genau dort,
wir werden sagen, req, res,
nächste, und dann innen hier,
werden wir einen Reisepass authentifizieren für die lokale,
und diese Authentifizierung wird zurück übergeben.
So können wir eine Callback-Funktion liefern,
und diese Callback-Funktion gibt entweder den Fehler,
den Benutzer oder die Info hier zurück.
Also, wenn es ein Fehler ist,
werden wir nur zulassen, dass der Express-Fehlerbehandler sich darum kümmert.
Wenn der Benutzer null ist,
bedeutet dies, dass die Benutzeranmeldung fehlgeschlagen war,
und der Grund dafür wird in der Info sein.
Also, das wird als Infofehler in der Antwortnachricht hier zurückgegeben.
Wenn wir zu diesem Punkt kommen,
wird der Benutzer erfolgreich verifiziert.
Also, dann werden wir den Benutzer einloggen.
Also, der Pass authentifizieren,
werden wir in dieser Methode namens Login in der req, die Anfrage Nachricht hinzufügen.
So können wir den Login mit dem Benutzer aufrufen.
Wenn dies einen Fehler zurückgibt,
dann werden wir den Fehler hier entsprechend zurückgeben.
Wenn nicht, dann haben wir den Punkt erreicht, an dem der Benutzer erfolgreich authentifiziert wird.
So können wir hier das JSON Web Token generieren und dann
das JSON Web Token an den Benutzer zurückgeben, um zu bestätigen, dass der Benutzer erfolgreich angemeldet ist.
Also, das ist die Reihe von Schritten, die wir hier verwenden werden.
Nun, der Grund, warum ich eine aufwendigere Art und Weise tue, ist, dass
ich zwischen der Situation unterscheiden möchte, in der ein echter Fehler
während des Authentifizierungsprozesses auftritt, im Gegensatz zu der
Situation, in der der Benutzername ungültig ist oder das Passwort ungültig ist.
Diese beiden Fälle werden also durch diese Situation behandelt,
wo die Informationen die Informationen zu uns zurückbringen werden.
Das ist also kein Fehler per se,
aber das ist eine Situation, in der der Benutzer
kein gültiger Benutzer ist oder das Passwort des Benutzers ungültig ist.
So werden wir den Anmeldeprozess des Benutzers behandeln.
Darüber hinaus werde ich
hier eine weitere Methode namens checkJWTToken hinzufügen.
Es ist durchaus möglich, dass, während der Client sich angemeldet hat und das JSON Web Token
abruft, irgendwann später das JSON Web Token abläuft.
Wenn der Benutzer also versucht, von der Clientseite mit einem abgelaufenen Token auf den Server zuzugreifen,
kann der Server den Benutzer nicht authentifizieren.
Daher
möchten wir in regelmäßigen Abständen eine Gegenprüfung durchführen, um sicherzustellen, dass das JSON-Web-Token weiterhin gültig ist.
Also, das ist der Grund, warum ich dies einschließe,
einen anderen Endpunkt namens checkJWTToken.
Wenn Sie also ein get to checkJWTToken durchführen, indem Sie das
Token in den Autorisierungsheader
einschließen, gibt dieser Aufruf einen true oder false zurück,
um Ihnen anzuzeigen, ob das JSON-Web-Token noch gültig ist oder nicht.
Wenn es ungültig ist, kann die Client-Seite eine weitere Anmeldung für
den Benutzer initiieren, um bei Bedarf ein neues JSON-Web-Token zu erhalten.
Also, um dies zu tun,
sagen wir cors.corsWithOptions und req,
res hier wie erwartet.
Hier werden wir sagen,
Pass authentifizieren jwt
und session: false,
und dies würde err, user, info zurückgeben.
Also, erinnern Sie sich, wie wir verwenden den Reisepass authentifizieren früher.
Also, wir nennen die JWT mit Sitzung falsch hier.
Also, früher hier, sagen wir Reisepass authentifizieren lokale.
Dies ist also für die lokale Authentifizierung.
Dies ist also für die JSON-Web-Token-Authentifizierung.
Also, wenn wir das aufrufen,
dann, da dies das JSON Web Token überprüfen wird, so werden wir sagen,
wenn irr nächsten Fehler zurückgibt,
und dann lassen Sie den Express Error Handler sich um diese Situation kümmern.
Dann werden wir sagen, wenn nicht Benutzer,
wenn der Benutzer nicht existiert, dann ähnlich.
Also, was bedeutet, dass, wenn das Benutzerobjekt
aus dem JSON-Web-Token gefunden und dann auf den req.user geladen wurde,
das bedeutet, dass der Benutzer ein gültiger Benutzer ist
und so weiter fortfahren kann.
Andernfalls werden wir sagen, dass der Benutzer nicht existiert.
Daher müssen wir informieren, dass das JSON Web Token abgelaufen ist.
Also, an dieser Stelle
senden wir ein res mit
einem Statuscode von 401.
Also, nicht autorisiert, setHeader, Content-Type,
application/json, und dann werden wir res zurückgeben.
Res.JSON wird sagen, Status JWT
ungültig und dann,
wir werden ein Flag namens Erfolg fällt
zurückgeben und dann, wir werden die Informationen, die wir erhalten, wenn der Benutzer
nicht als Fehler an diesem Punkt authentifiziert.
Andernfalls bedeutet das, dass wir diesen Punkt erreicht haben,
dann ist der Benutzer ein gültiger Benutzer.
Also, in diesem Fall,
lassen Sie mich einfach diesen Code hier kopieren,
wir werden einen Statuscode von 200 senden und dann
wird der res.json JWT gültig und erfolgreich als wahr senden.
Im dritten Teil senden wir die Informationen des Benutzers.
Wenn dieser Endpunkt mit der get-Methode aufgerufen
wird, überprüft dies, ob das Token gültig ist oder nicht.
Wenn das Token gültig ist,
erhalten Sie diese Antwort und vom Erfolgsflag in der Antwort
können Sie überprüfen, ob das jsonwebtoken gültig ist oder nicht.
Dies ist auf der Client-Seite nützlich.
Nun, dieser Pass authentifizieren hier muss
mit req und res als die beiden Parameter hier geliefert werden.
Also, so nennen wir den Reisepass authentifizieren.
Also, beachten Sie, dass, wenn Sie
Pass authentifizieren und erwarten, dass diese Callback-Funktion hier in,
müssen Sie bis zu diesem Punkt req.res an den Pass anhängen authentifizieren hier hinten.
In unserem restlichen API-Server
hatten wir unsere Kommentare so implementiert, dass die Kommentare
Unterdokumente innerhalb des Dokuments des Dishe bildeten,
so dass sie jedes Gericht mit seinen eigenen Kommentaren kaufen.
Aber die Art und Weise,
wie wir unseren React-Client implementiert haben, ist so, dass die Kommentare unabhängig von den Gerichten gehalten werden,
und die Kommentare selbst trugen die entsprechende ID des Gerichts.
Nun, dies sind zwei verschiedene Möglichkeiten, sowohl
die serverseitige als auch die Client-Seite zu implementieren.
In der Angular-Anwendung, die wir in unserer Angular-Spezialisierung implementiert sind,
hatten wir die Unterdokumentmethode für die
Bearbeitung von Kommentaren in unserer Angular Client-Anwendung verwendet.
So wurde der Rest API-Server
so implementiert, dass er besser für den Angular-Client geeignet war.
Aber für die React-Kunden, da wir die Kommentare unabhängig von den Gerichten gehalten haben,
und dann die Dish-ID innerhalb des Kommentars verwenden,
so dass wir unseren Rest API-Server neu strukturieren müssen,
so ist es, dass wir einen separaten Kommentar Endpunkt unabhängig von den Gerichten Endpunkt.
Daher müssen wir unseren Code im Server neu strukturieren,
um den /comments REST-API-Endpunkt in diesem Stadium einzuführen.
Um dies zu tun,
lassen Sie uns ein neues Modell namens comment.js implementieren.
Also, wenn ich in die Modelle gehe,
lass mich eine neue Datei namens comments.js implementieren.
In der Datei comments.js
verschieben wir das CommentSchema aus der
Datei dishes.js in die Datei comments.js und entfernen es dann vollständig aus der Datei dishes.js.
Aber bevor wir das tun,
müssen wir den Mungo und das Schema von hier kopieren,
also lassen Sie mich das einfach von dishes.js in comment.js kopieren.
Danach, wenn ich in dishes.js gehe,
lass mich dieses CommentSchema vollständig von hier aus schneiden,
weil wir dies separat im Kommentarmodell hier haben werden.
Also, lassen Sie uns das in das Kommentarmodell verschieben und dann fügen Sie es hier ein.
Aber natürlich ist dies nicht das komplette,
wir werden das CommentSchema ein wenig aktualisieren.
Aber bevor wir das tun,
gehen Sie zurück zur Datei dishes.js und in der Datei Gerichte,
werden wir die Kommentare aus dem DishesSchema entfernen,
weil wir den Inhalt getrennt von
den Gerichten in dieser Version unseres Servers speichern werden.
So werden wir das Geschirr Modell hier aktualisieren.
Also, wir haben die Kommentare vollständig aus dem Geschirr Modell hier entfernt.
Gehen Sie in das Kommentarmodell,
so dass wir jetzt sehen, dass wir das CommentSchema hier implementiert haben.
Darüber hinaus
müssen wir im CommentsSchema jetzt explizit auf
das spezifische Gericht verweisen, für das dieser Kommentar der entsprechende Kommentar ist.
Nun, hier
kommt unsere Mungo Population und die Art, wie wir die Objekt-IDs lagern, zu unserer Rettung.
Wir werden also das CommentSchema aktualisieren und sagen, dass wir
hier die Bewertung, den Kommentar und den Autor haben werden.
Zusätzlich zu dem Autor,
werden wir ein weiteres Feld als das Gericht hier genannt,
das vom Typ ist: Mongoose.Schema types.ObjectID,
und so wird dies auf die Dish hier beziehen.
Also, dies wäre ein Objekt-Verweis auf das Gericht Modell hier,
und so mit dieser Änderung jetzt
unsere Kommentare enthalten das Bewertungsfeld, das Kommentarfeld,
den Autor, der wieder ein Verweis auf den entsprechenden Benutzer ist,
und dann das Gericht Feld, das ein Verweis auf die entsprechenden Gericht hier.
Also, was bedeutet, dass wir jetzt
die Kommentare sowohl mit dem Autor als auch mit dem Gericht Feld füllen müssen.
Sobald wir dies abgeschlossen haben,
dann werden wir sagen var Kommentare
mongoose.model und wir werden diesen 'Kommentar' nennen,
und dann verwendet dies das CommentSchema, das wir gerade hier definiert haben,
und dann müssen wir dies von hier aus exportieren,
die comments.model von hier.
Also, jetzt, da wir das comments.model eingeführt haben,
werden wir voran gehen und dann einen neuen Router namens CommentRouter vorstellen.
Also, um den Kommentarrouter einzuführen,
gehen wir in die Routen hier,
und erstellen Sie dann eine neue Datei namens commentRouter.js.
Lassen Sie mich in der commentRouter.js ein paar Dinge
vom DishRouter kopieren.
Also, wir werden diese Kommentare hier haben,
also lassen Sie mich diese Dinge von der und auch kopieren,
während ich dabei bin, lassen Sie mich einfach diese auch bis zu diesem Punkt kopieren,
und dann werde ich das ein wenig später aktualisieren.
Also, wenn wir in den CommentRouter gehen,
brauchen wir alle diese Teile,
also sagen wir Com, Express, BodyParser, Mungo
, authentifizieren, cors, und dann
werden wir Kommentare aus Modellen/Kommentaren importieren.
Dann nennen wir dies als CommentRouter, der hier ein Express.Router ist.
Dann werden wir sagen, CommentRouter BodyParser verwenden,
und dann würde dies jetzt CommentRouter Route werden.
Jetzt müssen wir in den DishRouter gehen und dann
alle Teile entfernen, die sich auf die Kommentare hier beziehen.
Also, lassen Sie mich einfach diesen Teil ausschneiden und dann werden wir diese für unseren CommentRouter wiederverwenden.
Also, all diese werden im DishRouter nicht mehr benötigt.
Also, ich werde all dies aus dem DishRouter hier entfernen,
also lassen Sie mich sie ausschneiden,
alles, was mit der Kommentarroute vom DishRouter zusammenhängt,
dann gehen wir in den CommentRouter
und lassen Sie mich dann voran und fügen Sie das hier ein,
dann werden wir das hier bearbeiten.
Danach müssen wir den CommentRouter exportieren.
Also, wird den CommentRouter für uns exportieren.
Aber natürlich ist dieser Code nicht vollständig korrekt.
Also müssen wir voran gehen und diesen Code hier reparieren.
Für diesen Code
erkennen wir nun, dass dies nicht die DishRouter-Route ist,
sondern
der /Endpunkt sein sollte, weil
wir dies hier im Endpunkt /comments einhängen werden.
Also, wir sagen CommentRouter,
und dann die Optionen corsWithOptions (req,
res), die als solche dort bleibt,
und dann die get cors.cors und dann req.res,
und dann wird dieser zu Kommentaren werden.
FindById, req.
Also, das wäre Kommentare.Find
und req.query hier.
Also, wenn die Kommentare gefunden werden
, dann
werden wir an dieser Stelle den Autor bevölkern,
bereits dort haben, hier bevölkern.
Also, ich werde nur diesen comments.author entfernen, und dann,
wir werden einfach den Autor hier füllen.
Dann würde dies uns hier Kommentare geben.
Dann werden wir sagen, dass dies erheblich vereinfacht werden kann.
Also, der Catch-Fehler ist sowieso da.
Also, wenn der Kommentar kommt, wird er einfach zurückkehren.
Tut mir leid, das sollte sein.
Also, wenn für die get,
wenn wir die Kommentare erhalten,
comments.Find req.query, .populate Autor hier,
und dann, wir sagen,, .then Kommentare,
und dann, wir werden sagen, res.StatusCode 200,
SetHeader, und dann, wir werden die Kommentare von hier zurückgeben,
res.json Kommentare von hier.
Nun bevölkere ich die Gerichte hier nicht, weil ich die Gerichte nicht explizit
so brauche, wie ich diese Informationen in meinem Reakt-Client verwende.
Ich brauche nur die Dish ID,
und die Dish ID ist bereits dort vorhanden,
und das ist gut genug für mich, diese Daten in meinem React Client zu verwenden.
Also, ich werde es als solche dort lassen.
Ich werde nur
die Autoreninformationen dort auffüllen, weil wir die vollständigen Autoreninformationen benötigen,
wenn wir ein Kommentarelement in unserem Reakt-Client rendern.
Also, das get wird hier so aktualisiert.
Für den Beitrag corsWithOptions,
wir sagen, Authenticate.VerifyUser req, res, weiter.
Damit ein Kommentar gepostet werden kann,
muss der Autor offensichtlich ein gültiger angemeldeter Benutzer sein.
Nur dann erlauben Sie dem Benutzer, einen Kommentar zu posten.
Dann kommt der Kommentar selbst im Hauptteil der eingehenden Anforderungsnachricht.
Also, zuerst überprüfen wir den Körper,
um sicherzustellen, dass der Kommentar in den Körper hier enthalten ist.
Also, hier werde ich alle diese Teile entfernen und
es dann weiter vereinfachen, und dann
werden wir das dort richtig implementieren.
Also, genau an diesem Punkt, werden wir sagen,
wenn req.body nicht gleich null ist,
was bedeutet, dass es einen Kommentar gibt, der innerhalb des Körpers eingeschlossen ist.
Also, lassen Sie mich das schneiden und das in den If-Teil hier verschieben
, und dann werden wir das hier bearbeiten.
Also, wenn der Körper nicht existiert,
dann werden wir einen Fehler verursachen.
Also, wir werden sagen, irr neuen Fehler,
Kommentar nicht im Anforderungskörper gefunden.
Also, wir werden diesen Fehler hier aufwerfen.
Der Fehlerstatus ist 404.
Dann werden wir sagen, nächsten Fehler zurückgeben.
Also, lassen Sie uns den Fehlerteil hier behandeln, wenn der Körper
nicht die entsprechenden Kommentarinformationen enthält.
Wenn es enthält, dann, natürlich,
was wir als nächstes tun werden, ist,
sagen wir, req.body.author ist req.user. _id.
Der Grund, warum wir dies tun, ist, dass wir uns daran erinnern, dass, wenn es
sich um einen registrierten Benutzer handelt und der Benutzer
sich angemeldet hat, der req.user die Benutzerinformationen enthält.
Ich benötige also nur die ID des aktuell angemeldeten Benutzers.
Also, wir werden sagen, req.user. _id, und dann
setzen wir die req.body.author auf req.user. _id.
Nun wird der Verifizierungsbenutzer automatisch sicherstellen, dass Sie, wenn Sie an diesem Punkt landen,
offensichtlich einen Benutzer haben, der sich korrekt angemeldet hat.
Andernfalls hätte das bereits das Problem dort verursacht.
Also, wenn Sie an dieser Stelle erreichen,
haben Sie einen gültigen Benutzer, der sich bereits beim System angemeldet hat.
Also, das ist, wo Sie jetzt in der Lage sein würden.
Also, was wir tun, ist, dass das Autorenfeld,
wir setzen es explizit in die Benutzer-ID hier, so dass
die req.body die verbleibenden Teile des Kommentars enthält.
Wie Sie erkennen, enthält der Kommentar die Bewertung,
den Kommentar selbst und den Autor und die Felder des Gerichts.
Also, die restlichen Teile sollten vom Benutzer gefüllt worden sein.
Die Bewertung, der Kommentar
und die Dish-Informationen sollten bereits
in den Text der eingehenden Anforderungsnachricht eingegeben werden.
Der Autorenteil bleibt dort unausgefüllt
, den wir an dieser Stelle explizit in den Body einfügen werden.
Also, jetzt wird der req.body die gesamten Kommentarinformationen enthalten.
Also, an dieser Stelle,
anstatt dies zu tun, werden wir sagen, Kommentare.Erstellen.
Mit dem req.body, werden wir die Kommentare hier erstellen.
Dann gibt dies
den Kommentar zurück, der dem Kommentar entspricht, den wir gerade hier eingefügt haben.
Nun, sobald der Kommentar zurückgegeben wurde,
dann sollten wir comments.findById tun.
Nun, der Grund, warum wir dies tun müssen, ist, dass wir
die Autoreninformationen hier füllen müssen.
Also, wir werden sagen, FindById Kommentare. _id,
und dann füllen wir die Autoreninformationen in den Kommentar selbst.
Dann werden wir sagen, dann kommentieren.
Nun, offensichtlich, hier, würden Sie feststellen, dass der Kommentar
existieren wird, weil wir gerade diesen Kommentar eingefügt haben.
Also, hier werden wir einfach zurückkehren, res.StatusCode ist 200,
Res.setHeader ist Content-Type, application/json.
Der Kommentar selbst wird sagen, res.json, und dann,
den Kommentar an dieser Stelle zurück.
So werden wir
hier mit dem Einfügen eines neuen Kommentars in unsere Kundenseite umgehen.
Für den Put, wie Sie erkennen, werden
Sie nicht in der Lage sein, einen Put auf die /comments/Endpunkte zu tun.
Also, wir werden sagen, PUT-Operation nicht unterstützt auf /comments/Endpunkt.
Das ist der Punkt. Das ist die Nachricht, die du zurückkehrst.
Also, StatusCode ist 403,
und dann, PUT-Operation nicht unterstützt auf /comments/.
Nun, wenn wir ein Löschen tun,
lassen Sie mich einfach schneiden dies von hier, und dann, wir sagen,
Kommentare.Entfernen.
leer geschrieben. Wenn Sie also einen Löschvorgang auf dem Endpunkt von Schrägkommentaren
vornehmen, werden Sie alle Kommentare aus Ihrem System entfernen.
Also, das ist eine sehr gefährliche Operation, und so
sollten Sie dies nicht normal tun.
Daher erlauben wir dem Administrator nur, eine solche Operation durchzuführen.
Also, wir werden alle Kommentare von dort entfernen.
Also, wenn Sie die Antwort erhalten,
dann sagen wir res.StatusCode 200.
Also, lassen Sie mich diese Teile hier kopieren,
und dann kommen Sie und fügen Sie sie hier ein.
Also, wir werden sagen, Kommentare.entfernen.
Dann antworten Sie res.StatusCode 200 Anwendung json und dann res.json (Antwort) hier.
So gehen wir mit der Löschung um.
Löschvorgang auf dem Endpunkt von Schrägstrichkommentaren.
Nun, die nächste Route ist der Kommentarrouter.
Also, hier sagen wir commentRouter.Route und
der Endpunkt hier wäre der Schrägstrich commenttID.
Also, hier werden die Optionen als solche bleiben.
Dann für den get auf den aktuellen Router,
für die get sagen wir, comments.findById (req.params.
Dies wäre CommentID.
Also, sobald wir den spezifischen Kommentar gefunden haben,
dann werden wir nur den Autor von dort füllen.
Dann, wenn Sie den Autor füllen,
dann sagen wir, dann kommentieren.
Nun, all dieser Teil ist hier unnötig,
also werde ich nur den Teil löschen.
Das ist auch hier nicht das Richtige.
Also, lassen Sie mich Code umbenennen.
Also, wir werden für die get comments.findById sagen,
dann füllen Sie den Autor,
dann kommentieren, res.StatusCode ist 200, setHeader.
Dann sind der Rest JSON.
Wir werden einfach die Kommentare hier zurückgeben.
Also, wir werden den Kommentar an dieser Stelle zurückgeben, res.json (Kommentar).
Sie finden den spezifischen Kommentar
und geben dann diesen Kommentar für den Beitrag zurück.
Für die Post-Operation, wie Sie erkennen,
ist die Post-Operation nicht
auf Kommentare CommentID erlaubt.
Also, das ist die Nachricht, die wir senden,
POST-Operation nicht auf Kommentare Slash CommentID unterstützt.
Also, das ist die Botschaft, die wir für den Einsatz sagen werden.
Nun, für den Put, sagen wir Kommentare.Finden Sie wo Id (req.params.CommentID).
Also, wir werden den Kommentar dort finden,
und dort Kommentar, also für den Putt.
Also, wir werden den Kommentar dort finden,
und dann sagen wir für die Kommentare.
Also, wenn wir den Kommentar finden,
wenn der Kommentar nicht null ist,
dann werden wir auch überprüfen, ob comment.author.
Wenn nicht, ist comment.arthur gleich (req.user. _id).
Wir überprüfen also, um sicherzustellen, dass
der comments.author mit dem aktuellen Benutzer identisch ist.
Nur der aktuelle Benutzer, der angemeldet ist - wenn der Benutzer mit dem Autor des Kommentars
übereinstimmt, kann der Benutzer aktualisieren.
Also, das ist das erste, was wir überprüfen werden.
Also, Kommentare, dann kommentiert.author.equal rec.user. _id.
Wenn nicht, dann werden Sie sagen, dass Sie nicht berechtigt sind, diesen Kommentar zu aktualisieren.
Wie Sie die.403 sehen,
und geben Sie dann den nächsten Fehler hier zurück.
Also, wir werden den Fehler dort erstellen.
Danach sagen wir
req.body.author, req.user. _id.
Das ist wichtig.
Nun, diese beiden sind hier nicht notwendig,
weil wir den Kommentar direkt speichern.
Dann Pillen, sagen wir comments.findByidAndUpdate,
und req.params.CommentID.
Also, wir werden diesen spezifischen Kommentar finden,
weil wir bereits die Kommentar-ID angegeben haben.
Also, wir werden Kommentare FindById Req.params.CommentID tun.
Dann sagen wir dann (Kommentar).
Wenn Sie die Req.params.CommentID angeben,
müssen wir explizit den zweiten Parameter angeben,
was wir ändern möchten.
Also, wir sagen $set: req.body.
Der zweite Parameter
sagt Ihnen also im Wesentlichen, welchen Teil Sie ändern.
Jetzt, da wir den Körper geliefert haben, der den aktualisierten Kommentar enthält,
werden wir nur den gesamten Kommentar selbst aktualisieren.
Dann ist der andere Teil, nach dem wir fragen werden, neu: wahr.
Dadurch wird sichergestellt, dass der aktualisierte Kommentar in der
Höhle dieses Aufrufs des Kommentars.findByIdandUpdate-Objekts zurückgegeben wird.
Also, wir werden sagen, dann Kommentare.
Wenn dieser Kommentar zurückgegeben wird,
dann sagen wir comments.findById (Kommentar. _id).
Dann füllen Sie den Autor dort.
Wir werden den Autor dort füllen,
und dann sagen wir, dann kommentieren.
Sie sehen also, dass wir den Kommentar erhalten und dann den Kommentar an dieser Stelle zurückgeben werden.
So werden wir den Kommentar aktualisieren.
Dies ist also die Situation, in der der Kommentar nicht null ist.
Also, diese if-Anweisung für den Kommentar ist nicht null.
Also, das sonst wenn Teil,
jetzt ist dies nicht anwendbar,
also sagen wir sonst, Fehler.
Der Fehler in diesem Fall.
Also, wenn der Kommentar null ist,
bedeutet das, dass wir den Kommentar dort nicht gefunden haben,
so dass Sie keinen nicht vorhandenen Kommentar ändern können.
Also sagen wir, Fehler,
neue Fehler Kommentar req.params.CommentID nicht gefunden und dann werden wir den Fehler zurückgeben.
Also, so werden wir den Put-Teil unseres Kommentars hier behandeln,
und dann endlich das Löschen.
Für das Löschen, wieder müssen wir zuerst
comments.findById (Req.params.CommentID) finden
und dann kommentieren.
Also, wir werden nach dem Kommentar suchen.
Also, wir werden zuerst überprüfen, ob Kommentar nicht gleich null ist.
Das ist wichtig, hier zu überprüfen.
Dann wird der nächste Teil, auf den wir prüfen werden, ist, ob der comment.author gleich req.user ist. _id.
Wir stellen sicher, dass dieser Benutzer, der versucht,
diesen Kommentar zu löschen, genau derselbe Benutzer ist, der den Kommentar an erster Stelle eingefügt hat.
Wenn nicht, so, wenn dies der Fall ist,
dann sehen Sie „Sie sind nicht berechtigt, diesen Kommentar zu löschen!“
Und dann den Status dorthin zurückgeben.
Dann unten hier unten,
sagen wir comments.findByIdandRemove hier.
Also, wir sagen comments.findByIdAndRemove (req.params.CommentID),
dann erhalten wir eine Antwort aus dem Kommentar.
Also, an dieser Stelle
werden wir einfach sagen, res.StatusCode.
Also sagen wir comments.findByIdAndRemove dann Antwort.
Wenn es richtig entfernt wird,
sagen wir 200 und dann res.json
Antwort hier und wir werden auch den Fehler an dieser Stelle fangen.
Also, lassen Sie mich das hier kopieren und dann werden wir den Fang des Fehlers an dieser Stelle einschließen.
Also, das ist das erste, was wir überprüfen werden.
Wir stellen sicher, dass der Kommentar nicht gleich null ist.
Andernfalls ist dies also der andere Teil.
Also, dies ist der andere Teil des wenn else Fehler
neuen Kommentar req.params.CommentID nicht gefunden und dann
404 und senden Sie den sonst Teil für uns und dann wird der dann Teil angemessen behandeln.
Also, das sind die Änderungen, die wir hier für den Kommentarrouter vornehmen.
Also, wir behandeln den get put post und löschen für
die Schrägstrich Kommentare und Punkt Schrägstrich Kommentare Schrägstrich CommentID Auswirkungen.
Sobald wir dies abgeschlossen haben,
müssen wir dies in die Datei app.js aufnehmen.
Also, wir werden in die app.js Datei gehen und dann sagen wir
var CommentRouter
benötigen Routes/CommentRouter.
Also, wir haben den Kommentar Router hier und dann werden wir
unten in die app.js Datei unten gehen und
dann sagen wir app.use
Schrägstrich Kommentare, CommentRouter hier.
Das war's. Also, jetzt
ist mein Kommentarrouter bereit.
Also, lassen Sie uns fortfahren und alle Änderungen speichern.
Dann wird unser Server jetzt aktualisiert,
um alle Anfragen unserer React-Clients hier zu bearbeiten.
Nun, wenn Sie den alternativen Weg machen möchten, das heißt,
Sie haben Ihre Kommentare als Unterdokumente Ihres Gerichts und dann möchten Sie damit umgehen,
dann müssen Sie den React-Client aktualisieren,
um die Kommentare aus jedem Gericht entsprechend verwenden zu können.
Das wird als Übung für Sie übrig bleiben.
Denken Sie darüber nach, wie Sie Ihren React-Client so gestalten würden, dass er
sehr gut mit der früheren Version
des Servers funktioniert, der die Kommentare als Unterdokumente Ihrer Gerichte selbst hatte.
Nun, das wird eine interessante Möglichkeit sein, es zu implementieren.
Natürlich ist es ein bisschen komplizierter als die Art und Weise, wie wir
den React-Client implementiert haben, wo wir die Kommentare unabhängig von
den Gerichten gehalten haben, aber dann liegt die zusätzliche Arbeit dann in
der Verantwortung der Kundenseite, weil Sie
die entsprechenden Kommentare auswählen müssen, wenn Sie eine spezifisches Gericht.
Sie müssen die Kommentare aus allen Kommentaren hier auswählen.
Also, das ist eine zusätzliche Arbeit, die unser React-Client tut, weil
wir die Kommentare von den Gerichten selbst getrennt haben.
Ebenso, wenn Sie Ihren eckigen Kunden neu gestalten können, um
mit der Situation umzugehen, in der die Kommentare unabhängig von Ihren Gerichten gehalten werden.
Nun, das sind alles Übungen, die Sie tun können, um zu sehen, wie Sie
Ihre Client-Anwendungen für jede Art von Server erweitern können,
die beiden verschiedenen Arten von Servern dort.
Damit schließen wir das Update auf unseren Server hier ab.
Damit haben wir alles auf der Serverseite aktualisiert.
Lassen Sie uns also alle Änderungen auf der Serverseite speichern.
Jetzt ist unser Server bereit, die eingehenden Anfragen von unserem React-Client zu bearbeiten.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir nun unseren Express-Server vorbereitet,
um eingehende Anfragen von unserem React-Client zu bearbeiten.
In der nächsten Übung werden wir uns den React Client genauer ansehen, um zu
verstehen, wie es mit diesem zusätzlichen Server kommuniziert.
Dies ist ein guter Zeitpunkt für Sie,
eine Git-Abdeckung mit der Nachricht zu erstellen, die Client und Server integriert.