1
00:00:03,920 --> 00:00:09,645
Comme nous l'avons compris lors de la conférence précédente dans cette leçon,

2
00:00:09,645 --> 00:00:12,585
notre objectif dans cette leçon est d'

3
00:00:12,585 --> 00:00:16,590
intégrer le serveur API REST que nous avons déjà développé,

4
00:00:16,590 --> 00:00:20,525
ainsi que l'accès à la base de données MongoDB.

5
00:00:20,525 --> 00:00:24,060
Donc, nous allons commencer avec le serveur API REST

6
00:00:24,060 --> 00:00:27,480
que nous avons construit dans la toute première leçon de ce module,

7
00:00:27,480 --> 00:00:31,770
puis après avoir appris comment interagir de

8
00:00:31,770 --> 00:00:37,220
notre application de noeud vers le serveur MongoDB en utilisant Mongoose,

9
00:00:37,220 --> 00:00:43,865
nous allons développer notre serveur API REST plus loin pour intégrer

10
00:00:43,865 --> 00:00:50,749
l'ensemble entre la requête du client entrant dans le serveur,

11
00:00:50,749 --> 00:00:53,840
jusqu'à l'opération de base de données correspondante à effectuer,

12
00:00:53,840 --> 00:01:00,880
puis construire et renvoyer la réponse à ce client à partir de notre site serveur.

13
00:01:00,880 --> 00:01:04,125
Pour commencer bien sûr,

14
00:01:04,125 --> 00:01:08,300
allez d'abord dans le dossier du serveur de confusion que nous avons déjà créé dans

15
00:01:08,300 --> 00:01:15,215
le tout premier exercice de ce module dans la leçon de l'API REST,

16
00:01:15,215 --> 00:01:17,915
puis, dans le dossier de confusion,

17
00:01:17,915 --> 00:01:22,310
nous avons déjà construit le serveur API REST.

18
00:01:22,310 --> 00:01:26,630
Maintenant, ce que nous ferions est d'emprunter

19
00:01:26,630 --> 00:01:32,035
les modèles que nous avons développés dans l'exercice précédent,

20
00:01:32,035 --> 00:01:36,050
le fichier dishes.js que nous avons développé dans l'exercice précédent,

21
00:01:36,050 --> 00:01:41,220
copié sur le projet de serveur de confusion,

22
00:01:41,220 --> 00:01:44,430
et aussi installer Bluebird Mongoose,

23
00:01:44,430 --> 00:01:51,225
et un autre module appelé Mongoose monnaie, à notre projet.

24
00:01:51,225 --> 00:01:54,275
Donc, en allant à notre dossier JS nœud,

25
00:01:54,275 --> 00:01:57,050
nous allons d'abord dans le dossier Mongoose noeud,

26
00:01:57,050 --> 00:02:01,970
et nous voyons que dans le sous-dossier des modèles du dossier Mongoose noeud,

27
00:02:01,970 --> 00:02:03,810
nous avons le fichier dishes.js.

28
00:02:03,810 --> 00:02:07,354
Je vais juste copier le dossier models,

29
00:02:07,354 --> 00:02:10,490
puis passer au dossier du serveur de confusion,

30
00:02:10,490 --> 00:02:13,910
puis percer simplement le dossier models dedans.

31
00:02:13,910 --> 00:02:15,690
Donc, une fois que nous faisons cela,

32
00:02:15,690 --> 00:02:22,540
alors le fichier dishes.js qui contient le schéma et le modèle du document plats,

33
00:02:22,540 --> 00:02:28,155
sont intégrés dans notre serveur API REST.

34
00:02:28,155 --> 00:02:30,890
Bien sûr, pour en faire usage,

35
00:02:30,890 --> 00:02:34,400
nous devons installer le module de noeud Mongoose,

36
00:02:34,400 --> 00:02:40,990
et un nouveau module de noeud appelé monnaie Mongoose dans notre projet.

37
00:02:40,990 --> 00:02:47,510
Donc, aller au terminal dans le projet de serveur de confusion,

38
00:02:47,510 --> 00:02:52,640
assurez-vous que votre terminal ou la fenêtre de commande se trouve

39
00:02:52,640 --> 00:02:57,480
dans le projet de serveur de confusion où vous développez l'API REST plus tôt,

40
00:02:57,480 --> 00:03:01,070
et dans ce projet, installons.

41
00:03:01,070 --> 00:03:06,165
Donc, nous allons faire npm installer Mongoose,

42
00:03:06,165 --> 00:03:13,110
puis, un nouveau module de noeud appelé comme monnaie Mongoose.

43
00:03:13,250 --> 00:03:16,630
Le module de nœud de monnaie Mongoose,

44
00:03:16,630 --> 00:03:21,800
et vu dans un autre type de schéma à notre application Mongoose, de

45
00:03:21,800 --> 00:03:23,770
sorte que le Mongoose lui-même,

46
00:03:23,770 --> 00:03:26,390
a certainement déjà intégré des types de schéma.

47
00:03:26,390 --> 00:03:29,505
Nous avons vu l'utilisation du nombre, de

48
00:03:29,505 --> 00:03:35,550
la chaîne et du booléen, et du tableau.

49
00:03:35,550 --> 00:03:39,760
Maintenant, la monnaie mongoose ajoute en support pour la monnaie.

50
00:03:39,760 --> 00:03:42,385
Maintenant, pourquoi aurions-nous besoin de ce soutien monétaire ?

51
00:03:42,385 --> 00:03:49,040
Ainsi, ce module de monnaie Mongoose ajoute un nouveau type appelé comme le type de devise,

52
00:03:49,040 --> 00:03:53,140
ce qui nous permet de stocker une valeur monétaire.

53
00:03:53,140 --> 00:03:56,650
Puisque notre plat va contenir un prix,

54
00:03:56,650 --> 00:04:00,760
c'est pourquoi je vais utiliser le module de monnaie Mongoose ici.

55
00:04:00,760 --> 00:04:04,590
Maintenant, l'exercice ici,

56
00:04:04,590 --> 00:04:07,545
nous allons illustrer l'utilisation du module de monnaie Mongoose,

57
00:04:07,545 --> 00:04:11,880
vous pouvez lire plus de détails sur le module de noeud de monnaie Mongoose aussi,

58
00:04:11,880 --> 00:04:19,010
dans la documentation de cela un lien vers lequel est fourni dans les ressources supplémentaires.

59
00:04:19,010 --> 00:04:22,489
Donc, maintenant que nous avons installé ces modules de noeud,

60
00:04:22,489 --> 00:04:24,890
Mongoose et Mongoose monnaie,

61
00:04:24,890 --> 00:04:33,920
allons à notre application et configurons-la pour communiquer avec le serveur MongoDB.

62
00:04:33,920 --> 00:04:37,570
Maintenant, assurez-vous que votre serveur MongoDB est opérationnel.

63
00:04:37,570 --> 00:04:40,070
Donc, ici, vous voyez que

64
00:04:40,070 --> 00:04:44,730
mon serveur MongoDB est en cours d'exécution dans un autre onglet de terminal sur mon ordinateur.

65
00:04:44,730 --> 00:04:46,670
Si vous l'exécutez sur un ordinateur Windows,

66
00:04:46,670 --> 00:04:54,005
assurez-vous qu'il est en cours d'exécution dans une autre commande Fenêtre de votre ordinateur Windows.

67
00:04:54,005 --> 00:04:58,525
Aller à notre application dans l'éditeur,

68
00:04:58,525 --> 00:05:01,685
nous allons d'abord commencer par le fichier app.js.

69
00:05:01,685 --> 00:05:03,460
Maintenant, dans le fichier app.js,

70
00:05:03,460 --> 00:05:07,590
c'est là que nous avons construit notre application express plus tôt.

71
00:05:07,590 --> 00:05:12,935
Mais maintenant, cette négation supplémentaire n'est pas connectée au serveur MongoDB back-end.

72
00:05:12,935 --> 00:05:18,085
Nous allons utiliser le module Mongoose,

73
00:05:18,085 --> 00:05:20,430
afin d'établir la connexion avec le serveur.

74
00:05:20,430 --> 00:05:22,385
Donc, en allant ici,

75
00:05:22,385 --> 00:05:29,540
je vais ajouter le module require Mongoose ici.

76
00:05:29,540 --> 00:05:35,850
Donc, nous allons dire, « Const Mongoose a besoin de Mongoose. »

77
00:05:38,120 --> 00:05:43,280
Et puis aussi, puisque nous avons copié sur le dossier des modèles,

78
00:05:43,280 --> 00:05:46,520
qui contient le fichier plats,

79
00:05:46,520 --> 00:05:51,220
qui déclare le schéma des plats et le modèle.

80
00:05:51,220 --> 00:05:56,645
Alors, laissez-moi importer la vaisselle.

81
00:05:56,645 --> 00:06:04,930
Donc, nous allons dire, « nécessiter.Slash modèles plats. »

82
00:06:04,930 --> 00:06:07,640
Donc, une fois que nous avons terminé cela, maintenant bien sûr,

83
00:06:07,640 --> 00:06:11,000
nous devons établir la connexion avec le serveur.

84
00:06:11,000 --> 00:06:13,560
Donc, configurez

85
00:06:14,120 --> 00:06:24,960
l'URL mongodb// localhost7017/confusion,

86
00:06:27,340 --> 00:06:31,150
tout comme nous l'avons fait avec l'exercice Mongoose,

87
00:06:31,150 --> 00:06:33,140
puis nous dirons,

88
00:06:33,140 --> 00:06:44,040
« Const connect, l'URL de connexion de Mongo ».

89
00:06:44,040 --> 00:06:51,450
Donc, c'est exactement le même code que nous avons utilisé dans l'exercice précédent.

90
00:06:51,450 --> 00:06:53,640
Ensuite, établissons la connexion.

91
00:06:53,640 --> 00:07:01,695
Donc, nous allons dire, « se connecter », puis nous dirons,

92
00:07:01,695 --> 00:07:11,610
« DB do it console log. »

93
00:07:11,610 --> 00:07:19,030
Dire : « Connecté correctement au serveur. »

94
00:07:21,020 --> 00:07:26,260
Et nous allons également gérer l'erreur ici.

95
00:07:33,980 --> 00:07:40,855
Nous allons simplement faire un journal de la console de l'erreur ici, c'est tout.

96
00:07:40,855 --> 00:07:49,110
Cela établira la connexion au serveur à partir de notre fichier app.js.

97
00:07:49,110 --> 00:07:52,375
Donc, une fois que nous avons établi la connexion au serveur,

98
00:07:52,375 --> 00:07:58,615
alors, ouvrons le fichier dishes.js à partir de nos modèles.

99
00:07:58,615 --> 00:08:00,995
Maintenant, dans le fichier dishes.js,

100
00:08:00,995 --> 00:08:02,970
pour utiliser

101
00:08:02,970 --> 00:08:11,760
le module de noeud que nous venons d'installer.

102
00:08:11,760 --> 00:08:18,990
Donc, nous allons dire, « Exiger la monnaie mongoose », et dire,

103
00:08:18,990 --> 00:08:26,500
« Charger le type et Mongoose ».

104
00:08:26,500 --> 00:08:32,670
Donc, ce que cela fera est de charger ce nouveau type de devise dans Mongoose.

105
00:08:32,670 --> 00:08:39,970
Par la suite, nous pouvons dire const,

106
00:08:39,970 --> 00:08:48,705
monnaie Mongoose types monnaie.

107
00:08:48,705 --> 00:08:51,720
C' est ça. Donc, ce nouveau type,

108
00:08:51,720 --> 00:08:57,880
le type de devise est ajouté dans Mongoose et cela ajoutera un nouveau type appelé

109
00:08:57,880 --> 00:09:00,160
monnaie et alors je vais déclarer

110
00:09:00,160 --> 00:09:04,840
cette monnaie constante comme monnaie de types de Mongoose.

111
00:09:04,840 --> 00:09:11,630
Pour que je puisse utiliser cela dans la définition du schéma dans mon application.

112
00:09:11,630 --> 00:09:14,270
Maintenant, dans ce cas,

113
00:09:14,270 --> 00:09:17,970
le schéma commun restera exactement le même qu'avant, mais

114
00:09:17,970 --> 00:09:24,060
le schéma plat comme vous le rappelez du fichier db.json.

115
00:09:24,060 --> 00:09:28,050
Lorsque vous regardez la structure d'un document plat,

116
00:09:28,050 --> 00:09:35,630
vous voyez que le document plat contient le nom et l'image qui, comme vous le voyez ici, est une chaîne,

117
00:09:35,630 --> 00:09:38,570
une catégorie, une étiquette,

118
00:09:38,570 --> 00:09:42,555
un prix, qui est un type de chaîne ici.

119
00:09:42,555 --> 00:09:46,865
Mais nous allons déclarer ceci comme un type de devise,

120
00:09:46,865 --> 00:09:51,495
une fonctionnalité qui comme vous vous attendez est une variable booléenne,

121
00:09:51,495 --> 00:09:55,015
et une description qui est une chaîne, puis des commentaires

122
00:09:55,015 --> 00:09:59,755
qui n'est rien d'autre qu'un tableau de type commentaires.

123
00:09:59,755 --> 00:10:05,790
Maintenant, donc ce que nous allons maintenant faire est d'étendre le schéma plat pour

124
00:10:05,790 --> 00:10:12,865
soutenir toutes ces diverses propriétés ou divers champs dans mon document json.

125
00:10:12,865 --> 00:10:15,225
Donc nous avons déjà le nom.

126
00:10:15,225 --> 00:10:18,505
Nous avons donc déjà la description en place.

127
00:10:18,505 --> 00:10:23,730
Donc, nous devons ajouter dans les prochains, nous avons déjà les commentaires,

128
00:10:23,730 --> 00:10:27,185
le tableau de commentaires du type de schéma de commentaire là-bas.

129
00:10:27,185 --> 00:10:30,075
Donc, nous allons ajouter dans les prochains.

130
00:10:30,075 --> 00:10:34,150
Donc, le prochain que nous allons ajouter est le type d'image,

131
00:10:34,150 --> 00:10:37,640
qui serait de

132
00:10:37,640 --> 00:10:44,300
la chaîne de type et

133
00:10:44,300 --> 00:10:49,140
nous dirons nécessaire true.

134
00:10:49,200 --> 00:10:52,240
Cela ajoute donc le type d'image.

135
00:10:52,240 --> 00:11:00,460
Le suivant que j'ajouterai est la catégorie,

136
00:11:00,460 --> 00:11:03,865
qui est aussi le type de chaîne.

137
00:11:03,865 --> 00:11:07,990
Le suivant est l'étiquette,

138
00:11:07,990 --> 00:11:10,720
qui est également ce type de chaîne.

139
00:11:10,720 --> 00:11:14,560
Puisque tous ces éléments sont du même type et requis,

140
00:11:14,560 --> 00:11:16,625
je les copie juste ici.

141
00:11:16,625 --> 00:11:18,464
Ensuite, pour l'étiquette,

142
00:11:18,464 --> 00:11:21,275
je dirais que ce n'est pas nécessaire mais à la

143
00:11:21,275 --> 00:11:26,945
place je peux également spécifier une valeur par défaut si je veux.

144
00:11:26,945 --> 00:11:29,465
Donc, je peux spécifier une valeur par défaut comme ça.

145
00:11:29,465 --> 00:11:31,965
La valeur par défaut est une chaîne vide.

146
00:11:31,965 --> 00:11:37,245
Donc, si je ne spécifie pas requis, je peux simplement spécifier une valeur par défaut ici.

147
00:11:37,245 --> 00:11:46,300
Maintenant, en plus, le champ suivant que je vais introduire est le champ des prix.

148
00:11:47,070 --> 00:11:53,575
Le champ de prix je vais déclarer le type comme devise.

149
00:11:53,575 --> 00:11:57,085
Rappelons que nous avions déclaré le type de devise plus tôt

150
00:11:57,085 --> 00:12:00,380
ici en exigeant d'abord

151
00:12:00,380 --> 00:12:03,960
le module de monnaie Mongoose, puis en déclarant le type de devise.

152
00:12:03,960 --> 00:12:09,435
Donc, c'est ainsi que vous utiliseriez le type de devise dans notre application.

153
00:12:09,435 --> 00:12:16,170
Donc, nous allons dire que la monnaie de type de prix

154
00:12:16,170 --> 00:12:24,610
et requise est vraie et alors je peux également spécifier la valeur minimale qui serait zéro.

155
00:12:24,610 --> 00:12:29,590
Ensuite, le champ suivant est

156
00:12:29,590 --> 00:12:35,830
le champ vedette qui serait de type booléen,

157
00:12:35,830 --> 00:12:40,900
et la valeur par défaut sera false.

158
00:12:40,900 --> 00:12:43,625
Donc, si mon document manque cela,

159
00:12:43,625 --> 00:12:47,940
alors la valeur par défaut sera ajoutée dans le document ici.

160
00:12:47,940 --> 00:12:50,470
Notez donc que j'ai maintenant élargi

161
00:12:50,470 --> 00:12:56,825
le schéma plat en ajoutant le type d'image, la catégorie, l'

162
00:12:56,825 --> 00:13:01,710
étiquette, le prix et la fonctionnalité pour correspondre à la

163
00:13:01,710 --> 00:13:07,925
structure de l'exemple de document plat que je viens de vous montrer plus tôt.

164
00:13:07,925 --> 00:13:13,795
Alors maintenant, mon schéma de vaisselle est prêt à être utilisé.

165
00:13:13,795 --> 00:13:20,185
Alors, commençons maintenant à travailler sur mon routeur.

166
00:13:20,185 --> 00:13:21,915
Où est le routeur ?

167
00:13:21,915 --> 00:13:29,530
Vous rappelez que le routeur qui prend en charge les points de terminaison de l'API REST pour les plats de barre oblique,

168
00:13:29,530 --> 00:13:32,110
le point de terminaison de l'API REST et les plats de

169
00:13:32,110 --> 00:13:35,170
barre oblique, le point de terminaison de l'ID de barre oblique se trouve dans le

170
00:13:35,170 --> 00:13:41,295
Donc, nous allons aller à plat router.jsfile et ensuite nous allons étendre le fichier dish router.js.

171
00:13:41,295 --> 00:13:46,735
Donc, dans le routeur à plat avec Express et BodyParser,

172
00:13:46,735 --> 00:13:55,310
je vais maintenant inclure Mongoose.

173
00:13:56,640 --> 00:14:03,370
Donc, nous allons dire exiger Mongoose et

174
00:14:03,370 --> 00:14:10,944
alors nous aurons besoin de plats modèle.

175
00:14:10,944 --> 00:14:12,400
Où est le modèle des plats ?

176
00:14:12,400 --> 00:14:20,080
Il est dans. /modèles/vaisselles.

177
00:14:20,080 --> 00:14:22,405
Donc, il est là-dedans.

178
00:14:22,405 --> 00:14:24,470
Donc, notez que nous sommes dans le dossier du routeur,

179
00:14:24,470 --> 00:14:27,610
vous devez donc monter d'un niveau, puis aller dans

180
00:14:27,610 --> 00:14:31,460
le dossier du modèle, puis le fichier dishes.js est juste là.

181
00:14:31,460 --> 00:14:34,010
C' est donc ce que nous importons ici.

182
00:14:34,010 --> 00:14:41,039
Donc maintenant, je peux mettre à jour mon routeur plat pour pouvoir interagir

183
00:14:41,039 --> 00:14:46,330
avec le serveur MongoDB en utilisant

184
00:14:46,330 --> 00:14:52,175
Mongoose et nous avons déjà importé le modèle de vaisselle dans mon routeur plat.

185
00:14:52,175 --> 00:14:57,720
Donc, il est temps pour moi d'aller mettre à jour toutes les méthodes ici.

186
00:14:57,720 --> 00:14:59,465
Donc, pour le routeur à plat,

187
00:14:59,465 --> 00:15:03,665
la barre oblique qui signifie que la barre plats terminaison point.

188
00:15:03,665 --> 00:15:07,880
Je vais supprimer tout cela d'ici, à la place,

189
00:15:07,880 --> 00:15:12,040
je vais déclarer explicitement tous les différents points de terminaison.

190
00:15:12,040 --> 00:15:16,995
Pour obtenir post put and delete, je vais gérer chacun d'eux indépendamment.

191
00:15:16,995 --> 00:15:19,135
Donc, dans la méthode get,

192
00:15:19,135 --> 00:15:24,360
je vais couper ça et ensuite dans la méthode get, que dois-je faire ?

193
00:15:24,360 --> 00:15:32,760
Rappelons que nous avions défini méthode de Mongoose qui nous permet de trouver tous les plats.

194
00:15:32,760 --> 00:15:36,365
Donc, lorsque vous effectuez une opération get sur le point de terminaison des plats barre oblique,

195
00:15:36,365 --> 00:15:39,600
vous vous attendez à ce que tous les plats soient retournés

196
00:15:39,600 --> 00:15:44,005
au client en réponse à la demande get.

197
00:15:44,005 --> 00:15:49,890
Donc, je vais aller à la vaisselle et ensuite effectuer l'opération de recherche.

198
00:15:49,890 --> 00:15:53,040
Donc maintenant vous voyez que depuis mon serveur Express,

199
00:15:53,040 --> 00:15:58,585
j'accède à mon MongoDB.

200
00:15:58,585 --> 00:16:06,520
Donc, fera une recherche et dans la recherche, je vais maintenant gérer la demande.

201
00:16:06,520 --> 00:16:08,310
Donc, je peux dire

202
00:16:08,310 --> 00:16:13,885
que les plats trouvent, puisque cela va rendre une promesse,

203
00:16:13,885 --> 00:16:16,765
alors je peux gérer ça à l'intérieur ici.

204
00:16:16,765 --> 00:16:24,520
Donc, je vais dire plat et donc si la promesse résout correctement,

205
00:16:24,520 --> 00:16:33,529
je vais l'obtenir dans le puis et donc je vais dire plat et puis nous allons gérer le

206
00:16:33,960 --> 00:16:41,125
code d'état res est 200 et puis nous allons dire le

207
00:16:41,125 --> 00:16:48,920
type de contenu d'en-tête res set.

208
00:16:53,100 --> 00:16:57,830
Puisque nous allons retourner la valeur en tant que json,

209
00:16:57,830 --> 00:17:00,770
nous allons donc définir cela à l'application json.

210
00:17:00,770 --> 00:17:03,580
Ok, ça va retourner un tableau de plats.

211
00:17:03,580 --> 00:17:07,955
Donc, je peux simplement dire de la vaisselle et ensuite nous dirons res.json.

212
00:17:07,955 --> 00:17:12,650
Donc, le res.json prendra comme entrée dans la chaîne json

213
00:17:12,650 --> 00:17:17,680
, puis le renvoyer à mon client.

214
00:17:17,680 --> 00:17:21,785
Donc, lorsque vous appelez res.json et fournissez la valeur, puis il

215
00:17:21,785 --> 00:17:27,650
prendra simplement le paramètre que vous donnez ici et ensuite le renvoyer en tant que réponse json.

216
00:17:27,650 --> 00:17:30,365
Il va mettre ces plats dans le corps

217
00:17:30,365 --> 00:17:33,835
du message de réponse, puis le renvoyer au serveur.

218
00:17:33,835 --> 00:17:39,560
Maintenant, nous pouvons gérer l'erreur

219
00:17:39,560 --> 00:17:47,370
ici en disant l'erreur suivante.

220
00:17:48,100 --> 00:17:59,140
Nous pouvons également faire une erreur de capture juste pour le bien de complet.

221
00:17:59,140 --> 00:18:03,290
Je vais simplement mettre les deux en place ici, de

222
00:18:03,290 --> 00:18:05,960
sorte que les deux soient traités comme tels.

223
00:18:05,960 --> 00:18:08,305
Donc, si une erreur est renvoyée,

224
00:18:08,305 --> 00:18:11,740
cela va simplement transmettre l'erreur

225
00:18:11,740 --> 00:18:15,260
au gestionnaire d'erreur global pour mon application

226
00:18:15,260 --> 00:18:18,985
et laisser cela s'inquiéter de la façon de gérer l'erreur.

227
00:18:18,985 --> 00:18:21,490
Donc on va l'envoyer à ça.

228
00:18:21,490 --> 00:18:28,610
Donc, vous voyez comment j'utilise l'opération de recherche et ensuite j'effectue la requête ici.

229
00:18:28,610 --> 00:18:30,595
Maintenant, pour le poste,

230
00:18:30,595 --> 00:18:32,904
comme vous l'auriez déjà prévu,

231
00:18:32,904 --> 00:18:37,100
je vais faire des plats.create

232
00:18:38,790 --> 00:18:43,425
parce que nous allons créer un nouveau plat ici.

233
00:18:43,425 --> 00:18:47,195
Donc, rappelez-vous que nous avons déjà vu les plats créer l'

234
00:18:47,195 --> 00:18:52,400
utilisation de la méthode plus tôt et rappelez-vous que l'analyseur de corps aurait

235
00:18:52,400 --> 00:18:56,950
déjà analysé tout ce qui est dans le corps du message et l'a chargé

236
00:18:56,950 --> 00:19:01,510
sur la propriété body de la requête.

237
00:19:01,510 --> 00:19:08,650
Donc, je vais juste prendre le corps de la requête, puis l'analyser en tant que paramètre à ma

238
00:19:08,650 --> 00:19:16,120
méthode dishes.create et gérer la valeur de retour.

239
00:19:16,120 --> 00:19:21,325
Donc, nous dirons alors et cela rendrait

240
00:19:21,325 --> 00:19:26,755
un plat et nous nous occuperons de ça ici.

241
00:19:26,755 --> 00:19:35,220
Donc, nous dirons si les plats retournent correctement et si les plats affichés correctement, dira res res.

242
00:19:36,060 --> 00:19:43,045
Ok, faisons un console.log pour notre propre usage.

243
00:19:43,045 --> 00:19:52,330
Du côté serveur, nous allons faire un console.log disant « Dish Created » plat ici.

244
00:19:52,330 --> 00:20:02,125
Nous allons enregistrer ce plat sur la console et ensuite nous dirons ces deux codes d'état de repos.

245
00:20:02,125 --> 00:20:09,820
Nous allons juste copier ce code, puis le coller dedans et dans ce cas,

246
00:20:09,820 --> 00:20:12,445
nous retournons le plat ici.

247
00:20:12,445 --> 00:20:16,480
Le plat qui est entré en tant que paramètre ici, puis laisser

248
00:20:16,480 --> 00:20:22,825
le client gérer cette valeur côté client,

249
00:20:22,825 --> 00:20:24,985
tout ce qui est retourné dans le plat.

250
00:20:24,985 --> 00:20:27,745
Maintenant, aussi, ils vont ajouter

251
00:20:27,745 --> 00:20:41,770
ici et puis la prise.

252
00:20:41,770 --> 00:20:44,860
Donc, c'est comme ça que nous gérons le poste.

253
00:20:44,860 --> 00:20:47,830
Pour le PUT, parce que PUT n'est pas autorisé,

254
00:20:47,830 --> 00:20:50,365
donc nous allons le laisser en tant que tel.

255
00:20:50,365 --> 00:20:54,250
Pour DELETE, nous allons supprimer tous les plats.

256
00:20:54,250 --> 00:21:02,240
Donc, nous allons dire, « vaisselles.Retirer. »

257
00:21:03,990 --> 00:21:08,185
Il s'agit essentiellement d'une opération dangereuse.

258
00:21:08,185 --> 00:21:11,080
Donc, vous supprimez tous les plats

259
00:21:11,080 --> 00:21:18,610
du serveur et donc nous dirons,

260
00:21:18,610 --> 00:21:25,600
« vaisselles.Retirer puis » et le « puis » recevra une réponse.

261
00:21:25,600 --> 00:21:32,200
Donc, nous allons simplement dire, « resp ici » et la façon dont nous gérerions

262
00:21:32,200 --> 00:21:40,550
cette réponse est simplement de prendre cette valeur et de la retourner au client.

263
00:21:40,620 --> 00:21:48,550
Donc, nous allons dire, « RES.StatusCode 200 application de type de contenu json »,

264
00:21:48,550 --> 00:21:56,660
puis nous allons simplement renvoyer la réponse au client et nous allons gérer l'erreur

265
00:22:06,000 --> 00:22:08,830
comme nous l'avons fait plus tôt.

266
00:22:08,830 --> 00:22:10,390
C' est l'opération DELETE.

267
00:22:10,390 --> 00:22:14,110
Donc, vous voyez que maintenant nous faisons l'

268
00:22:14,110 --> 00:22:17,545
opération GET, POST, PUT et DELETE.

269
00:22:17,545 --> 00:22:26,425
Maintenant, nous allons continuer la même chose avec le point de terminaison /dishid.

270
00:22:26,425 --> 00:22:28,270
Donc, dans ce cas,

271
00:22:28,270 --> 00:22:34,040
nous sommes spécifiquement motif obtenir un plat spécifique.

272
00:22:34,040 --> 00:22:39,480
Nous allons rendre cette valeur de plat spécifique.

273
00:22:39,480 --> 00:22:41,445
Donc, dans le GET,

274
00:22:41,445 --> 00:22:51,275
ce que nous faisons, c'est que nous dirons « Plaises.FindById.

275
00:22:51,275 --> 00:22:57,965
Donc, le FindById est une méthode qui est disponible à partir de mongo ainsi que le pilote MongoDB.

276
00:22:57,965 --> 00:23:02,020
Donc, nous allons dire, » req.params.dishid. »

277
00:23:03,600 --> 00:23:11,030
Rappelons que nous savons déjà que l'ID plat est présent dans la propriété params.

278
00:23:11,030 --> 00:23:14,140
Vous en avez déjà appris plus tôt.

279
00:23:14,140 --> 00:23:20,260
Donc, je vais dire, « FindById (req.params.dishid) » et

280
00:23:20,260 --> 00:23:24,565
puis et le reste.

281
00:23:24,565 --> 00:23:30,520
Donc, je vais juste copier cela puis et d'autre à partir de

282
00:23:30,520 --> 00:23:38,170
là et ensuite descendre sur le Dish.Router et

283
00:23:38,170 --> 00:23:46,150
puis simplement coller ça ici.

284
00:23:46,150 --> 00:23:49,190
Donc, nous allons dire, "

285
00:23:49,440 --> 00:23:55,585
application res.statusCode200 json.res.jsondish, puis la gestion des erreurs.

286
00:23:55,585 --> 00:24:05,350
Pour le POST, évidemment, nous ne gérerons pas la publication pour un point de terminaison /dishid.

287
00:24:05,350 --> 00:24:07,635
Donc nous allons le laisser en tant que tel.

288
00:24:07,635 --> 00:24:12,740
Pour PUT, nous allons mettre à jour

289
00:24:12,740 --> 00:24:17,975
un plat spécifique identifié par son identifiant de plat.

290
00:24:17,975 --> 00:24:25,270
Donc, c'est là que nous allons utiliser des plats.FindbyIdAndUpdate.

291
00:24:25,270 --> 00:24:27,690
Donc, c'est la méthode que nous allons utiliser,

292
00:24:27,690 --> 00:24:35,539
findByidAndUpdate et cela prend comme premier paramètre

293
00:24:37,410 --> 00:24:44,410
req.params.dishid et la deuxième valeur est

294
00:24:44,410 --> 00:24:53,290
l'ensemble et la mise à jour

295
00:24:53,290 --> 00:24:55,150
sera dans le corps du message.

296
00:24:55,150 --> 00:24:57,580
Donc je vais juste récupérer ça du

297
00:24:57,580 --> 00:25:05,410
corps de req et puis aussi de l'autre drapeau que je vais avoir.

298
00:25:05,410 --> 00:25:10,840
Donc dira, « new : true », de sorte que cette méthode findById retournera

299
00:25:10,840 --> 00:25:18,730
le plat mis à jour sous forme de chaîne json dans la réponse.

300
00:25:18,730 --> 00:25:23,650
Donc c'est ce que je vais obtenir ici et quand cette valeur entrera en jeu,

301
00:25:23,650 --> 00:25:26,230
je vais juste prendre le plat et

302
00:25:26,230 --> 00:25:39,040
ensuite simplement retourner le plat au côté client.

303
00:25:39,040 --> 00:25:47,095
Donc, je vais dire res.jason (plat) et ensuite nous allons gérer l'erreur en conséquence.

304
00:25:47,095 --> 00:25:49,090
Enfin pour la DELETE.

305
00:25:49,090 --> 00:25:50,695
Pour la DELETE à nouveau,

306
00:25:50,695 --> 00:25:54,880
la méthode correspondante que nous allons

307
00:25:54,880 --> 00:26:01,165
utiliser est la méthode de Mongo appelée FindByIdAndRemove.

308
00:26:01,165 --> 00:26:03,760
Donc, vous pouvez voir que nous avons cette méthode appelée

309
00:26:03,760 --> 00:26:08,080
FindByIdAndRemove et cette FindByIdAndRemove,

310
00:26:08,080 --> 00:26:18,355
prendra req.params.dishid parce que c'est le plat que nous essayons de supprimer.

311
00:26:18,355 --> 00:26:20,970
Ensuite, quand cela est supprimé,

312
00:26:20,970 --> 00:26:23,940
donc tout comme nous avons géré cela ici,

313
00:26:23,940 --> 00:26:30,830
donc je vais juste copier ce code à partir des plates.Retirer.

314
00:26:30,830 --> 00:26:34,350
C' est la même chose que je vais faire ici aussi.

315
00:26:34,350 --> 00:26:38,750
Donc findByIdAndRemove et quelle que soit la réponse que

316
00:26:38,750 --> 00:26:41,970
j'obtiens, je vais le retourner à mon client.

317
00:26:41,970 --> 00:26:45,490
Avec cela, nous avons mis à jour le Dish.Router.

318
00:26:45,490 --> 00:26:49,960
Sauvegardons tous les changements que nous avons faits

319
00:26:49,960 --> 00:26:57,185
jusqu'à présent, puis nous allons démarrer notre serveur et voir ce qu'il fait.

320
00:26:57,185 --> 00:27:01,370
Donc, en allant au terminal ou à la fenêtre de commande, démarrez le serveur.

321
00:27:01,370 --> 00:27:06,045
Donc, je vais dire « npm start » et le serveur est maintenant opérationnel.

322
00:27:06,045 --> 00:27:12,030
On va utiliser le facteur pour communiquer avec ce serveur.

323
00:27:12,030 --> 00:27:15,700
Alors allons voir le facteur et ensuite effectuer certaines opérations.

324
00:27:15,700 --> 00:27:19,030
Alors voici mon facteur qui court ici.

325
00:27:19,030 --> 00:27:26,450
Alors laissez-moi faire une opération GET sur le localhost : 3000/plats.

326
00:27:28,300 --> 00:27:31,875
Donc, lorsque vous faites une opération GET comme vous le voyez,

327
00:27:31,875 --> 00:27:33,205
il retournera une chaîne vide.

328
00:27:33,205 --> 00:27:36,715
Ma base de données est maintenant vide, donc je n'ai rien là-bas.

329
00:27:36,715 --> 00:27:40,205
Donc, je vais juste être retourné une chaîne vide.

330
00:27:40,205 --> 00:27:45,600
Envoyez-nous un plat.

331
00:27:46,020 --> 00:27:48,340
Donc, lorsque vous publiez un plat,

332
00:27:48,340 --> 00:27:50,254
évidemment dans le corps,

333
00:27:50,254 --> 00:27:58,175
vous serez enfermant un plat et le corps sera défini pour être le type d'application json.

334
00:27:58,175 --> 00:28:00,785
Maintenant, pour poster un plat,

335
00:28:00,785 --> 00:28:06,770
je vous ai déjà donné le fichier db.json dans les ressources d'exercice.

336
00:28:06,770 --> 00:28:10,880
Alors ouvrez simplement le fichier db.json et copiez le tout premier plat à partir de

337
00:28:10,880 --> 00:28:15,390
là, puis nous allons le coller ici et ensuite poster ce plat.

338
00:28:15,390 --> 00:28:18,735
Alors, laissez-moi aller au fichier db.jason.

339
00:28:18,735 --> 00:28:21,550
Permettez-moi de copier le tout premier plat d'ici.

340
00:28:21,550 --> 00:28:22,810
Donc je vais juste copier

341
00:28:22,810 --> 00:28:32,765
le plat entier jusqu'à là et ensuite je vais poster ce plat.

342
00:28:32,765 --> 00:28:36,610
Cela contient beaucoup de champs que nous avons déjà ici.

343
00:28:36,610 --> 00:28:39,895
Postons ce plat sur le serveur et voyons ce qui se passe.

344
00:28:39,895 --> 00:28:44,605
Alors, revenons au facteur.

345
00:28:44,605 --> 00:28:47,620
Ici, dans les données de forme,

346
00:28:47,620 --> 00:28:51,535
dans le corps, laissez-moi coller le plat en place.

347
00:28:51,535 --> 00:28:54,760
Donc, nous avons tous les détails du plat là-bas.

348
00:28:54,760 --> 00:28:58,010
POSTONS ce plat sur le serveur.

349
00:28:58,320 --> 00:29:01,780
Ensuite, une fois que le plat est posté sur le serveur,

350
00:29:01,780 --> 00:29:06,580
vous voyez que le facteur a,

351
00:29:06,580 --> 00:29:09,700
laissez-moi juste réduire cela,

352
00:29:09,700 --> 00:29:18,370
et puis vous voyez en bas que ce plat particulier a été posté dans la base de données, dans

353
00:29:18,370 --> 00:29:20,290
la base de données MongoDB par mon serveur.

354
00:29:20,290 --> 00:29:23,560
Donc, vous voyez que la valeur renvoyée

355
00:29:23,560 --> 00:29:30,760
ici montre quand le plat a été inséré dans ce serveur.

356
00:29:30,760 --> 00:29:35,020
Donc, vous avez le CreateDAT et UpdateDAT ajoutés là.

357
00:29:35,020 --> 00:29:39,880
Vous voyez que les champs restants y sont tous stockés.

358
00:29:39,880 --> 00:29:45,865
Notez en particulier comment la valeur du prix y est stockée.

359
00:29:45,865 --> 00:29:49,820
C' est ainsi que la devise stocke la valeur du prix.

360
00:29:50,630 --> 00:29:53,825
Donc, lorsque vous obtenez la valeur de retour,

361
00:29:53,825 --> 00:29:59,370
vous devez interpréter cela de manière appropriée du côté de votre client ce que cela signifie.

362
00:29:59,370 --> 00:30:08,510
Notez également que l'ID a été ajouté à mon plat et pour chaque commentaire lui-même,

363
00:30:08,510 --> 00:30:11,445
car chacun des commentaires est lui-même un sous-document.

364
00:30:11,445 --> 00:30:14,370
Vous aurez les UpdateDAT et CreateDAT ajoutés,

365
00:30:14,370 --> 00:30:21,115
et l'ID de chacun des commentaires également ajoutés automatiquement par ma base de données.

366
00:30:21,115 --> 00:30:23,080
Voilà, tu y vas. Donc maintenant,

367
00:30:23,080 --> 00:30:26,875
ce plat a été ajouté à ma base de données.

368
00:30:26,875 --> 00:30:29,589
Effectuons à nouveau l'opération GET,

369
00:30:29,589 --> 00:30:32,244
et évidemment à ce stade,

370
00:30:32,244 --> 00:30:37,135
le serveur devrait renvoyer ce plat particulier qui a été ajouté dans.

371
00:30:37,135 --> 00:30:39,775
Donc, il retournera un tableau de plats ici, de

372
00:30:39,775 --> 00:30:42,190
sorte que vous pouvez le voir, il retourne un tableau de plats.

373
00:30:42,190 --> 00:30:44,050
Bien sûr, ce tableau ne contient qu'un seul plat

374
00:30:44,050 --> 00:30:47,245
ou ce plat particulier a été retourné ici.

375
00:30:47,245 --> 00:30:49,585
Jusqu' à présent, si bien.

376
00:30:49,585 --> 00:30:54,895
Alors, faisons un PUT sur la vaisselle et voyons ce qui se passe.

377
00:30:54,895 --> 00:30:56,980
Lorsque vous faites un PUT, évidemment, il est dit,

378
00:30:56,980 --> 00:31:02,255
« opération PUT non supportée sur les plats », comme nous nous y attendons.

379
00:31:02,255 --> 00:31:03,770
Faisons une DELETE. En

380
00:31:03,770 --> 00:31:05,575
faisant une opération DELETE,

381
00:31:05,575 --> 00:31:09,030
il renvoie cette réponse disant,

382
00:31:09,030 --> 00:31:10,890
« N est égal à un », ok,

383
00:31:10,890 --> 00:31:13,570
un signifiant qu'il a supprimé un plat.

384
00:31:13,570 --> 00:31:15,660
Revenons maintenant, effectuez une opération GET,

385
00:31:15,660 --> 00:31:22,850
et puis vous verrez que mes plats sont vides comme nous nous y attendions.

386
00:31:22,980 --> 00:31:25,930
Ainsi, vous voyez que les

387
00:31:25,930 --> 00:31:28,405
opérations GET, PUT, POST et DELETE fonctionnent toutes correctement.

388
00:31:28,405 --> 00:31:31,225
Maintenant, laissez-moi POST le plat

389
00:31:31,225 --> 00:31:36,110
à nouveau sur le serveur parce que je veux avoir un plat dans le serveur.

390
00:31:36,270 --> 00:31:38,725
Donc, laissez-moi POST ce plat,

391
00:31:38,725 --> 00:31:41,425
et vous remarqueriez que l'ID a maintenant changé.

392
00:31:41,425 --> 00:31:44,110
Donc, laissez-moi sélectionner cet ID,

393
00:31:44,110 --> 00:31:50,630
puis nous ferons un GET avec l'ID en place.

394
00:31:51,990 --> 00:31:55,405
Lorsque vous faites un GET avec l'ID en place,

395
00:31:55,405 --> 00:32:02,300
vous voyez qu'il renvoie ce plat spécifique comme vous l'attendez.

396
00:32:02,760 --> 00:32:07,630
Allons au terminal et voyons ce qui

397
00:32:07,630 --> 00:32:12,125
est imprimé sur le terminal ou votre fenêtre de commande.

398
00:32:12,125 --> 00:32:15,300
Donc, en allant au terminal ou à votre fenêtre de commande,

399
00:32:15,300 --> 00:32:19,360
vous voyez qu'il est en train d'imprimer toutes ces choses sur la fenêtre de commande.

400
00:32:19,360 --> 00:32:21,540
Donc, quand nous avons fait la première opération GET,

401
00:32:21,540 --> 00:32:22,640
il est dit, GET /plats.

402
00:32:22,640 --> 00:32:24,375
Donc, c'est encore une fois,

403
00:32:24,375 --> 00:32:28,155
Morgan qui fait ce travail pour vous, il est d'imprimer, de

404
00:32:28,155 --> 00:32:31,170
tracer cette information et il dit plat créé

405
00:32:31,170 --> 00:32:34,575
et ensuite que les informations de plat particulier ont été imprimées,

406
00:32:34,575 --> 00:32:38,190
puis il dit POST /plats, GET /plats,

407
00:32:38,190 --> 00:32:41,130
puis quand vous avez fait un PUT, il a retourné un 403

408
00:32:41,130 --> 00:32:44,170
là et vous avez encore créé des plats et ainsi de suite.

409
00:32:44,170 --> 00:32:47,145
Donc, vous voyez que votre serveur fait tout le travail,

410
00:32:47,145 --> 00:32:53,110
et ces choses sont insérées dans votre base de données MongoDB comme prévu.

411
00:32:53,110 --> 00:32:58,540
Maintenant, revenons au Facteur,

412
00:32:58,540 --> 00:33:00,850
faisons un POST sur la vaisselle.

413
00:33:00,850 --> 00:33:03,605
Maintenant, cela n'est pas pris en charge côté serveur,

414
00:33:03,605 --> 00:33:04,750
donc votre serveur doit dire,

415
00:33:04,750 --> 00:33:10,225
« L'opération POST n'est pas prise en charge sur ce point de terminaison particulier », comme vous pouvez vous y attendre.

416
00:33:10,225 --> 00:33:13,070
Faisons une opération PUT.

417
00:33:14,430 --> 00:33:17,190
Lorsque vous faites une opération PUT,

418
00:33:17,190 --> 00:33:20,955
ce que je vais faire dans l'opération PUT, c'est que je vais

419
00:33:20,955 --> 00:33:26,860
remplacer l'étiquette là-bas.

420
00:33:26,860 --> 00:33:29,550
Donc, dans mon corps du message.

421
00:33:29,550 --> 00:33:34,570
Donc, rappelez-vous que si vous regardez le fichier DB.json,

422
00:33:34,570 --> 00:33:38,180
l'étiquette pour cela serait nouvelle,

423
00:33:38,180 --> 00:33:51,160
et donc je vais changer cette étiquette en hot.

424
00:33:51,160 --> 00:33:53,040
Puisque cela doit être en Json,

425
00:33:53,040 --> 00:33:57,895
donc étiqueter aussi entre guillemets Json étiquette chaude,

426
00:33:57,895 --> 00:34:02,810
puis faisons un PUT sur ce point de terminaison particulier.

427
00:34:04,080 --> 00:34:07,615
L' opération PUT a réussi,

428
00:34:07,615 --> 00:34:12,280
et vous voyez donc que lorsque l'opération PUT a été terminée,

429
00:34:12,280 --> 00:34:19,150
vous remarqueriez que l'étiquette est maintenant passée de new à hot ici,

430
00:34:19,150 --> 00:34:22,630
et notez en particulier la valeur

431
00:34:22,630 --> 00:34:28,900
CreatedAt et la valeur UpdateDAT.

432
00:34:28,900 --> 00:34:31,990
Donc, notez que cet enregistrement a été créé

433
00:34:31,990 --> 00:34:36,970
à ce moment et a été mis à jour un peu plus tard.

434
00:34:36,970 --> 00:34:40,000
Donc, la mise à jour a été faite par l'opération PUT que je viens d'

435
00:34:40,000 --> 00:34:43,450
effectuer sur ce plat particulier.

436
00:34:43,450 --> 00:34:46,240
Supprimons le plat.

437
00:34:46,240 --> 00:34:49,795
Ceci est permis. Donc, nous allons supprimer le plat,

438
00:34:49,795 --> 00:34:54,100
puis le plat sera supprimé et la valeur sera retournée.

439
00:34:54,100 --> 00:34:58,930
Maintenant, si vous effectuez une opération GET sur

440
00:34:58,930 --> 00:35:04,615
le point de terminaison vaisselle, vous verrez que cela retournera un vide.

441
00:35:04,615 --> 00:35:09,385
Donc, vous venez de supprimer le plat de notre base de données.

442
00:35:09,385 --> 00:35:14,095
Ce que je vais faire est d'effectuer

443
00:35:14,095 --> 00:35:20,630
une opération GET sur un plat inexistant et de voir ce qui se passe.

444
00:35:20,630 --> 00:35:23,905
Lorsque j'effectue une opération GET sur un plat inexistant,

445
00:35:23,905 --> 00:35:27,300
il renvoie null car ce plat n'existe pas.

446
00:35:27,300 --> 00:35:31,570
Donc, il renvoie une valeur nulle disant que le plat n'existe pas.

447
00:35:31,570 --> 00:35:40,525
Maintenant, laissez-moi effectuer une opération GET sur un non-Objectid et voir ce qui se passe.

448
00:35:40,525 --> 00:35:44,980
Il revient comme vous le voyez.

449
00:35:44,980 --> 00:35:46,465
Laissez-moi en prévisualiser.

450
00:35:46,465 --> 00:35:51,840
Donc, il est dit, « Cast to ObjectID a échoué pour la valeur ici au chemin. »

451
00:35:51,840 --> 00:35:53,840
Donc, je serai évidemment ce n'est pas

452
00:35:53,840 --> 00:35:57,565
un ObjectID valide donc j'ai juste réussi à en supprimer une partie,

453
00:35:57,565 --> 00:36:02,050
puis à effectuer l'opération afin qu'il renvoie une erreur disant,

454
00:36:02,050 --> 00:36:04,915
donc vous voyez qu'il y a 500 erreur de serveur interne.

455
00:36:04,915 --> 00:36:09,505
Le serveur n'a pas pu gérer cela, puis retourner cette valeur ici.

456
00:36:09,505 --> 00:36:11,925
Donc, il est dit, « Non,

457
00:36:11,925 --> 00:36:13,230
ce n'est pas permis. »

458
00:36:13,230 --> 00:36:18,385
Donc, parce que ce n'est pas un ObjectID valide.

459
00:36:18,385 --> 00:36:22,275
Ainsi, même les erreurs sont traitées de manière appropriée comme vous le voyez ici.

460
00:36:22,275 --> 00:36:26,050
Donc, laissez-moi encore une fois, faites une opération GET sur les plats,

461
00:36:26,050 --> 00:36:27,975
et votre serveur est toujours en cours d'exécution,

462
00:36:27,975 --> 00:36:30,650
et il retournera une valeur vide ici.

463
00:36:30,650 --> 00:36:34,465
Donc, nous avons vu comment en modifiant

464
00:36:34,465 --> 00:36:40,900
notre serveur API REST pour être en mesure d'interagir avec le serveur MongoDB.

465
00:36:40,900 --> 00:36:45,775
Nous avons maintenant un serveur d'API REST à part entière qui est capable de stocker

466
00:36:45,775 --> 00:36:48,090
, récupérer et effectuer diverses opérations

467
00:36:48,090 --> 00:36:51,220
sur les données stockées sur mon serveur MongoDB.

468
00:36:51,220 --> 00:36:54,535
Avec cela, nous terminons cet exercice.

469
00:36:54,535 --> 00:36:56,290
Donc, dans cet exercice,

470
00:36:56,290 --> 00:37:05,200
nous avons vu comment nous sommes capables d'interagir avec notre serveur API REST

471
00:37:05,200 --> 00:37:07,560
, et à son tour, avec le serveur MongoDB,

472
00:37:07,560 --> 00:37:12,400
puis nous exploitons le serveur MongoDB pour stocker et récupérer des données du serveur.

473
00:37:12,400 --> 00:37:14,770
Vous pouvez interagir depuis

474
00:37:14,770 --> 00:37:20,225
notre application Express avec le serveur MongoDB en utilisant Mongoose.

475
00:37:20,225 --> 00:37:24,700
C' est le bon moment pour vous de faire un commit GIT avec le message

476
00:37:24,700 --> 00:37:31,550
« Express REST API with Mongoose Part One ».