Nun, da wir über Mongoose Population gelernt haben,
und wie es uns ermöglicht, ein Dokument mit Informationen aus einem anderen Dokument zu füllen.
In dieser Übung werden wir den Express-Server ändern, an dem wir bisher gearbeitet haben.
In dem Schüsselschema, das wir früher definiert haben, hatten wir Kommentare.
Für die Kommentare hatten wir das Autorenfeld
, das wir verwenden, um die Details über den Autor zu speichern.
In dieser Übung verwandeln wir das Autorenfeld in einen Verweis auf ein Benutzerdokument,
und wir werden Mongoose Population verwenden, um die Informationen in
das Geschirr Dokument zu füllen, wie und wenn erforderlich,
um die Informationen an den Kunden zu liefern.
Jetzt sollte die Verwendung von bevölkerten und Mungo Bevölkerung
vernünftig durchgeführt werden, um nicht zu viel Overhead auf der Serverseite verursachen.
Jetzt in dieser Übung
werden wir es einfach verwenden, um die Informationen
in das Autorenfeld unserer Kommentare zu füllen.
Also, lassen Sie uns mit der Übung fortfahren, um zu lernen, wie wir Mongoose Bevölkerung verwenden.
Um mit dieser Übung zu beginnen,
wechseln Sie zum Projekt und öffnen Sie die Datei user.js.
Also, in der Datei user.js
speichern wir das Benutzerschema.
Ich werde das Benutzerschema ändern, indem ich ein paar weitere Felder darin hinzufüge.
Einer ist der Vorname,
der
vom Typ string sein wird und
der Standardwert wäre eine leere Zeichenfolge.
Also, der Vorname, wie der Name schon sagt,
speichert den Vornamen für den Benutzer und dann haben wir ein anderes Feld namens Nachname,
das auch von der gleichen Art ist.
Also, ich werde nur diese zwei Stücke von Informationen kopieren und dann kopieren Sie es
hier und so jetzt unser Benutzerdokument enthält,
zusätzlich zu dem Benutzernamen und Passwort,
Benutzernamen und Still und Salz, die wir zuvor gesehen haben,
Das wird automatisch durch den Pass lokalen Mongoose Modul hinzugefügt .
Wir haben auch den Vor- und Nachnamen für den Benutzer, der hier definiert wird.
Später werden wir sehen, wie wir
diese Werte initialisieren würden, indem wir den Registrierungsprozess des Benutzers ändern.
Jetzt, sobald wir dies abgeschlossen haben,
so dass auf diese Weise die Informationen des Benutzers
einfach abgerufen werden können, indem Sie das Benutzerdokument hier nachschlagen.
Also, jetzt, da wir die Informationen über den Benutzer im Benutzerdokument haben,
gehen in das Dish-Schema,
also gehen Sie in dishes.js Datei.
Im Dish-Schema früher
haben wir den Autor des Dokuments in Form einer Zeichenfolge hier gespeichert.
Jetzt werden wir die Tatsache nutzen, dass wir die
Unterstützung der Mungo Bevölkerung haben.
Also werde ich das Kommentarfeld von einer Zeichenfolge in
Mungo Schema-Typen Objekt-ID umwandeln.
Also, auf diese Weise, tut mir leid, falsches Feld.
Ich wollte das Autorenfeld in
Mungo Schema-Typen Objekt-ID umwandeln.
Also, das Autorenfeld jetzt anstatt eine Zeichenfolge zu speichern,
wird einen Verweis auf das Benutzerdokument haben.
Wenn ich also das Autorenfeld in diesen Typ umwandle,
wird die zweite Eigenschaft, die ich hier definiert habe, eine Referenz
sein, die ein Verweis auf das Benutzermodell wäre.
Auf diese Weise
verbinden wir nun dieses Autorenfeld und dieses Autorenfeld
speichert einfach einen Verweis auf die ID des Benutzerdokuments,
anstatt die Details über den Autor in Form eines Namens zu speichern.
Nun, wenn wir das tun,
können wir Mungo Populate verwenden, um
diese Informationen in unser Geschirr Dokument zu füllen, wann immer es erforderlich ist.
Also, mit dieser Änderung des Schemas Gerichte, in der Datei dishes.js,
werden wir jetzt den Geschirrrouter aktualisieren, um die Mungo Population zu verwenden.
Also, gehen Sie zu dishRouter.js.
In Gericht Router, daran erinnern, dass, wenn wir ein Gericht hier bekommen,
jetzt, wenn Sie das Gericht hier bekommen,
sagen wir Gerichte dann finden.
Also, genau an diesem Punkt,
werden wir sagen, Gerichte finden und wir werden danach sagen, bevölkern.
Also, wir verwenden die Bevölkerung Unterstützung in Mungo
und wir werden sagen, füllen Kommentare Autor.
Also, indem wir dies angeben,
sagen wir, wenn
das Geschirr Dokument konstruiert wurde, um die Antwort an den Benutzer zurückzusenden,
wir werden das Autorenfeld dort aus dem Benutzerdokument dort füllen.
Dieser Aufruf an das Populate stellt also sicher, dass
das andere Feld mit den Informationen nach Bedarf gefüllt wird.
In ähnlicher Weise gehen Sie zum Gericht ID hier,
auch in der Schale ID, das gleiche.
Wir werden sagen, füllen und Kommentare Autor hinzugefügt
in die Gerichte finden durch ID
im get der /dish ID Endpunkt.
In ähnlicher Weise, in den Kommentaren auch, wenn wir das Gericht abrufen,
werden wir sagen, füllen Sie Kommentare Autor hier und die
gleiche Sache auch in der Schale Router,
Gericht ID Kommentare, Kommentar ID auch.
Je größer diese Informationen dort bevölkert werden.
Das bedeutet natürlich, dass Sie, wenn Sie das Gericht veröffentlichen,
früher die Autoreninformationen in den Nachrichtentext aufnehmen.
Also, jetzt hier, wenn wir versuchen, den Kommentar in das zu schieben,
so dass dieser Beitrag entspricht dem Gericht ID Kommentarfeld.
So haben wir einen Kommentar zu einem bestimmten Gericht gepostet.
Also, jetzt in diesem Beitrag,
da wir die Informationen über den Autor nicht mehr speichern,
also was wir tun müssen, ist, wenn wir den Artikel in das Autorenfeld dort schieben.
Also, hier, wenn Sie die Informationen in das Gericht füllen,
müssen wir ersten-
Daran erinnern, dass der Körper den Kommentar bereits enthält,
aber die Eigenschaft des Autors wird nicht in den Körper der Nachricht im Buch,
aber je nachdem, welcher Benutzer diese Informationen veröffentlicht,
können wir füllen Sie sofort das Autorenfeld aus.
Woher wissen wir nun, welcher Benutzer diese Informationen veröffentlicht?
Die Tatsache, dass wir den Verifizierungsbenutzer hier für den Beitrag gemacht haben,
bedeutet, dass ein bestimmter Benutzer diese Informationen veröffentlicht,
und indem wir den Benutzer verifizieren,
hätten wir bereits den req.user in das Anforderungsobjekt geladen.
Im Anforderungsobjekt
können wir in gehen und sagen Wrack Benutzer,
und dann Unterstrich ID hier.
Also, lassen Sie mich noch einmal diesen Punkt wiederholen,
wie erhalten wir hier die Informationen des Autors? Denken Sie
nun daran, dass wir das Schemas Gerichte aktualisiert haben,
so dass das Autorenfeld im Kommentar einfach
die Objekt-ID speichert, die sich auf den Benutzer bezieht, der diesen Kommentar veröffentlicht.
Woher wissen wir nun, welcher Benutzer diesen Kommentar veröffentlicht?
Nun noch einmal, um diesen Punkt zu wiederholen,
erinnern Sie sich, dass, wenn wir den Benutzer hier durch Aufruf von authentifizieren verifizieren Benutzer überprüft,
der Pass autorisierte JWT würde
die Benutzerinformationen in den Anforderungstext in Form von req.user geladen haben.
Dieser Benutzer enthält also die ID
des bestimmten Benutzers, der diesen Kommentar tatsächlich veröffentlicht.
Also, wir haben bereits die Authentizität des Benutzers überprüft,
und so kann die Benutzer-ID einfach erhalten werden, indem Sie req.user sagen.
_ID und die ID dieses Benutzers,
werde ich dies dem Autorenfeld aus dem Kommentar zuweisen.
Nun, wenn der Kommentar eingeht,
enthält der Kommentar im Text der Anforderungsnachricht nur das Bewertungsfeld und das Kommentarfeld.
Jetzt wollen wir das Autorenfeld nicht mehr explizit von der Client-Seite senden,
stattdessen sollte das automatisch
auf der Serverseite basierend auf der Authentizität des
Benutzers eingefügt werden Das ist der Punkt, den ich
in dieser Modifikation wiederholt habe, die ich hier gemacht habe.
So, dass Benutzerinformationen automatisch von dem req.user abgerufen werden,
der in den Text der Anforderungsnachricht vom authentifizierenden Benutzer geladen
wird, der Passport authentifizieren mit der JWT-Strategie dort verwenden wird.
Darüber hinaus
müssen wir jetzt, wenn wir das aktualisierte Gericht hier erhalten, die Informationen des Autors in das Gericht füllen.
Also, an dieser Stelle,
wenn wir das Gericht hier erhalten,
werden wir dann die Gerichte hier durchsuchen.
Also, wir sagen dishes.FindById
und geben Sie dann die Schüssel ID als Parameter hier,
so dass wir sagen, finden Sie nach
ID, Gericht ID, und dann,
wir müssen die Kommentare Autor hier füllen,
und dann sagen wir dann Gericht.
Dort drinnen schicken wir diese Informationen zurück an den Benutzer hier.
Also, lassen Sie mich das ausschneiden und das hier einfügen.
Also, diese Änderung ist erforderlich, weil ich jetzt die
Informationen des Autors wieder in
den Kommentar füllen muss, bevor ich den aktuellen zurück an den Benutzer senden kann.
Also, das ist die zusätzliche Modifikation, die wir
tun müssen, wenn wir die Mongoose-Bevölkerung hier benutzen.
In ähnlicher Weise geht jetzt in den Put,
wenn wir einen bestimmten Kommentar mit der Kommentar-ID ändern,
so dass dies unter dem Gericht ID Kommentare Kommentar ID Teil ist.
Also, wenn wir die setzen hier,
so finden wir zuerst die Gerichte finden durch id req params Gericht ID,
dann in der Schüssel.
Also, das erste, was wir überprüfen, ist sicherzustellen, dass, wenn das Gericht nicht null ist,
und das Gericht Kommentare ID ist nicht null,
so dass wir überprüft, um sicherzustellen, dass der Kommentar tatsächlich in der Schüssel vorhanden ist,
und dann, wenn das Gericht selbst zurückgegeben wird,
dann müssen wir wieder nach
dem Gericht suchen, weil wir müssen die Kommentare Autor in das Gericht füllen.
Also hier, wir sagen dishes.findById (dish ID),
der Grund, warum wir eine weitere Suche machen
müssen, ist, weil wir die comments.author hier füllen müssen,
also das ist der einzige Grund, warum wir hier eine weitere Suche durchführen müssen.
Dann, wenn wir das Gericht hier erhalten,
offensichtlich, weil wir gerade das Gericht aktualisiert haben, so dass die Teller Informationen
in der Datenbank gefunden werden sollten,
so dass sollte gut funktionieren und dann im Inneren gibt es
Risikostatus-Code sagen 200 res setzen Header Inhaltstyp Anwendung json,
und dann das Gericht hier,
und dann werden wir Fehler hier behandeln,
und dann die anderen, wenn die Gerichte
jetzt und auch die anderen Fehler, die wir früher eingerichtet haben,
werden sie wie gewohnt hier behandelt werden.
Also, dies sind die zusätzlichen Änderungen, die wir sicherstellen müssen, wenn Sie das Gericht aktualisieren,
wenn Sie den aktualisierten Kommentar oder das aktualisierte Gericht zurücksenden,
dann werden wir den Kommentar in der Schüssel hier füllen.
In ähnlicher Weise gehen wir zum Löschen hier,
und dann nach dem Löschen des Kommentars,
wieder werden wir das Gericht holen und die Autoreninformationen füllen.
Also, lassen Sie mich einfach diesen Teil kopieren,
und dann werden wir genau das gleiche hier tun,
also sagen wir Gericht speichern,
dann werden wir dann überprüfen dish.FindById (Dish Autor),
und dann werden wir die Kommentare Autor füllen,
und dann sagen wir (dann) Gericht,
und dann res.StatusCode, und so weiter,
und die verbleibende Fehlerbehandlung genau wie zuvor hier.
Also, mit dieser Änderung an den Dish Router,
jetzt der letzte Punkt, den wir berücksichtigen müssen, ist die Tatsache, dass
wir in der Datei user.js jetzt in Felder hinzugefügt haben,
das Feld Vorname und Nachname, das standardmäßig leere Strings sein wird.
Wenn sich der Benutzer registriert,
sollten wir dem Benutzer erlauben, den Vor- und
Nachnamen im Registrierungsprozess anzugeben.
Nun, wo findet das statt?
Das findet in der s.js des Benutzers statt.
Also, zu Benutzern users.js zu gehen,
wenn der Benutzer auf den Schrägstrich Anmeldung postet,
früher haben wir nur den Benutzernamen und das Passwort gepostet.
Zusätzlich zu diesen beiden können wir
in dem JSON-Objekt, das wir in den Text der Anforderungsnachricht einschließen,
die von der Clientseite eingehende Post Request Nachricht,
auch den Vor- und Nachnamen für den Benutzer einschließen.
Also, wenn der Vorname und Nachname für den Benutzer enthalten sind,
was also werde ich hier tun?
Also, erinnern Sie sich, dass, wenn Sie sagen, user.register an dieser Stelle die Benutzerinformationen kommen,
und dann haben Sie den Benutzernamen hier eingereicht,
und Sie haben auch das Passwort hier zugewiesen, das
in den Hash und Salz durch den Pass lokalen Mungo verwandelt wird.
Nun, wenn es keinen Fehler gibt, bedeutet das, dass die Registrierung des Benutzers erfolgreich war,
und so an diesem Punkt, was wir tun werden, werden wir sagen, wenn req.body.
Vorname. Also, was bedeutet, dass der Körper der eingehenden Anforderungsnachricht,
wenn es den Vornamen enthält,
dann sagen wir user.firstname gleich req.body.firstname ist.
In ähnlicher Weise auch für den Nachnamen.
An dieser Stelle
würden wir den Benutzer hier zur Verfügung haben.
Sehen Sie, dass der Benutzer als zweiter Parameter für diese Callback-Funktion hier eintrifft.
Also, wir richten den Vornamen durch Ändern
der Vornamen-Eigenschaft innerhalb des Benutzerdokuments hier sagen, req.body.firstname.
Wenn es existiert, setzen wir den Vornamen des Benutzers auf diesen.
Ebenso, wenn der req.body.nachname verfügbar ist,
so werden wir auch den Nachnamen des Benutzers als req.body.lastname aktualisieren.
Und sobald wir diese beiden Änderungen an dem Vornamen und dem Nachnamen vorgenommen
haben, müssen wir die Änderung speichern, die wir dem Benutzer vorgenommen haben.
Also, wir haben gerade den Benutzer aktualisiert.
Also, wir sagen user.save dann wird dies
den Fehler oder den Benutzer zurückgeben.
Also, wenn die Änderung richtig gespeichert wurde,
dann wird es den Fehler zurückgeben,
sonst wird es den Benutzerwert zurückgeben und dieser Pass authentifizieren wir
es in diesem Benutzer hier tun.
Also, wir werden sagen, user.save (irr, user).
Und dann müssen wir auch eine Kreuzprüfung durchführen, um sicherzustellen, dass,
wenn es einen Fehler beim Speichern der Änderungen für den Benutzer gibt,
wir den Res-Statuscode 500 sagen,
also lassen Sie mich das von dort kopieren.
Also, wir sagen res Statuscode 500,
res setzen Header Inhaltstyp Anwendung json und res.jason hier.
Dann, und wir werden zu diesem Punkt zurückkehren.
Wenn es keinen Fehler gibt,
dann natürlich authentifizieren Sie den Benutzer, indem Sie
Pass authentifizieren mit dem lokalen anrufen, um sicherzustellen, dass
die Benutzerregistrierung erfolgreich war und dies
korrekt durchgeführt werden sollte und in diesem Fall werden Sie diese Nachricht zurück an die Client-Seite.
Wir müssen diesen user.save hier schließen. Stellen Sie
also sicher, dass Sie diesen Endpunkt korrekt schließen.
Also, user.save ist hier geschlossen, und das war's.
Dies sind die Änderungen, die wir für den Benutzer vornehmen müssen.
So, nachdem der Benutzer mit dem angegebenen Benutzernamen und dem angegebenen Passwort registriert wurde,
dann, nachdem der Benutzer erfolgreich registriert wurde,
dann werden wir das Feld Vorname und Nachname
des Benutzerdokuments setzen, indem wir diese beiden hier verwenden.
Wir möchten sicherstellen, dass der Benutzer erfolgreich
registriert ist, bevor wir dafür den Vor- und Nachnamen gesendet haben.
Deshalb führen wir diesen Vorgang durch, nachdem der Benutzer
erfolgreich registriert wurde. Das war's.
Lassen Sie uns die Änderungen speichern und gehen und überprüfen Sie den Server.
Nachdem Sie die Änderungen gespeichert haben,
gehen wir nun zum Terminal und
dann, bevor ich den Server starte,
lassen Sie mich zuerst meine MongoDB überprüfen und den Benutzer löschen, den wir zuvor registriert haben.
Also, wir werden sagen, verwenden Sie Verwirrung und dann sagen wir db.usersfind.
Wir wissen also, dass dieser bestimmte Benutzer früher registriert wurde,
aber wenn wir diesen Benutzer registrieren,
haben wir nicht den Vor- und Nachnamen für den Benutzer registriert.
Also werde ich diesen Benutzer löschen und dann den Benutzer erneut registrieren.
Also, um das mit der Mongo-Welligkeit zu tun, werde ich sagen, dass db-Benutzer fallen,
und dann sagen wir,
dass db-Benutzer finden, und das sollte eine leere zurückgeben.
Keine Benutzer registriert dort und dann verlassen wir die Mongo-Welligkeit.
Und so, sobald wir diesen registrierten Benutzer entfernt haben
, dann lassen Sie mich meinen Server starten.
Und sobald der Server betriebsbereit ist,
gehen wir zu Postman und registrieren Sie dann
einen neuen Benutzer zusammen mit dem Vor- und Nachnamen des Benutzers.
Dann werden sie sich als dieser Benutzer anmelden und dann schauen wir uns an, wie
die Mongoose-Bevölkerung uns hilft, die Informationen über
den Benutzer automatisch in das Dokument dort zu füllen.
Jetzt gehen Sie zu Postman,
lassen Sie mich eine Anmeldung für einen neuen Benutzer.
Also, ich mache einen Beitrag localhost: 3000 Benutzer melden sich an.
Im Nachrichtentext
hatten wir den Benutzernamen und das Passwort bereits drin.
Lassen Sie mich zwei zusätzliche Felder hinzufügen:
Vorname, Nachname.
Registrieren Sie dann diesen Benutzer.
Sobald ich den Benutzer registriert habe,
können Sie sehen, dass die Registrierung erfolgreich war.
Lassen Sie mich nun als dieser Benutzer einloggen.
Also, um sich als Benutzer anzumelden,
lassen Sie mich einen Beitrag machen und überprüfen, um sicherzustellen, dass.
Also, ich mache einen Beitrag zum Anmelden von Benutzern.
Lassen Sie mich überprüfen und ich sehe, dass der Benutzername und das Passwort korrekt eingegeben sind.
Also, wenn ich mich einlogge,
sollte ich erfolgreich eingeloggt sein und ich sollte in der Lage sein, dieses Token dort zu erhalten.
Denn dieses Token ist wichtig für uns, um in einer Schüssel zu unserer Server-Site hinzufügen zu können.
Nachdem Sie das Token erhalten haben,
kopieren Sie diese Token-Zeichenfolge und speichern Sie sie, da Sie dies im
Autorisierungs-Header für die
Post-Put- und Löschvorgänge benötigen, die Sie später ausführen werden.
Also lassen Sie mich das Token kopieren.
Nun, normalerweise würde ich diese Token behalten, ist,
dass ich einfach ein Textdokument öffne und es dann kopieren und in das Textdokument einfügen werde.
Damit
ich für nachfolgende Postman-Anfragen diese Zeichenfolge einfach kopieren und sie dann bei
Bedarf in den Autorisierungs-Header einfügen kann.
Also, lassen Sie mich das Token kopieren und hier habe ich ein Textdokument geöffnet.
Also, ich werde diese Zeichenfolge in dieses Textdokument einfügen.
Also, hier haben wir das Token, das wir erhalten haben.
Lassen Sie uns jetzt gehen und ein Gericht auf unserem Server posten.
Zurück zum Postboten,
lassen Sie mich ein Gericht auf dem Server posten.
Also, hier werde ich den Beitrag hier wählen.
Drinnen hier habe ich die Dish-Informationen, die ich früher verwendet hatte, aber für die Kommentare
, jetzt, daran erinnern, dass wir früher Autorenfeld hatten, das eine Zeichenfolge speicherte.
Also, alle diese Kommentare sind nicht gültig.
Also werde ich alle diese Kommentare aus der Einreichung löschen, weil
wir jetzt erwarten, dass der Benutzer selbst Kommentare posten wird.
Wenn der Benutzer Kommentare eingibt,
fügen wir automatisch die ID des Benutzers in das Autorenfeld der Kommentare hinzu.
Also, lassen Sie mich dieses Gericht hier posten.
Gehe zum Header,
in der Autorisierungs-Header, werde ich sagen,
Bearer und dann, fügen Sie das Token ein und senden Sie es dann.
Ich sollte einen Beitrag dazu machen.
Also, ich werde Post sagen und so, wenn ich jetzt poste,
sehen Sie, dass dieses Gericht auf der Serverseite veröffentlicht wurde,
und mit dem Kommentarfeld in diesem Moment leer ist.
Also, nachdem ich dieses Gericht gepostet habe,
lassen Sie mich die ID dieses Gerichts kopieren.
Also, lassen Sie mich diese ID für das Gericht kopieren, weil ich
das brauchen, um Kommentare für dieses Gericht zu posten.
Dann gehe ich zu meinem Texteditor,
ich werde die ID des Gerichts hier speichern.
Nun, natürlich, sobald Sie Ihre Client-Seite erstellt haben,
wird Ihr Client automatisch alle diese Informationen haben.
So wird Ihr Client automatisch in der Lage sein, das Token zu senden und so weiter.
Also, Sie müssen diese Ausschneiden und Einfügen Sache nicht tun, aber mit Postboten
ist dies die einzige Möglichkeit, dass wir alle Informationen zu unseren Postboten hinzufügen können,
die vom Postboten auf den Server gehen.
Nun, um uns zu überzeugen, dass dieses Gericht tatsächlich existiert,
lassen Sie mich ein get auf der lokalen Hostcolon:3000/Gerichte.
Wenn ich ein get mache, können Sie tatsächlich sehen, dass
dieses spezielle Gericht auf der Serverseite existiert.
Also, lasst uns jetzt versuchen, einen Kommentar zu posten.
Also, um einen Kommentar zu posten,
lassen Sie uns einen Beitrag machen und wir werden sagen,
localhost: 3000/Gerichte, Schrägstrich und die ID des Gerichts, das
ich gerade kopiert habe, und Schrägstrich Kommentare.
Wenn Sie auf die Kommentare posten,
müssen Sie sicherstellen, dass wir im Körper den Kommentar hier hinzufügen werden.
Also, ein typischer Kommentar enthält
eine Bewertung von sagen
fünf und dann Kommentar.
Also, lassen Sie mich einfach einen zufälligen Kommentar eingeben,
nur um Ihnen zu zeigen.
Also, dies sollte im Körper des Beitrags für die Kommentare sein und in der Kopfzeile
sollten wir den Autorisierungs-Header hinzufügen.
Also, für den Autorisierungs-Header, sagen wir, Träger.
Ich muss das Token hier einfügen und
den Token-Wert einfügen, den ich früher gespeichert habe.
Lassen Sie uns jetzt diesen Kommentar posten.
Dann, wenn der Kommentar veröffentlicht wird,
schauen wir uns den zurückgegebenen Wert hier an.
Wenn Sie also nach unten blättern,
können Sie sehen, dass das Gericht, zu dem der Kommentar hinzugefügt wurde, zurückgegeben wurde.
Beachten Sie, dass die Teller Informationen vorhanden sind, aber beachten Sie insbesondere,
was in dem Kommentar enthalten ist, der hier gepostet wurde.
Wie Sie sehen können, wissen Sie bereits, dass die aktualisierten und
erstellten Felder automatisch von Mungo hinzugefügt werden.
Die Bewertung und der Kommentar, den wir eingereicht haben, sind
genau da, aber beachten Sie, wie das Autorenfeld
jetzt die ID enthält, die dem Benutzer entspricht.
Nun, wie wir im Code gesehen haben, wie der Autor Feld-Informationen hinzugefügt wird, jetzt,
wenn Sie ein bekommen auf dem Geschirr,
Sie werden feststellen, dass dieses Feld Autor
automatisch von den Benutzerinformationen hier ausgefüllt werden.
Also, lassen Sie uns jetzt ein get auf dem localhost: 3000/Gerichte.
Also, wenn wir jetzt ein get auf diesen Punkt,
Sie werden jetzt feststellen, dass in den Gerichten hier,
genau dort, die Informationen über das Gericht bereits
vorhanden ist, aber beachten Sie, wie der Kommentar jetzt konstruiert ist.
Der Kommentar enthält nun,
die Bewertungskommentarfelder, wie wir zuvor gesehen haben,
die aktualisierte und erstellte bei,
aber beachten Sie, was mit dem Autorenfeld hier passiert ist.
Wenn Sie also eine get-Anfrage ausführen, weil wir eine Auffüllung auf
der Serverseite durchgeführt haben, wenn der get-Vorgang aufgerufen wird,
hat das Populate
die Autoreninformationen automatisch in die Position im Autorenfeld hier aufgefüllt.
Dort können Sie also sehen, dass Sie vom Autor aus den
Nachnamen und die
Vornameninformationen automatisch aus dem Autorenfeld nachschlagen können.
Wenn Sie also einen Kommentar erstellen müssen,
haben Sie jetzt die Bewertung,
den Kommentar und auch den Vor- und Nachnamen
des Autors automatisch in dieses Dokument aufgenommen.
Außerdem ist der Benutzername in diesem Dokument enthalten.
Auf diese Weise können Sie Informationen aus einem anderen Dokument hinzufügen und
ein zweites Dokument mit diesen Informationen füllen, bevor Sie von der Serversite aus antworten.
Dies ist also die Verwendung von Mungo Population und wie wir
Informationen automatisch in ein Mungo Dokument füllen können.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir die Verwendung von Mungo Population gesehen und wir haben auch gesehen,
wie wir Informationen von einem Dokument in ein anderes Dokument auffüllen können.
Wenn wir den Server so modifizieren, dass er die Bevölkerung für die Anfragen erledigt,
kümmert sich Mungo automatisch darum, diese Informationen für uns zu füllen.
Alles, was wir tun müssen,
ist, den Verweis auf das andere Dokument in Form der Objekt-ID
in dem Dokument zu speichern, in das Sie diese Informationen füllen möchten.
Damit schließen wir diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit mit der Nachricht zu machen, Mungo Population.