Maintenant que nous avons appris sur la population mongoose,
et comment elle nous permet de remplir un document avec des informations provenant d'un autre document.
Dans cet exercice, nous allons modifier le serveur express sur lequel nous avons travaillé jusqu'à présent.
Dans le schéma plat que nous avons défini plus tôt, nous avons eu des commentaires.
Pour les commentaires, nous avions le champ auteur
que nous utilisons pour stocker les détails sur l'auteur.
Dans cet exercice, nous transformerons le champ auteur en référence à un document utilisateur,
et nous utiliserons la population mongoose pour remplir les informations dans
le document plats au besoin
afin de fournir les informations au client.
Maintenant, l'utilisation de la population peuplée et mongoose doit être faite
judicieusement afin de ne pas causer trop de frais généraux sur le côté serveur.
Maintenant, dans cet exercice,
nous allons l'utiliser simplement pour remplir l'information
dans le champ auteur de nos commentaires.
Alors, continuons avec l'exercice pour apprendre comment nous utilisons la population mongoose.
Pour commencer cet exercice,
allez dans le projet et ouvrez le fichier user.js.
Ainsi, dans le fichier user.js,
nous stockons le schéma utilisateur.
Je vais modifier le schéma de l'utilisateur en ajoutant quelques champs supplémentaires là-dedans.
L' un est le prénom,
qui sera de
la chaîne de type et
la valeur par défaut serait une chaîne vide.
Donc, le prénom comme le nom l'indique,
stocke le prénom de l'utilisateur et ensuite nous aurons un autre champ appelé nom de famille,
qui est également du même genre.
Donc, je vais juste copier ces deux éléments d'information et puis le copier
ici et maintenant notre document utilisateur contiendra,
en plus du nom d'utilisateur et mot de passe, nom
d'utilisateur et hush et sel que nous avons vu plus tôt,
qui est automatiquement ajouté par le module local de Mongoose .
Nous aurons également le prénom et le nom de famille de l'utilisateur défini ici.
Plus tard, nous verrons comment nous allons initialiser
ces valeurs en modifiant le processus d'inscription de l'utilisateur.
Maintenant, une fois que nous avons terminé cela, de
cette façon, les informations de l'utilisateur
peuvent simplement être récupérées en cherchant le document utilisateur ici.
Donc, maintenant que nous avons les informations sur l'utilisateur dans le document utilisateur,
aller dans le schéma plat,
donc aller dans le fichier dishes.js.
Dans le schéma plat plus tôt,
nous stockions l'auteur du document sous la forme d'une chaîne ici.
Maintenant, nous allons profiter du fait que nous
avons le soutien de la population de mangoustes.
Donc, je vais transformer le champ de commentaire d'une chaîne en type de
schéma mongoose ID d'objet.
Donc, de cette façon, désolé, mauvais champ.
Je voulais transformer le champ auteur en
type de schéma mongoose ID d'objet.
Ainsi, le champ auteur maintenant au lieu de stocker une chaîne,
aura une référence au document utilisateur.
Donc, lorsque je transforme le champ auteur dans ce type,
alors la deuxième propriété que j'ai définie ici sera une référence,
qui serait une référence au modèle utilisateur.
Donc, de cette façon, nous allons maintenant
connecter ce champ auteur et ce champ auteur va
simplement stocker une référence à l'ID du document utilisateur,
au lieu de stocker les détails sur l'auteur sous la forme d'un nom.
Maintenant, quand nous faisons cela,
nous pouvons utiliser mongoose populate pour remplir
cette information dans notre document de plats chaque fois que nécessaire.
Donc, avec cette modification du schéma des plats, dans le fichier dishes.js,
nous allons maintenant mettre à jour le routeur plat pour utiliser la population de mangoustes.
Donc, aller à dishRouter.js.
Dans routeur à plat, rappelez-vous que lorsque nous recevons un plat ici,
maintenant quand vous obtenez le plat ici,
nous disons plats trouver alors.
Donc, à ce moment-là,
nous allons dire que les plats trouvent et nous dirons après cela, peupler.
Donc, nous utilisons le soutien de la population en mongoose
et nous dirons peupler commentaires auteur.
Donc, en déclarant ceci,
nous disons que lorsque
le document plats a été construit pour renvoyer la réponse à l'utilisateur,
nous allons remplir le champ auteur à l'intérieur à partir du document utilisateur.
Ainsi, cet appel au peuplate garantira que
l'autre champ sera rempli avec les informations requises.
De même, aller à l'ID du plat ici,
même dans l'ID du plat, même chose.
Nous dirons peupler et commentaires auteur ajouté
dans les plats find by id dans
le get du point de terminaison /dish ID.
De même, dans les commentaires aussi quand nous récupérons le plat,
nous dirons remplir les commentaires auteur ici et la
même chose aussi dans le routeur de plat, les
commentaires d'ID de plat, ID de commentaire aussi.
Le plus grand peuplement de cette information là-bas.
Bien sûr, ce que cela signifie, c'est que lorsque vous publiez le plat,
plus tôt, vous incluez les informations de l'auteur dans le corps du message.
Donc, maintenant ici quand nous essayons de pousser le commentaire dans cela,
donc ce post correspond au champ de commentaires d'ID plat.
Donc, c'est comme ça que nous publiions un commentaire sur un plat spécifique.
Donc, maintenant dans ce post,
puisque nous ne stockons plus les informations sur l'auteur,
donc ce que nous devons faire est quand nous poussons l'élément dans le champ auteur là-bas.
Donc, ici, lorsque vous remplissez les informations dans le plat,
nous devrons premier-
Rappelons que le corps contient déjà le commentaire,
mais la propriété de l'auteur ne sera pas là dans le corps du message dans le livre,
mais en fonction de l'utilisateur qui affiche cette information,
nous pouvons remplissez immédiatement le champ auteur.
Maintenant, comment pouvons-nous savoir quel utilisateur publie cette information ?
Le fait que nous ayons fait la vérification de l'utilisateur ici pour le post,
signifie qu'un utilisateur spécifique publie cette information,
et en faisant l'utilisateur de vérification,
nous aurions déjà chargé dans le req.user dans l'objet requête.
Dans l'objet de requête,
nous pouvons entrer et dire l'utilisateur de l'épave,
puis souligner l'ID ici.
Permettez-moi donc encore une fois de répéter ce point,
comment obtenons-nous les informations de l'auteur ici ?
Maintenant, rappelez-vous que nous avons mis à jour le schéma des plats, de
sorte que le champ auteur dans le commentaire stockera simplement
l'ID de l'objet faisant référence à l'utilisateur qui publie ce commentaire.
Maintenant, comment pouvons-nous savoir quel utilisateur publie ce commentaire ?
Maintenant encore, pour réitérer ce point,
rappelez-vous que lorsque nous avons vérifié l'utilisateur ici en appelant authentifier l'utilisateur,
le passeport autorisé JWT aurait chargé les
informations de l'utilisateur dans le corps de la demande sous la forme de req.user.
Ainsi, cet utilisateur contiendra l'ID de
l'utilisateur spécifique qui publie ce commentaire.
Donc, nous avons déjà vérifié l'authenticité de l'utilisateur,
et donc l'ID utilisateur peut simplement être obtenu en disant req.user.
_ID, et l'ID de
cet utilisateur, je vais l'affecter au champ auteur du commentaire.
Maintenant, lorsque le commentaire est entré,
le commentaire dans le corps du message de demande
ne contiendra que le champ d'évaluation et le champ de commentaire.
Maintenant, nous ne voulons plus envoyer explicitement le champ auteur du côté client,
au lieu de cela devrait être automatiquement
inséré du côté serveur en fonction de l'authenticité de
l'utilisateur C'est le point que j'avais
répété dans cette modification que j'ai faite ici.
Ainsi, que les informations des utilisateurs sont automatiquement obtenues à partir du req.user qui est
chargé dans le corps du message de demande par l'utilisateur authentifier vérification,
qui va utiliser Passport authentifier avec la stratégie JWT là.
En outre, maintenant, lorsque nous recevons le plat mis à jour ici,
nous devons remplir les informations de l'auteur dans le plat.
Donc, à ce stade,
quand nous recevons le plat ici,
nous allons alors chercher les plats ici.
Donc, nous allons dire plats.findById,
puis fournir l'ID plat comme paramètre ici,
donc nous allons dire trouver par ID,
plat ID, et puis,
nous devons remplir l'auteur des commentaires ici,
et puis nous allons dire puis plat.
À l'intérieur, nous allons renvoyer cette information à l'utilisateur ici.
Laisse-moi couper ça et coller ça ici.
Donc, cette modification est nécessaire car maintenant j'ai besoin de remplir
les informations de l'auteur dans
le commentaire avant de pouvoir renvoyer le courant à l'utilisateur.
Donc, c'est la modification supplémentaire que nous devons
faire lorsque nous utilisons la population mongoose ici.
De même, maintenant dans le put,
lorsque nous modifions un commentaire spécifique avec l'ID de commentaire,
donc c'est sous la partie ID de commentaire de l'ID de plat.
Donc, quand nous faisons le mettre ici,
donc nous trouvons d'abord les plats trouver par id req params ID plat,
puis dans le plat.
Donc, la première chose que nous vérifions est de nous assurer que si le plat n'est pas nul,
et que l'ID des commentaires de plat n'est pas nul,
donc nous avons vérifié pour nous assurer que le commentaire est effectivement présent dans le plat,
puis quand le plat lui-même est retourné,
alors nous devons chercher à nouveau
le plat parce que nous devons remplir l'auteur des commentaires dans le plat.
Donc, ici, nous allons dire dishes.findById (dish ID),
la raison pour laquelle nous devons faire une recherche de plus est parce que
nous devons remplir les commentaires.author ici,
donc c'est la seule raison pour laquelle nous devons faire une recherche de plus ici.
Ensuite, quand nous recevons le plat ici,
évidemment parce que nous venons de mettre à jour le plat de sorte que les informations de plat devraient être
trouvées dans la base de données, de
sorte que cela devrait fonctionner correctement et puis à l'intérieur il y aura le
code d'état de risque 200 res ensemble application de type de contenu d'en-tête json,
puis retourner le plat ici,
et puis nous allons gérer les erreurs ici,
puis les autres si les plats
maintenant et aussi les autres erreurs que nous avons mises en place plus tôt,
ils seront traités comme d'habitude ici.
Donc, ce sont les changements supplémentaires que nous devons nous assurer lorsque vous mettez à jour le plat,
lorsque vous renvoyez le commentaire mis à jour ou le plat mis à jour,
alors nous allons remplir le commentaire dans le plat ici.
De même, aller à la suppression ici,
puis après la suppression du commentaire,
encore une fois nous allons chercher le plat et remplir les informations de l'auteur.
Donc, laissez-moi juste copier cette partie,
et puis nous allons faire exactement la même chose ici,
donc nous allons dire plat sauver,
alors nous allons être alors vérifier plat.FindById (auteur de plat),
et puis nous allons remplir l'auteur des commentaires,
puis nous allons dire (puis) plat,
puis RES.StatusCode, et ainsi de suite,
et la gestion des erreurs restantes comme ici.
Donc, avec cette modification au routeur plat,
maintenant le dernier point que nous devons considérer est le fait que dans le fichier user.js,
nous avons maintenant ajouté dans les champs,
le prénom et le champ de nom qui par défaut seront des chaînes vides.
Ainsi, lorsque l'utilisateur s'inscrit,
nous devrions permettre à l'utilisateur de fournir le prénom et le nom de
famille dans le processus d'enregistrement.
Maintenant, où est-ce que ça a lieu ?
Cela a lieu dans le s.js de l'utilisateur.
Donc, en allant aux utilisateurs users.js,
lorsque l'utilisateur publie sur l'inscription slash,
plus tôt, nous ne publions que le nom d'utilisateur et le mot de passe.
En plus de ces deux,
dans l'objet json que nous incluons dans le corps du message de requête entrant,
le message de demande de poste venant du côté client,
nous pouvons également inclure le prénom et le nom de famille de l'utilisateur.
Donc, quand le prénom et le nom de l'utilisateur sont inclus,
alors que vais-je faire ici ?
Donc, rappelez-vous que lorsque vous dites user.register à ce stade, les informations de l'utilisateur entrent,
puis vous avez soumis le nom d'utilisateur ici,
et vous avez également attribué le mot de passe ici qui sera
transformé en hachage et sel par le passeport mongoose local.
Maintenant, s'il n'y a pas d'erreur qui signifie que l'enregistrement de l'utilisateur a réussi,
et donc à ce stade ce que nous allons faire est nous dirons si req.body.
Prénom. Donc, ce qui signifie que le corps du message de demande entrante,
s'il contient le prénom,
alors nous dirons user.firstname est égal à req.body.firstname.
De même, pour le nom de famille aussi.
Donc, à ce stade,
nous aurions l'utilisateur disponible ici.
Voir l'utilisateur arrive en tant que deuxième paramètre de cette fonction de rappel ici.
Donc, nous configurons le prénom en changeant
la propriété prénom à l'intérieur du document utilisateur en disant ici, req.body.firstname.
S' il existe, nous allons définir le prénom de l'utilisateur sur cela.
De même, si le nom req.body.last est disponible,
nous allons également mettre à jour le nom de famille de l'utilisateur en tant que req.body.lastname.
Et une fois que nous avons fait ces deux changements au prénom et au nom de famille,
alors nous devons enregistrer la modification que nous avons faite à l'utilisateur.
Donc, nous venons de mettre à jour l'utilisateur.
Donc, nous allons dire user.save alors cela
retournera l'erreur ou l'utilisateur.
Donc, si la modification a été enregistrée correctement,
alors il retournera l'erreur,
sinon il retournera la valeur de l'utilisateur et ce passeport authentifier nous le
ferons à l'intérieur de cet utilisateur ici.
Donc, nous allons dire, user.save (err, utilisateur).
Et puis nous devons aussi vérifier que
s'il y a une erreur dans l'enregistrement des changements à l'utilisateur,
alors nous dirons le code d'état de res 500,
alors laissez-moi copier ceci à partir de là.
Donc, nous dirons le code d'état res 500,
res jeu de type d'en-tête application json et res.jason ici.
Ensuite, et nous reviendrons à ce point.
S' il n'y a pas d'erreur,
alors bien sûr, vous authentifiez l'utilisateur en appelant
passeport authentifier auprès du local pour vous assurer que
l'enregistrement de l'utilisateur a été réussi et cela devrait être
fait correctement et quand dans ce cas, vous retournerez ce message côté client.
Nous devons fermer cet utilisateur.save ici.
Donc, assurez-vous que vous fermez ce point de terminaison correctement.
Donc, user.save est fermé ici, et c'est tout.
Ce sont les changements que nous devons apporter à l'utilisateur.
Ainsi, après que l'utilisateur est enregistré avec le nom d'utilisateur donné et le mot de passe donné,
puis après que l'utilisateur est enregistré avec succès,
nous allons définir le prénom et
le champ de nom du document utilisateur en utilisant ces deux ici.
Nous voulons nous assurer que l'utilisateur est
enregistré avec succès avant d'envoyer le prénom et le nom de famille pour cela.
Donc, c'est pourquoi nous effectuons cette opération après que l'utilisateur
est enregistré avec succès. C'est ça.
Sauvegardons les modifications et allons vérifier le serveur.
Après avoir enregistré les changements,
allons maintenant au terminal et
puis avant de démarrer le serveur,
laissez-moi d'abord vérifier mon MongoDB et supprimer l'utilisateur que nous avons enregistré plus tôt.
Donc, nous allons dire utiliser la confusion et ensuite nous dirons db.usersfind.
Donc, nous savons que cet utilisateur particulier a été enregistré plus tôt,
mais lorsque nous enregistrons cet utilisateur,
nous n'avons pas enregistré le prénom et le nom de famille de l'utilisateur.
Donc, je vais supprimer cet utilisateur, puis ré-enregistrer l'utilisateur.
Donc, pour ce faire en utilisant l'ondulation Mongo, je dirai que les utilisateurs de db abandonnent,
et ensuite nous dirons que les utilisateurs de db trouvent,
et cela devrait retourner un vide.
Aucun utilisateur enregistré là-bas, puis nous quitterons l'ondulation Mongo.
Et donc, une fois que nous avons supprimé cet utilisateur enregistré,
alors, laissez-moi démarrer mon serveur.
Et une fois que le serveur est opérationnel,
allons dans Postman et puis inscrivons
un nouvel utilisateur avec le prénom et le nom de famille de l'utilisateur.
Ensuite, ils se connecteront en tant qu'utilisateur, puis nous verrons comment
la population mongoose nous aide à remplir
automatiquement les informations sur l'utilisateur dans le document là-bas.
Maintenant, allez à Postman,
laissez-moi faire une inscription d'un nouvel utilisateur.
Donc, je fais un post localhost : 3000 utilisateurs s'inscrivent.
Dans le corps du message,
nous avions déjà le nom d'utilisateur et le mot de passe.
Permettez-moi d'ajouter deux champs supplémentaires :
prénom, nom de famille.
Ensuite, enregistrez cet utilisateur.
Donc, une fois que j'ai enregistré l'utilisateur,
vous pouvez voir que l'enregistrement a réussi.
Maintenant, laissez-moi me connecter en tant qu'utilisateur.
Donc, pour me connecter en tant qu'utilisateur,
laissez-moi faire un post et vérifier pour m'assurer.
Donc, je fais un post pour les utilisateurs se connecter.
Laissez-moi vérifier et je vois que le nom d'utilisateur et le mot de passe sont correctement tapés là.
Donc, quand je me
connecte, je devrais être connecté avec succès et je devrais être en mesure d'obtenir ce jeton là.
Parce que ce jeton est essentiel pour que nous puissions ajouter dans un plat à notre site serveur.
Donc, après avoir obtenu le jeton,
copiez cette chaîne de jeton et enregistrez-la car vous en aurez besoin dans
l'en-tête d'autorisation pour les
opérations de post put and delete que vous allez effectuer plus tard.
Laisse-moi copier ce jeton.
Maintenant, normalement, la façon dont je garderais ces jetons est,
que je vais juste ouvrir un document texte, puis le copier et le coller dans le document texte.
Pour que pour les demandes ultérieures de facteur,
je peux simplement copier cette chaîne, puis la coller dans
l'en-tête d'autorisation, si nécessaire.
Donc, laissez-moi copier ce jeton et ici j'ai un document texte ouvert ici.
Donc, je vais coller cette chaîne dans ce document texte.
Donc, nous avons ici le jeton que nous avons obtenu.
Allons maintenant poster un plat sur notre serveur.
Retourner au facteur,
laisse-moi poster un plat au serveur.
Donc, c'est là que je vais choisir le poste ici.
À l'intérieur ici, j'ai les informations de plat que j'avais utilisées plus tôt mais pour les commentaires,
maintenant, rappelez-vous que plus tôt nous avions un champ d'auteur qui stockait une chaîne.
Donc, tous ces commentaires ne sont pas valides.
Donc, je vais supprimer tous ces commentaires de la soumission parce que,
maintenant, nous nous attendons à ce que l'utilisateur publie des commentaires par lui-même.
Lorsque l'utilisateur publie des commentaires,
nous ajouterons automatiquement l'ID de l'utilisateur dans le champ auteur des commentaires.
Alors, laissez-moi poster ce plat ici.
Aller à l'en-tête,
dans l'en-tête d'autorisation, je vais dire,
porteur, puis, coller le jeton, puis soumettre.
Je devrais faire un post là-dessus.
Donc, je dirai post et donc quand je post maintenant,
vous voyez que ce plat a été posté du côté serveur,
et avec le tableau de commentaires étant vide en ce moment.
Donc, après avoir posté ce plat,
laissez-moi copier l'ID de ce plat.
Donc, laissez-moi copier cet ID pour le plat parce que j'en aurai
besoin pour poster des commentaires pour ce plat.
Ensuite, en allant à mon éditeur de texte,
je vais enregistrer l'ID du plat ici.
Maintenant, bien sûr, une fois que vous aurez construit votre côté
client, votre client aura automatiquement toutes ces informations.
Ainsi, votre client sera automatiquement en mesure d'envoyer le jeton et ainsi de suite.
Donc, vous n'avez pas besoin de faire cette chose de coupe-coller, mais avec
le facteur, c'est la seule façon d'ajouter des informations à nos demandes de facteur,
qui vont du facteur au serveur.
Maintenant, afin de nous convaincre que ce plat existe réellement,
laissez-moi faire un get sur l'hôtcolon:3000/plats.
Quand je fais un get, vous pouvez effectivement voir que
ce plat particulier existe sur le côté serveur.
Alors, essayons maintenant de poster un commentaire.
Donc, pour poster un commentaire,
faisons un post et nous allons dire,
localhost : 3000/plats, barre oblique et l'ID du plat que
je viens de copier, et des commentaires barre oblique.
Lorsque vous publiez sur les commentaires,
vous devez vous assurer que dans le corps, nous allons ajouter dans le commentaire ici.
Donc, un commentaire typique contient
une note de disons
cinq, puis commenter.
Donc, laissez-moi juste taper un commentaire aléatoire,
juste pour vous démontrer.
Donc, cela devrait être dans le corps du post pour les commentaires et dans l'en-tête,
nous devrions ajouter l'en-tête d'autorisation.
Donc, pour l'en-tête d'autorisation, nous dirons, porteur.
J' ai besoin de coller le jeton ici, en
collant la valeur du jeton que j'ai enregistrée plus tôt.
Nous allons maintenant poster ce commentaire.
Ensuite, lorsque le commentaire est posté,
regardons la valeur renvoyée ici.
Ainsi, lorsque vous naviguez vers le bas,
vous pouvez voir que le plat auquel le commentaire a été ajouté, a été retourné.
Notez que l'information du plat est là, mais notez en particulier,
ce qui est contenu dans le commentaire qui a été posté ici.
Ainsi, comme vous pouvez le voir, vous savez déjà que les
champs mis à jour et créés sont automatiquement ajoutés par mongoose.
La note et le commentaire que nous avons soumis sont
juste là, mais notez comment le champ auteur
contient maintenant l'ID correspondant à l'utilisateur.
Maintenant, comme nous l'avons vu dans le code comment les informations de champ auteur sont ajoutées, maintenant,
si vous faites un get sur la vaisselle,
vous remarquerez que ce champ auteur sera
automatiquement rempli par les informations des utilisateurs ici.
Donc, faisons maintenant un get sur le localhost : 3000/plats.
Donc, quand nous faisons maintenant un get sur ce point,
vous remarquerez maintenant que dans les plats ici,
juste là, les informations sur le plat est déjà
présent, mais notez comment le commentaire est maintenant construit.
Le commentaire contient maintenant,
les champs de commentaire de notation comme nous l'avons vu précédemment,
le mis à jour et créé à,
mais notez ce qui est arrivé au champ auteur ici.
Donc, lorsque vous faites une requête get parce que nous avons fait un remplissage
côté serveur lorsque l'opération get est appelée,
le remplissage a automatiquement rempli les
informations de l'auteur en position dans le champ auteur ici.
Ainsi, là, vous pouvez voir que de l'auteur,
vous pouvez maintenant rechercher le nom de famille et
les informations de prénom automatiquement à partir du champ auteur.
Donc, si vous avez besoin de construire un commentaire,
vous avez maintenant la note,
le commentaire, ainsi que le prénom et le nom de famille de
l'auteur automatiquement inclus dans ce document.
En outre, le nom d'utilisateur est également inclus dans ce document.
Ainsi, vous pouvez ajouter des informations à partir d'un autre document et remplir
un second document avec ces informations avant de répondre à partir du site du serveur.
Donc, c'est l'utilisation de la population de mangoustes et comment nous
pouvons automatiquement remplir des informations dans un document de mangouste.
Avec cela, nous complétons cet exercice.
Dans cet exercice, nous avons vu l'utilisation de la population de mangoustes et nous avons également vu
comment nous pouvons alimenter les informations d'un document dans un autre document.
Par conséquent, lorsque nous modifions le serveur pour faire la population pour les demandes,
mongoose prendra automatiquement soin de remplir cette information pour nous.
Tout ce que nous avons à faire,
est de stocker la référence à l'autre document sous la forme de l'ID d'objet,
dans le document dans lequel vous voulez remplir cette information.
Avec cela, nous complétons cet exercice.
C' est un bon moment pour vous de faire un git-commit avec le message, la population de mangoustes.