1
00:00:03,710 --> 00:00:07,605
Maintenant que nous avons appris sur la population mongoose,

2
00:00:07,605 --> 00:00:14,040
et comment elle nous permet de remplir un document avec des informations provenant d'un autre document.

3
00:00:14,040 --> 00:00:20,605
Dans cet exercice, nous allons modifier le serveur express sur lequel nous avons travaillé jusqu'à présent.

4
00:00:20,605 --> 00:00:25,580
Dans le schéma plat que nous avons défini plus tôt, nous avons eu des commentaires.

5
00:00:25,580 --> 00:00:28,365
Pour les commentaires, nous avions le champ auteur

6
00:00:28,365 --> 00:00:31,490
que nous utilisons pour stocker les détails sur l'auteur.

7
00:00:31,490 --> 00:00:40,815
Dans cet exercice, nous transformerons le champ auteur en référence à un document utilisateur,

8
00:00:40,815 --> 00:00:46,265
et nous utiliserons la population mongoose pour remplir les informations dans

9
00:00:46,265 --> 00:00:50,330
le document plats au besoin

10
00:00:50,330 --> 00:00:54,440
afin de fournir les informations au client.

11
00:00:54,440 --> 00:00:59,960
Maintenant, l'utilisation de la population peuplée et mongoose doit être faite

12
00:00:59,960 --> 00:01:05,550
judicieusement afin de ne pas causer trop de frais généraux sur le côté serveur.

13
00:01:05,550 --> 00:01:06,890
Maintenant, dans cet exercice,

14
00:01:06,890 --> 00:01:09,395
nous allons l'utiliser simplement pour remplir l'information

15
00:01:09,395 --> 00:01:13,280
dans le champ auteur de nos commentaires.

16
00:01:13,280 --> 00:01:18,660
Alors, continuons avec l'exercice pour apprendre comment nous utilisons la population mongoose.

17
00:01:18,660 --> 00:01:21,455
Pour commencer cet exercice,

18
00:01:21,455 --> 00:01:25,315
allez dans le projet et ouvrez le fichier user.js.

19
00:01:25,315 --> 00:01:27,730
Ainsi, dans le fichier user.js,

20
00:01:27,730 --> 00:01:29,600
nous stockons le schéma utilisateur.

21
00:01:29,600 --> 00:01:35,515
Je vais modifier le schéma de l'utilisateur en ajoutant quelques champs supplémentaires là-dedans.

22
00:01:35,515 --> 00:01:38,220
L' un est le prénom,

23
00:01:38,220 --> 00:01:40,070
qui sera de

24
00:01:40,070 --> 00:01:48,115
la chaîne de type et

25
00:01:48,115 --> 00:01:52,025
la valeur par défaut serait une chaîne vide.

26
00:01:52,025 --> 00:01:56,555
Donc, le prénom comme le nom l'indique,

27
00:01:56,555 --> 00:02:03,630
stocke le prénom de l'utilisateur et ensuite nous aurons un autre champ appelé nom de famille,

28
00:02:03,630 --> 00:02:06,540
qui est également du même genre.

29
00:02:06,540 --> 00:02:13,540
Donc, je vais juste copier ces deux éléments d'information et puis le copier

30
00:02:13,540 --> 00:02:20,735
ici et maintenant notre document utilisateur contiendra,

31
00:02:20,735 --> 00:02:22,840
en plus du nom d'utilisateur et mot de passe, nom

32
00:02:22,840 --> 00:02:26,760
d'utilisateur et hush et sel que nous avons vu plus tôt,

33
00:02:26,760 --> 00:02:34,450
qui est automatiquement ajouté par le module local de Mongoose .

34
00:02:34,450 --> 00:02:39,840
Nous aurons également le prénom et le nom de famille de l'utilisateur défini ici.

35
00:02:39,840 --> 00:02:43,505
Plus tard, nous verrons comment nous allons initialiser

36
00:02:43,505 --> 00:02:50,765
ces valeurs en modifiant le processus d'inscription de l'utilisateur.

37
00:02:50,765 --> 00:02:52,950
Maintenant, une fois que nous avons terminé cela, de

38
00:02:52,950 --> 00:02:56,599
cette façon, les informations de l'utilisateur

39
00:02:56,599 --> 00:03:00,880
peuvent simplement être récupérées en cherchant le document utilisateur ici.

40
00:03:00,880 --> 00:03:05,200
Donc, maintenant que nous avons les informations sur l'utilisateur dans le document utilisateur,

41
00:03:05,200 --> 00:03:08,560
aller dans le schéma plat,

42
00:03:08,560 --> 00:03:11,015
donc aller dans le fichier dishes.js.

43
00:03:11,015 --> 00:03:13,260
Dans le schéma plat plus tôt,

44
00:03:13,260 --> 00:03:18,465
nous stockions l'auteur du document sous la forme d'une chaîne ici.

45
00:03:18,465 --> 00:03:22,700
Maintenant, nous allons profiter du fait que nous

46
00:03:22,700 --> 00:03:27,425
avons le soutien de la population de mangoustes.

47
00:03:27,425 --> 00:03:33,740
Donc, je vais transformer le champ de commentaire d'une chaîne en type de

48
00:03:33,740 --> 00:03:41,975
schéma mongoose ID d'objet.

49
00:03:41,975 --> 00:03:49,120
Donc, de cette façon, désolé, mauvais champ.

50
00:03:49,120 --> 00:03:53,135
Je voulais transformer le champ auteur en

51
00:03:53,135 --> 00:04:02,295
type de schéma mongoose ID d'objet.

52
00:04:02,295 --> 00:04:05,390
Ainsi, le champ auteur maintenant au lieu de stocker une chaîne,

53
00:04:05,390 --> 00:04:10,835
aura une référence au document utilisateur.

54
00:04:10,835 --> 00:04:14,105
Donc, lorsque je transforme le champ auteur dans ce type,

55
00:04:14,105 --> 00:04:20,180
alors la deuxième propriété que j'ai définie ici sera une référence,

56
00:04:20,180 --> 00:04:25,229
qui serait une référence au modèle utilisateur.

57
00:04:25,229 --> 00:04:27,980
Donc, de cette façon, nous allons maintenant

58
00:04:27,980 --> 00:04:31,370
connecter ce champ auteur et ce champ auteur va

59
00:04:31,370 --> 00:04:37,585
simplement stocker une référence à l'ID du document utilisateur,

60
00:04:37,585 --> 00:04:43,790
au lieu de stocker les détails sur l'auteur sous la forme d'un nom.

61
00:04:43,790 --> 00:04:45,100
Maintenant, quand nous faisons cela,

62
00:04:45,100 --> 00:04:48,350
nous pouvons utiliser mongoose populate pour remplir

63
00:04:48,350 --> 00:04:53,115
cette information dans notre document de plats chaque fois que nécessaire.

64
00:04:53,115 --> 00:04:58,595
Donc, avec cette modification du schéma des plats, dans le fichier dishes.js,

65
00:04:58,595 --> 00:05:05,910
nous allons maintenant mettre à jour le routeur plat pour utiliser la population de mangoustes.

66
00:05:05,910 --> 00:05:09,030
Donc, aller à dishRouter.js.

67
00:05:09,030 --> 00:05:16,120
Dans routeur à plat, rappelez-vous que lorsque nous recevons un plat ici,

68
00:05:16,120 --> 00:05:19,470
maintenant quand vous obtenez le plat ici,

69
00:05:19,470 --> 00:05:23,820
nous disons plats trouver alors.

70
00:05:23,820 --> 00:05:26,610
Donc, à ce moment-là,

71
00:05:26,610 --> 00:05:36,005
nous allons dire que les plats trouvent et nous dirons après cela, peupler.

72
00:05:36,005 --> 00:05:41,924
Donc, nous utilisons le soutien de la population en mongoose

73
00:05:41,924 --> 00:05:48,165
et nous dirons peupler commentaires auteur.

74
00:05:48,165 --> 00:05:49,740
Donc, en déclarant ceci,

75
00:05:49,740 --> 00:05:51,060
nous disons que lorsque

76
00:05:51,060 --> 00:05:58,750
le document plats a été construit pour renvoyer la réponse à l'utilisateur,

77
00:05:58,750 --> 00:06:05,810
nous allons remplir le champ auteur à l'intérieur à partir du document utilisateur.

78
00:06:05,810 --> 00:06:09,095
Ainsi, cet appel au peuplate garantira que

79
00:06:09,095 --> 00:06:14,665
l'autre champ sera rempli avec les informations requises.

80
00:06:14,665 --> 00:06:18,565
De même, aller à l'ID du plat ici,

81
00:06:18,565 --> 00:06:21,660
même dans l'ID du plat, même chose.

82
00:06:21,660 --> 00:06:31,680
Nous dirons peupler et commentaires auteur ajouté

83
00:06:31,680 --> 00:06:37,320
dans les plats find by id dans

84
00:06:37,320 --> 00:06:43,395
le get du point de terminaison /dish ID.

85
00:06:43,395 --> 00:06:54,350
De même, dans les commentaires aussi quand nous récupérons le plat,

86
00:06:54,520 --> 00:07:02,370
nous dirons remplir les commentaires auteur ici et la

87
00:07:02,370 --> 00:07:09,900
même chose aussi dans le routeur de plat, les

88
00:07:09,900 --> 00:07:13,695
commentaires d'ID de plat, ID de commentaire aussi.

89
00:07:13,695 --> 00:07:16,530
Le plus grand peuplement de cette information là-bas.

90
00:07:16,530 --> 00:07:22,620
Bien sûr, ce que cela signifie, c'est que lorsque vous publiez le plat,

91
00:07:22,620 --> 00:07:30,090
plus tôt, vous incluez les informations de l'auteur dans le corps du message.

92
00:07:30,090 --> 00:07:35,120
Donc, maintenant ici quand nous essayons de pousser le commentaire dans cela,

93
00:07:35,120 --> 00:07:41,370
donc ce post correspond au champ de commentaires d'ID plat.

94
00:07:41,370 --> 00:07:46,280
Donc, c'est comme ça que nous publiions un commentaire sur un plat spécifique.

95
00:07:46,280 --> 00:07:48,570
Donc, maintenant dans ce post,

96
00:07:48,570 --> 00:07:53,890
puisque nous ne stockons plus les informations sur l'auteur,

97
00:07:53,890 --> 00:08:02,400
donc ce que nous devons faire est quand nous poussons l'élément dans le champ auteur là-bas.

98
00:08:02,400 --> 00:08:06,720
Donc, ici, lorsque vous remplissez les informations dans le plat,

99
00:08:06,720 --> 00:08:10,680
nous devrons premier-

100
00:08:12,010 --> 00:08:16,430
Rappelons que le corps contient déjà le commentaire,

101
00:08:16,430 --> 00:08:21,505
mais la propriété de l'auteur ne sera pas là dans le corps du message dans le livre,

102
00:08:21,505 --> 00:08:26,020
mais en fonction de l'utilisateur qui affiche cette information,

103
00:08:26,020 --> 00:08:29,250
nous pouvons remplissez immédiatement le champ auteur.

104
00:08:29,250 --> 00:08:32,535
Maintenant, comment pouvons-nous savoir quel utilisateur publie cette information ?

105
00:08:32,535 --> 00:08:38,165
Le fait que nous ayons fait la vérification de l'utilisateur ici pour le post,

106
00:08:38,165 --> 00:08:42,115
signifie qu'un utilisateur spécifique publie cette information,

107
00:08:42,115 --> 00:08:44,250
et en faisant l'utilisateur de vérification,

108
00:08:44,250 --> 00:08:50,415
nous aurions déjà chargé dans le req.user dans l'objet requête.

109
00:08:50,415 --> 00:08:51,925
Dans l'objet de requête,

110
00:08:51,925 --> 00:08:55,565
nous pouvons entrer et dire l'utilisateur de l'épave,

111
00:08:55,565 --> 00:08:59,010
puis souligner l'ID ici.

112
00:08:59,010 --> 00:09:01,910
Permettez-moi donc encore une fois de répéter ce point,

113
00:09:01,910 --> 00:09:05,760
comment obtenons-nous les informations de l'auteur ici ?

114
00:09:05,760 --> 00:09:10,470
Maintenant, rappelez-vous que nous avons mis à jour le schéma des plats, de

115
00:09:10,470 --> 00:09:13,875
sorte que le champ auteur dans le commentaire stockera simplement

116
00:09:13,875 --> 00:09:20,915
l'ID de l'objet faisant référence à l'utilisateur qui publie ce commentaire.

117
00:09:20,915 --> 00:09:24,450
Maintenant, comment pouvons-nous savoir quel utilisateur publie ce commentaire ?

118
00:09:24,450 --> 00:09:27,085
Maintenant encore, pour réitérer ce point,

119
00:09:27,085 --> 00:09:31,825
rappelez-vous que lorsque nous avons vérifié l'utilisateur ici en appelant authentifier l'utilisateur,

120
00:09:31,825 --> 00:09:37,590
le passeport autorisé JWT aurait chargé les

121
00:09:37,590 --> 00:09:45,120
informations de l'utilisateur dans le corps de la demande sous la forme de req.user.

122
00:09:45,120 --> 00:09:48,470
Ainsi, cet utilisateur contiendra l'ID de

123
00:09:48,470 --> 00:09:52,520
l'utilisateur spécifique qui publie ce commentaire.

124
00:09:52,520 --> 00:09:55,730
Donc, nous avons déjà vérifié l'authenticité de l'utilisateur,

125
00:09:55,730 --> 00:10:01,400
et donc l'ID utilisateur peut simplement être obtenu en disant req.user.

126
00:10:01,400 --> 00:10:04,400
_ID, et l'ID de

127
00:10:04,400 --> 00:10:09,380
cet utilisateur, je vais l'affecter au champ auteur du commentaire.

128
00:10:09,380 --> 00:10:10,990
Maintenant, lorsque le commentaire est entré,

129
00:10:10,990 --> 00:10:13,880
le commentaire dans le corps du message de demande

130
00:10:13,880 --> 00:10:17,355
ne contiendra que le champ d'évaluation et le champ de commentaire.

131
00:10:17,355 --> 00:10:23,425
Maintenant, nous ne voulons plus envoyer explicitement le champ auteur du côté client,

132
00:10:23,425 --> 00:10:26,090
au lieu de cela devrait être automatiquement

133
00:10:26,090 --> 00:10:28,990
inséré du côté serveur en fonction de l'authenticité de

134
00:10:28,990 --> 00:10:32,180
l'utilisateur C'est le point que j'avais

135
00:10:32,180 --> 00:10:36,830
répété dans cette modification que j'ai faite ici.

136
00:10:36,830 --> 00:10:43,400
Ainsi, que les informations des utilisateurs sont automatiquement obtenues à partir du req.user qui est

137
00:10:43,400 --> 00:10:50,200
chargé dans le corps du message de demande par l'utilisateur authentifier vérification,

138
00:10:50,200 --> 00:10:55,250
qui va utiliser Passport authentifier avec la stratégie JWT là.

139
00:10:55,250 --> 00:10:59,795
En outre, maintenant, lorsque nous recevons le plat mis à jour ici,

140
00:10:59,795 --> 00:11:03,695
nous devons remplir les informations de l'auteur dans le plat.

141
00:11:03,695 --> 00:11:05,500
Donc, à ce stade,

142
00:11:05,500 --> 00:11:08,675
quand nous recevons le plat ici,

143
00:11:08,675 --> 00:11:15,370
nous allons alors chercher les plats ici.

144
00:11:15,370 --> 00:11:20,150
Donc, nous allons dire plats.findById,

145
00:11:21,000 --> 00:11:28,090
puis fournir l'ID plat comme paramètre ici,

146
00:11:28,090 --> 00:11:30,190
donc nous allons dire trouver par ID,

147
00:11:30,190 --> 00:11:33,175
plat ID, et puis,

148
00:11:33,175 --> 00:11:43,405
nous devons remplir l'auteur des commentaires ici,

149
00:11:43,405 --> 00:11:55,600
et puis nous allons dire puis plat.

150
00:11:55,600 --> 00:12:04,370
À l'intérieur, nous allons renvoyer cette information à l'utilisateur ici.

151
00:12:04,370 --> 00:12:07,260
Laisse-moi couper ça et coller ça ici.

152
00:12:07,260 --> 00:12:12,670
Donc, cette modification est nécessaire car maintenant j'ai besoin de remplir

153
00:12:12,670 --> 00:12:15,190
les informations de l'auteur dans

154
00:12:15,190 --> 00:12:18,760
le commentaire avant de pouvoir renvoyer le courant à l'utilisateur.

155
00:12:18,760 --> 00:12:22,220
Donc, c'est la modification supplémentaire que nous devons

156
00:12:22,220 --> 00:12:26,105
faire lorsque nous utilisons la population mongoose ici.

157
00:12:26,105 --> 00:12:29,950
De même, maintenant dans le put,

158
00:12:29,950 --> 00:12:34,450
lorsque nous modifions un commentaire spécifique avec l'ID de commentaire,

159
00:12:34,450 --> 00:12:40,830
donc c'est sous la partie ID de commentaire de l'ID de plat.

160
00:12:40,830 --> 00:12:42,890
Donc, quand nous faisons le mettre ici,

161
00:12:42,890 --> 00:12:49,230
donc nous trouvons d'abord les plats trouver par id req params ID plat,

162
00:12:49,230 --> 00:12:50,840
puis dans le plat.

163
00:12:50,840 --> 00:12:57,160
Donc, la première chose que nous vérifions est de nous assurer que si le plat n'est pas nul,

164
00:12:57,160 --> 00:13:01,430
et que l'ID des commentaires de plat n'est pas nul,

165
00:13:01,430 --> 00:13:08,665
donc nous avons vérifié pour nous assurer que le commentaire est effectivement présent dans le plat,

166
00:13:08,665 --> 00:13:12,320
puis quand le plat lui-même est retourné,

167
00:13:12,320 --> 00:13:16,385
alors nous devons chercher à nouveau

168
00:13:16,385 --> 00:13:21,230
le plat parce que nous devons remplir l'auteur des commentaires dans le plat.

169
00:13:21,230 --> 00:13:27,950
Donc, ici, nous allons dire dishes.findById (dish ID),

170
00:13:31,750 --> 00:13:36,880
la raison pour laquelle nous devons faire une recherche de plus est parce que

171
00:13:36,880 --> 00:13:42,240
nous devons remplir les commentaires.author ici,

172
00:13:42,240 --> 00:13:46,355
donc c'est la seule raison pour laquelle nous devons faire une recherche de plus ici.

173
00:13:46,355 --> 00:13:50,720
Ensuite, quand nous recevons le plat ici,

174
00:13:52,260 --> 00:13:57,700
évidemment parce que nous venons de mettre à jour le plat de sorte que les informations de plat devraient être

175
00:13:57,700 --> 00:14:03,640
trouvées dans la base de données, de

176
00:14:03,640 --> 00:14:07,490
sorte que cela devrait fonctionner correctement et puis à l'intérieur il y aura le

177
00:14:07,490 --> 00:14:12,215
code d'état de risque 200 res ensemble application de type de contenu d'en-tête json,

178
00:14:12,215 --> 00:14:14,960
puis retourner le plat ici,

179
00:14:14,960 --> 00:14:16,740
et puis nous allons gérer les erreurs ici,

180
00:14:16,740 --> 00:14:19,630
puis les autres si les plats

181
00:14:19,630 --> 00:14:24,095
maintenant et aussi les autres erreurs que nous avons mises en place plus tôt,

182
00:14:24,095 --> 00:14:27,050
ils seront traités comme d'habitude ici.

183
00:14:27,050 --> 00:14:32,790
Donc, ce sont les changements supplémentaires que nous devons nous assurer lorsque vous mettez à jour le plat,

184
00:14:32,790 --> 00:14:39,175
lorsque vous renvoyez le commentaire mis à jour ou le plat mis à jour,

185
00:14:39,175 --> 00:14:44,485
alors nous allons remplir le commentaire dans le plat ici.

186
00:14:44,485 --> 00:14:48,160
De même, aller à la suppression ici,

187
00:14:48,160 --> 00:14:50,575
puis après la suppression du commentaire,

188
00:14:50,575 --> 00:14:59,310
encore une fois nous allons chercher le plat et remplir les informations de l'auteur.

189
00:14:59,310 --> 00:15:01,275
Donc, laissez-moi juste copier cette partie,

190
00:15:01,275 --> 00:15:04,130
et puis nous allons faire exactement la même chose ici,

191
00:15:04,130 --> 00:15:06,770
donc nous allons dire plat sauver,

192
00:15:06,770 --> 00:15:16,210
alors nous allons être alors vérifier plat.FindById (auteur de plat),

193
00:15:16,210 --> 00:15:19,760
et puis nous allons remplir l'auteur des commentaires,

194
00:15:19,760 --> 00:15:21,925
puis nous allons dire (puis) plat,

195
00:15:21,925 --> 00:15:24,920
puis RES.StatusCode, et ainsi de suite,

196
00:15:24,920 --> 00:15:29,350
et la gestion des erreurs restantes comme ici.

197
00:15:29,350 --> 00:15:33,040
Donc, avec cette modification au routeur plat,

198
00:15:33,040 --> 00:15:41,420
maintenant le dernier point que nous devons considérer est le fait que dans le fichier user.js,

199
00:15:41,420 --> 00:15:43,740
nous avons maintenant ajouté dans les champs,

200
00:15:43,740 --> 00:15:49,050
le prénom et le champ de nom qui par défaut seront des chaînes vides.

201
00:15:49,050 --> 00:15:51,880
Ainsi, lorsque l'utilisateur s'inscrit,

202
00:15:51,880 --> 00:15:54,670
nous devrions permettre à l'utilisateur de fournir le prénom et le nom de

203
00:15:54,670 --> 00:15:58,040
famille dans le processus d'enregistrement.

204
00:15:58,040 --> 00:16:00,040
Maintenant, où est-ce que ça a lieu ?

205
00:16:00,040 --> 00:16:03,025
Cela a lieu dans le s.js de l'utilisateur.

206
00:16:03,025 --> 00:16:05,390
Donc, en allant aux utilisateurs users.js,

207
00:16:05,390 --> 00:16:09,885
lorsque l'utilisateur publie sur l'inscription slash,

208
00:16:09,885 --> 00:16:13,050
plus tôt, nous ne publions que le nom d'utilisateur et le mot de passe.

209
00:16:13,050 --> 00:16:15,105
En plus de ces deux,

210
00:16:15,105 --> 00:16:21,785
dans l'objet json que nous incluons dans le corps du message de requête entrant,

211
00:16:21,785 --> 00:16:25,530
le message de demande de poste venant du côté client,

212
00:16:25,530 --> 00:16:29,590
nous pouvons également inclure le prénom et le nom de famille de l'utilisateur.

213
00:16:29,590 --> 00:16:33,740
Donc, quand le prénom et le nom de l'utilisateur sont inclus,

214
00:16:33,740 --> 00:16:35,590
alors que vais-je faire ici ?

215
00:16:35,590 --> 00:16:42,450
Donc, rappelez-vous que lorsque vous dites user.register à ce stade, les informations de l'utilisateur entrent,

216
00:16:42,450 --> 00:16:45,785
puis vous avez soumis le nom d'utilisateur ici,

217
00:16:45,785 --> 00:16:49,460
et vous avez également attribué le mot de passe ici qui sera

218
00:16:49,460 --> 00:16:53,380
transformé en hachage et sel par le passeport mongoose local.

219
00:16:53,380 --> 00:17:00,000
Maintenant, s'il n'y a pas d'erreur qui signifie que l'enregistrement de l'utilisateur a réussi,

220
00:17:00,000 --> 00:17:08,740
et donc à ce stade ce que nous allons faire est nous dirons si req.body.

221
00:17:08,740 --> 00:17:13,420
Prénom. Donc, ce qui signifie que le corps du message de demande entrante,

222
00:17:13,420 --> 00:17:16,345
s'il contient le prénom,

223
00:17:16,345 --> 00:17:24,770
alors nous dirons user.firstname est égal à req.body.firstname.

224
00:17:26,160 --> 00:17:29,675
De même, pour le nom de famille aussi.

225
00:17:29,675 --> 00:17:32,040
Donc, à ce stade,

226
00:17:32,040 --> 00:17:34,780
nous aurions l'utilisateur disponible ici.

227
00:17:34,780 --> 00:17:40,125
Voir l'utilisateur arrive en tant que deuxième paramètre de cette fonction de rappel ici.

228
00:17:40,125 --> 00:17:43,455
Donc, nous configurons le prénom en changeant

229
00:17:43,455 --> 00:17:51,490
la propriété prénom à l'intérieur du document utilisateur en disant ici, req.body.firstname.

230
00:17:51,490 --> 00:17:55,395
S' il existe, nous allons définir le prénom de l'utilisateur sur cela.

231
00:17:55,395 --> 00:18:03,220
De même, si le nom req.body.last est disponible,

232
00:18:03,220 --> 00:18:09,630
nous allons également mettre à jour le nom de famille de l'utilisateur en tant que req.body.lastname.

233
00:18:09,770 --> 00:18:16,650
Et une fois que nous avons fait ces deux changements au prénom et au nom de famille,

234
00:18:16,650 --> 00:18:23,160
alors nous devons enregistrer la modification que nous avons faite à l'utilisateur.

235
00:18:23,160 --> 00:18:25,030
Donc, nous venons de mettre à jour l'utilisateur.

236
00:18:25,030 --> 00:18:30,550
Donc, nous allons dire user.save alors cela

237
00:18:30,550 --> 00:18:37,190
retournera l'erreur ou l'utilisateur.

238
00:18:37,190 --> 00:18:41,025
Donc, si la modification a été enregistrée correctement,

239
00:18:41,025 --> 00:18:43,765
alors il retournera l'erreur,

240
00:18:43,765 --> 00:18:49,380
sinon il retournera la valeur de l'utilisateur et ce passeport authentifier nous le

241
00:18:49,380 --> 00:18:55,710
ferons à l'intérieur de cet utilisateur ici.

242
00:18:55,710 --> 00:19:00,505
Donc, nous allons dire, user.save (err, utilisateur).

243
00:19:00,505 --> 00:19:04,740
Et puis nous devons aussi vérifier que

244
00:19:04,740 --> 00:19:10,660
s'il y a une erreur dans l'enregistrement des changements à l'utilisateur,

245
00:19:10,660 --> 00:19:15,180
alors nous dirons le code d'état de res 500,

246
00:19:15,180 --> 00:19:18,485
alors laissez-moi copier ceci à partir de là.

247
00:19:18,485 --> 00:19:23,275
Donc, nous dirons le code d'état res 500,

248
00:19:23,275 --> 00:19:30,220
res jeu de type d'en-tête application json et res.jason ici.

249
00:19:30,220 --> 00:19:35,995
Ensuite, et nous reviendrons à ce point.

250
00:19:35,995 --> 00:19:37,960
S' il n'y a pas d'erreur,

251
00:19:37,960 --> 00:19:40,480
alors bien sûr, vous authentifiez l'utilisateur en appelant

252
00:19:40,480 --> 00:19:43,550
passeport authentifier auprès du local pour vous assurer que

253
00:19:43,550 --> 00:19:48,835
l'enregistrement de l'utilisateur a été réussi et cela devrait être

254
00:19:48,835 --> 00:19:56,390
fait correctement et quand dans ce cas, vous retournerez ce message côté client.

255
00:19:56,390 --> 00:20:03,215
Nous devons fermer cet utilisateur.save ici.

256
00:20:03,215 --> 00:20:07,520
Donc, assurez-vous que vous fermez ce point de terminaison correctement.

257
00:20:07,520 --> 00:20:11,005
Donc, user.save est fermé ici, et c'est tout.

258
00:20:11,005 --> 00:20:14,730
Ce sont les changements que nous devons apporter à l'utilisateur.

259
00:20:14,730 --> 00:20:21,740
Ainsi, après que l'utilisateur est enregistré avec le nom d'utilisateur donné et le mot de passe donné,

260
00:20:21,740 --> 00:20:24,940
puis après que l'utilisateur est enregistré avec succès,

261
00:20:24,940 --> 00:20:28,235
nous allons définir le prénom et

262
00:20:28,235 --> 00:20:32,925
le champ de nom du document utilisateur en utilisant ces deux ici.

263
00:20:32,925 --> 00:20:35,900
Nous voulons nous assurer que l'utilisateur est

264
00:20:35,900 --> 00:20:39,160
enregistré avec succès avant d'envoyer le prénom et le nom de famille pour cela.

265
00:20:39,160 --> 00:20:42,540
Donc, c'est pourquoi nous effectuons cette opération après que l'utilisateur

266
00:20:42,540 --> 00:20:46,360
est enregistré avec succès. C'est ça.

267
00:20:46,360 --> 00:20:53,785
Sauvegardons les modifications et allons vérifier le serveur.

268
00:20:53,785 --> 00:20:56,185
Après avoir enregistré les changements,

269
00:20:56,185 --> 00:20:59,980
allons maintenant au terminal et

270
00:20:59,980 --> 00:21:06,925
puis avant de démarrer le serveur,

271
00:21:06,925 --> 00:21:16,690
laissez-moi d'abord vérifier mon MongoDB et supprimer l'utilisateur que nous avons enregistré plus tôt.

272
00:21:16,690 --> 00:21:25,640
Donc, nous allons dire utiliser la confusion et ensuite nous dirons db.usersfind.

273
00:21:25,650 --> 00:21:30,690
Donc, nous savons que cet utilisateur particulier a été enregistré plus tôt,

274
00:21:30,690 --> 00:21:32,580
mais lorsque nous enregistrons cet utilisateur,

275
00:21:32,580 --> 00:21:35,700
nous n'avons pas enregistré le prénom et le nom de famille de l'utilisateur.

276
00:21:35,700 --> 00:21:39,155
Donc, je vais supprimer cet utilisateur, puis ré-enregistrer l'utilisateur.

277
00:21:39,155 --> 00:21:48,370
Donc, pour ce faire en utilisant l'ondulation Mongo, je dirai que les utilisateurs de db abandonnent,

278
00:21:48,370 --> 00:21:52,220
et ensuite nous dirons que les utilisateurs de db trouvent,

279
00:21:52,220 --> 00:21:54,620
et cela devrait retourner un vide.

280
00:21:54,620 --> 00:22:01,685
Aucun utilisateur enregistré là-bas, puis nous quitterons l'ondulation Mongo.

281
00:22:01,685 --> 00:22:05,285
Et donc, une fois que nous avons supprimé cet utilisateur enregistré,

282
00:22:05,285 --> 00:22:08,760
alors, laissez-moi démarrer mon serveur.

283
00:22:09,490 --> 00:22:12,275
Et une fois que le serveur est opérationnel,

284
00:22:12,275 --> 00:22:16,240
allons dans Postman et puis inscrivons

285
00:22:16,240 --> 00:22:20,930
un nouvel utilisateur avec le prénom et le nom de famille de l'utilisateur.

286
00:22:20,930 --> 00:22:26,845
Ensuite, ils se connecteront en tant qu'utilisateur, puis nous verrons comment

287
00:22:26,845 --> 00:22:31,650
la population mongoose nous aide à remplir

288
00:22:31,650 --> 00:22:37,000
automatiquement les informations sur l'utilisateur dans le document là-bas.

289
00:22:37,000 --> 00:22:40,029
Maintenant, allez à Postman,

290
00:22:40,029 --> 00:22:42,660
laissez-moi faire une inscription d'un nouvel utilisateur.

291
00:22:42,660 --> 00:22:48,310
Donc, je fais un post localhost : 3000 utilisateurs s'inscrivent.

292
00:22:48,310 --> 00:22:50,715
Dans le corps du message,

293
00:22:50,715 --> 00:22:54,910
nous avions déjà le nom d'utilisateur et le mot de passe.

294
00:22:54,910 --> 00:22:59,199
Permettez-moi d'ajouter deux champs supplémentaires :

295
00:22:59,199 --> 00:23:09,350
prénom, nom de famille.

296
00:23:14,880 --> 00:23:18,530
Ensuite, enregistrez cet utilisateur.

297
00:23:20,850 --> 00:23:23,680
Donc, une fois que j'ai enregistré l'utilisateur,

298
00:23:23,680 --> 00:23:26,350
vous pouvez voir que l'enregistrement a réussi.

299
00:23:26,350 --> 00:23:29,810
Maintenant, laissez-moi me connecter en tant qu'utilisateur.

300
00:23:29,820 --> 00:23:32,640
Donc, pour me connecter en tant qu'utilisateur,

301
00:23:32,640 --> 00:23:37,620
laissez-moi faire un post et vérifier pour m'assurer.

302
00:23:37,620 --> 00:23:40,475
Donc, je fais un post pour les utilisateurs se connecter.

303
00:23:40,475 --> 00:23:45,725
Laissez-moi vérifier et je vois que le nom d'utilisateur et le mot de passe sont correctement tapés là.

304
00:23:45,725 --> 00:23:47,775
Donc, quand je me

305
00:23:47,775 --> 00:23:53,165
connecte, je devrais être connecté avec succès et je devrais être en mesure d'obtenir ce jeton là.

306
00:23:53,165 --> 00:24:02,660
Parce que ce jeton est essentiel pour que nous puissions ajouter dans un plat à notre site serveur.

307
00:24:02,660 --> 00:24:05,915
Donc, après avoir obtenu le jeton,

308
00:24:05,915 --> 00:24:10,250
copiez cette chaîne de jeton et enregistrez-la car vous en aurez besoin dans

309
00:24:10,250 --> 00:24:13,220
l'en-tête d'autorisation pour les

310
00:24:13,220 --> 00:24:16,910
opérations de post put and delete que vous allez effectuer plus tard.

311
00:24:16,910 --> 00:24:20,540
Laisse-moi copier ce jeton.

312
00:24:20,540 --> 00:24:23,890
Maintenant, normalement, la façon dont je garderais ces jetons est,

313
00:24:23,890 --> 00:24:28,400
que je vais juste ouvrir un document texte, puis le copier et le coller dans le document texte.

314
00:24:28,400 --> 00:24:31,190
Pour que pour les demandes ultérieures de facteur,

315
00:24:31,190 --> 00:24:34,230
je peux simplement copier cette chaîne, puis la coller dans

316
00:24:34,230 --> 00:24:37,770
l'en-tête d'autorisation, si nécessaire.

317
00:24:37,770 --> 00:24:44,070
Donc, laissez-moi copier ce jeton et ici j'ai un document texte ouvert ici.

318
00:24:44,070 --> 00:24:50,815
Donc, je vais coller cette chaîne dans ce document texte.

319
00:24:50,815 --> 00:24:57,170
Donc, nous avons ici le jeton que nous avons obtenu.

320
00:24:57,170 --> 00:25:03,120
Allons maintenant poster un plat sur notre serveur.

321
00:25:03,120 --> 00:25:05,135
Retourner au facteur,

322
00:25:05,135 --> 00:25:07,535
laisse-moi poster un plat au serveur.

323
00:25:07,535 --> 00:25:12,690
Donc, c'est là que je vais choisir le poste ici.

324
00:25:12,690 --> 00:25:21,334
À l'intérieur ici, j'ai les informations de plat que j'avais utilisées plus tôt mais pour les commentaires,

325
00:25:21,334 --> 00:25:25,345
maintenant, rappelez-vous que plus tôt nous avions un champ d'auteur qui stockait une chaîne.

326
00:25:25,345 --> 00:25:28,770
Donc, tous ces commentaires ne sont pas valides.

327
00:25:28,770 --> 00:25:35,110
Donc, je vais supprimer tous ces commentaires de la soumission parce que,

328
00:25:35,110 --> 00:25:42,570
maintenant, nous nous attendons à ce que l'utilisateur publie des commentaires par lui-même.

329
00:25:42,570 --> 00:25:44,460
Lorsque l'utilisateur publie des commentaires,

330
00:25:44,460 --> 00:25:52,155
nous ajouterons automatiquement l'ID de l'utilisateur dans le champ auteur des commentaires.

331
00:25:52,155 --> 00:25:55,390
Alors, laissez-moi poster ce plat ici.

332
00:25:55,390 --> 00:25:57,325
Aller à l'en-tête,

333
00:25:57,325 --> 00:26:01,550
dans l'en-tête d'autorisation, je vais dire,

334
00:26:02,310 --> 00:26:12,785
porteur, puis, coller le jeton, puis soumettre.

335
00:26:12,785 --> 00:26:17,055
Je devrais faire un post là-dessus.

336
00:26:17,055 --> 00:26:21,950
Donc, je dirai post et donc quand je post maintenant,

337
00:26:21,950 --> 00:26:26,785
vous voyez que ce plat a été posté du côté serveur,

338
00:26:26,785 --> 00:26:31,340
et avec le tableau de commentaires étant vide en ce moment.

339
00:26:31,340 --> 00:26:34,450
Donc, après avoir posté ce plat,

340
00:26:34,450 --> 00:26:37,660
laissez-moi copier l'ID de ce plat.

341
00:26:37,660 --> 00:26:40,835
Donc, laissez-moi copier cet ID pour le plat parce que j'en aurai

342
00:26:40,835 --> 00:26:44,735
besoin pour poster des commentaires pour ce plat.

343
00:26:44,735 --> 00:26:47,075
Ensuite, en allant à mon éditeur de texte,

344
00:26:47,075 --> 00:26:51,485
je vais enregistrer l'ID du plat ici.

345
00:26:51,485 --> 00:26:54,550
Maintenant, bien sûr, une fois que vous aurez construit votre côté

346
00:26:54,550 --> 00:26:57,770
client, votre client aura automatiquement toutes ces informations.

347
00:26:57,770 --> 00:27:02,565
Ainsi, votre client sera automatiquement en mesure d'envoyer le jeton et ainsi de suite.

348
00:27:02,565 --> 00:27:06,385
Donc, vous n'avez pas besoin de faire cette chose de coupe-coller, mais avec

349
00:27:06,385 --> 00:27:11,750
le facteur, c'est la seule façon d'ajouter des informations à nos demandes de facteur,

350
00:27:11,750 --> 00:27:17,185
qui vont du facteur au serveur.

351
00:27:17,185 --> 00:27:22,090
Maintenant, afin de nous convaincre que ce plat existe réellement,

352
00:27:22,090 --> 00:27:26,310
laissez-moi faire un get sur l'hôtcolon:3000/plats.

353
00:27:26,570 --> 00:27:30,750
Quand je fais un get, vous pouvez effectivement voir que

354
00:27:30,750 --> 00:27:34,175
ce plat particulier existe sur le côté serveur.

355
00:27:34,175 --> 00:27:37,600
Alors, essayons maintenant de poster un commentaire.

356
00:27:37,600 --> 00:27:39,515
Donc, pour poster un commentaire,

357
00:27:39,515 --> 00:27:45,550
faisons un post et nous allons dire,

358
00:27:49,940 --> 00:27:54,950
localhost : 3000/plats, barre oblique et l'ID du plat que

359
00:27:54,950 --> 00:27:59,910
je viens de copier, et des commentaires barre oblique.

360
00:27:59,910 --> 00:28:03,090
Lorsque vous publiez sur les commentaires,

361
00:28:03,090 --> 00:28:11,285
vous devez vous assurer que dans le corps, nous allons ajouter dans le commentaire ici.

362
00:28:11,285 --> 00:28:13,605
Donc, un commentaire typique contient

363
00:28:13,605 --> 00:28:20,555
une note de disons

364
00:28:20,555 --> 00:28:26,140
cinq, puis commenter.

365
00:28:29,030 --> 00:28:33,535
Donc, laissez-moi juste taper un commentaire aléatoire,

366
00:28:33,535 --> 00:28:34,915
juste pour vous démontrer.

367
00:28:34,915 --> 00:28:41,085
Donc, cela devrait être dans le corps du post pour les commentaires et dans l'en-tête,

368
00:28:41,085 --> 00:28:44,665
nous devrions ajouter l'en-tête d'autorisation.

369
00:28:44,665 --> 00:28:50,525
Donc, pour l'en-tête d'autorisation, nous dirons, porteur.

370
00:28:50,525 --> 00:28:54,875
J' ai besoin de coller le jeton ici, en

371
00:28:54,875 --> 00:28:59,065
collant la valeur du jeton que j'ai enregistrée plus tôt.

372
00:28:59,065 --> 00:29:02,575
Nous allons maintenant poster ce commentaire.

373
00:29:02,575 --> 00:29:05,265
Ensuite, lorsque le commentaire est posté,

374
00:29:05,265 --> 00:29:07,705
regardons la valeur renvoyée ici.

375
00:29:07,705 --> 00:29:09,510
Ainsi, lorsque vous naviguez vers le bas,

376
00:29:09,510 --> 00:29:14,975
vous pouvez voir que le plat auquel le commentaire a été ajouté, a été retourné.

377
00:29:14,975 --> 00:29:19,300
Notez que l'information du plat est là, mais notez en particulier,

378
00:29:19,300 --> 00:29:22,620
ce qui est contenu dans le commentaire qui a été posté ici.

379
00:29:22,620 --> 00:29:25,740
Ainsi, comme vous pouvez le voir, vous savez déjà que les

380
00:29:25,740 --> 00:29:29,050
champs mis à jour et créés sont automatiquement ajoutés par mongoose.

381
00:29:29,050 --> 00:29:31,900
La note et le commentaire que nous avons soumis sont

382
00:29:31,900 --> 00:29:34,780
juste là, mais notez comment le champ auteur

383
00:29:34,780 --> 00:29:40,675
contient maintenant l'ID correspondant à l'utilisateur.

384
00:29:40,675 --> 00:29:47,190
Maintenant, comme nous l'avons vu dans le code comment les informations de champ auteur sont ajoutées, maintenant,

385
00:29:47,190 --> 00:29:49,965
si vous faites un get sur la vaisselle,

386
00:29:49,965 --> 00:29:52,900
vous remarquerez que ce champ auteur sera

387
00:29:52,900 --> 00:29:56,890
automatiquement rempli par les informations des utilisateurs ici.

388
00:29:56,890 --> 00:30:02,180
Donc, faisons maintenant un get sur le localhost : 3000/plats.

389
00:30:02,300 --> 00:30:06,820
Donc, quand nous faisons maintenant un get sur ce point,

390
00:30:06,820 --> 00:30:12,215
vous remarquerez maintenant que dans les plats ici,

391
00:30:12,215 --> 00:30:15,460
juste là, les informations sur le plat est déjà

392
00:30:15,460 --> 00:30:20,110
présent, mais notez comment le commentaire est maintenant construit.

393
00:30:20,110 --> 00:30:23,500
Le commentaire contient maintenant,

394
00:30:23,500 --> 00:30:27,240
les champs de commentaire de notation comme nous l'avons vu précédemment,

395
00:30:27,240 --> 00:30:28,780
le mis à jour et créé à,

396
00:30:28,780 --> 00:30:32,910
mais notez ce qui est arrivé au champ auteur ici.

397
00:30:32,910 --> 00:30:36,890
Donc, lorsque vous faites une requête get parce que nous avons fait un remplissage

398
00:30:36,890 --> 00:30:42,230
côté serveur lorsque l'opération get est appelée,

399
00:30:42,230 --> 00:30:45,750
le remplissage a automatiquement rempli les

400
00:30:45,750 --> 00:30:51,390
informations de l'auteur en position dans le champ auteur ici.

401
00:30:51,390 --> 00:30:54,215
Ainsi, là, vous pouvez voir que de l'auteur,

402
00:30:54,215 --> 00:30:56,260
vous pouvez maintenant rechercher le nom de famille et

403
00:30:56,260 --> 00:30:58,970
les informations de prénom automatiquement à partir du champ auteur.

404
00:30:58,970 --> 00:31:01,645
Donc, si vous avez besoin de construire un commentaire,

405
00:31:01,645 --> 00:31:04,050
vous avez maintenant la note,

406
00:31:04,050 --> 00:31:08,210
le commentaire, ainsi que le prénom et le nom de famille de

407
00:31:08,210 --> 00:31:12,485
l'auteur automatiquement inclus dans ce document.

408
00:31:12,485 --> 00:31:15,645
En outre, le nom d'utilisateur est également inclus dans ce document.

409
00:31:15,645 --> 00:31:21,495
Ainsi, vous pouvez ajouter des informations à partir d'un autre document et remplir

410
00:31:21,495 --> 00:31:27,905
un second document avec ces informations avant de répondre à partir du site du serveur.

411
00:31:27,905 --> 00:31:32,315
Donc, c'est l'utilisation de la population de mangoustes et comment nous

412
00:31:32,315 --> 00:31:37,580
pouvons automatiquement remplir des informations dans un document de mangouste.

413
00:31:37,580 --> 00:31:41,280
Avec cela, nous complétons cet exercice.

414
00:31:41,280 --> 00:31:46,075
Dans cet exercice, nous avons vu l'utilisation de la population de mangoustes et nous avons également vu

415
00:31:46,075 --> 00:31:51,785
comment nous pouvons alimenter les informations d'un document dans un autre document.

416
00:31:51,785 --> 00:31:57,340
Par conséquent, lorsque nous modifions le serveur pour faire la population pour les demandes,

417
00:31:57,340 --> 00:32:02,200
mongoose prendra automatiquement soin de remplir cette information pour nous.

418
00:32:02,200 --> 00:32:04,190
Tout ce que nous avons à faire,

419
00:32:04,190 --> 00:32:10,900
est de stocker la référence à l'autre document sous la forme de l'ID d'objet,

420
00:32:10,900 --> 00:32:16,240
dans le document dans lequel vous voulez remplir cette information.

421
00:32:16,240 --> 00:32:18,965
Avec cela, nous complétons cet exercice.

422
00:32:18,965 --> 00:32:25,230
C' est un bon moment pour vous de faire un git-commit avec le message, la population de mangoustes.