1
00:00:03,710 --> 00:00:10,135
Il s'agit de la deuxième partie de l'Exercice Express Sessions.

2
00:00:10,135 --> 00:00:12,320
Nous avons terminé la première partie plus tôt,

3
00:00:12,320 --> 00:00:15,310
où nous avons ajouté la prise en charge des

4
00:00:15,310 --> 00:00:20,340
sessions Express, et nous utilisons les sessions Express comme moyen de suivre les utilisateurs côté serveur

5
00:00:20,340 --> 00:00:24,160
et de reconnaître les demandes entrantes des utilisateurs.

6
00:00:24,160 --> 00:00:30,930
Dans cet exercice, nous ne nous concentrons pas tellement sur les sessions Express elles-mêmes,

7
00:00:30,930 --> 00:00:36,605
mais nous chercherons un moyen d'étendre notre serveur API REST express

8
00:00:36,605 --> 00:00:42,435
pour prendre en charge un nouveau modèle d'enregistrement et d'authentification des utilisateurs.

9
00:00:42,435 --> 00:00:48,635
Nous allons donc introduire un nouveau modèle d'utilisateur et un nouveau schéma dans notre application.

10
00:00:48,635 --> 00:00:52,295
Nous avons déjà la route des utilisateurs slash que

11
00:00:52,295 --> 00:00:57,290
le générateur express a déjà monté le routeur d'un utilisateur.

12
00:00:57,290 --> 00:01:00,035
Donc, nous allons tirer parti de cela, puis mettre à jour cela

13
00:01:00,035 --> 00:01:03,205
pour prendre en charge l'enregistrement de nouveaux utilisateurs, l'

14
00:01:03,205 --> 00:01:05,390
authentification d'un utilisateur existant,

15
00:01:05,390 --> 00:01:11,695
et également la déconnexion d'un utilisateur de notre site serveur.

16
00:01:11,695 --> 00:01:17,915
Par conséquent, nous allons examiner les sessions Express comme un moyen de suivre les utilisateurs une fois que l'utilisateur se connecte,

17
00:01:17,915 --> 00:01:19,820
puis lorsque l'utilisateur se déconnecte,

18
00:01:19,820 --> 00:01:22,680
la session sera supprimée du système.

19
00:01:22,680 --> 00:01:27,480
Alors, comment pouvons-nous faire cette extension dans cet exercice ?

20
00:01:27,480 --> 00:01:29,700
Allons le découvrir.

21
00:01:29,800 --> 00:01:35,485
En continuant avec notre serveur d'API REST express,

22
00:01:35,485 --> 00:01:41,835
allons maintenant dans les modèles et ajoutons un nouveau fichier nommé user.js.

23
00:01:41,835 --> 00:01:46,440
C' est le fichier où nous allons créer le schéma utilisateur et le modèle.

24
00:01:46,440 --> 00:01:51,405
Nous allons créer un schéma utilisateur simple qui suit le nom d'utilisateur et le mot de passe,

25
00:01:51,405 --> 00:01:55,520
ainsi qu'un indicateur qui est défini pour indiquer

26
00:01:55,520 --> 00:01:59,540
si l'utilisateur est un administrateur ou un utilisateur normal.

27
00:01:59,540 --> 00:02:03,660
Donc, c'est une façon de distinguer les différents types d'utilisateurs.

28
00:02:03,660 --> 00:02:07,210
Donc, dans ce fichier, nous

29
00:02:07,210 --> 00:02:16,510
allons d'abord exiger Mongoose parce que nous créons un schéma Mongoose,

30
00:02:16,510 --> 00:02:26,710
puis nous allons créer un schéma nommé schéma Mongoose,

31
00:02:26,710 --> 00:02:29,720
puis nous allons dire utilisateur var.

32
00:02:29,720 --> 00:02:32,870
C' est donc le schéma utilisateur que nous allons créer,

33
00:02:32,870 --> 00:02:38,150
et nous allons dire nouveau schéma utilisateur.

34
00:02:38,150 --> 00:02:42,740
Le schéma utilisateur sera défini comme je viens de le mentionner,

35
00:02:42,740 --> 00:02:47,705
avec trois champs ici appelés nom d'utilisateur

36
00:02:47,705 --> 00:02:55,755
qui serait évidemment de la chaîne de type,

37
00:02:55,755 --> 00:02:59,290
et c'est un champ obligatoire,

38
00:02:59,290 --> 00:03:03,975
et c'est un champ unique.

39
00:03:03,975 --> 00:03:07,580
Vous ne voulez pas deux utilisateurs avec le même nom d'utilisateur dans votre système,

40
00:03:07,580 --> 00:03:12,810
donc nous créons le nom d'utilisateur et ensuite le deuxième champ est le champ mot de passe.

41
00:03:12,810 --> 00:03:15,259
Maintenant, bien sûr, vous pouvez étendre

42
00:03:15,259 --> 00:03:19,820
ce schéma utilisateur pour permettre à l'utilisateur de suivre son profil entier,

43
00:03:19,820 --> 00:03:23,985
mais nous le ferons dans l'un des exercices ultérieurs, pour le moment,

44
00:03:23,985 --> 00:03:30,604
un utilisateur est reconnu dans le système par simplement le nom d'utilisateur et le mot de passe.

45
00:03:30,604 --> 00:03:36,290
Ainsi, le mot de passe est de la chaîne de type et est ensuite requis.

46
00:03:37,300 --> 00:03:44,320
Le troisième champ que je vais utiliser est appelé l'admin.

47
00:03:44,320 --> 00:03:48,025
Donc, l'administrateur est du type booléen,

48
00:03:48,025 --> 00:03:58,270
et nous dirons false par défaut.

49
00:03:58,270 --> 00:04:02,905
Ainsi, par défaut, lorsqu'un utilisateur est créé,

50
00:04:02,905 --> 00:04:04,830
un nouvel utilisateur est créé,

51
00:04:04,830 --> 00:04:06,855
l'indicateur admin sera défini sur false.

52
00:04:06,855 --> 00:04:09,925
Vous pouvez définir explicitement la valeur true à partir de

53
00:04:09,925 --> 00:04:14,605
votre code afin de marquer un utilisateur en tant qu'utilisateur administratif.

54
00:04:14,605 --> 00:04:18,460
Peut-être pourriez-vous fournir des privilèges supplémentaires à un utilisateur administratif,

55
00:04:18,460 --> 00:04:21,230
ou peut-être autoriser l'utilisateur administrateur à effectuer

56
00:04:21,230 --> 00:04:24,810
certaines opérations que les utilisateurs normaux ne le feraient pas.

57
00:04:24,810 --> 00:04:27,760
Nous allons regarder cela dans l'un des exercices ultérieurs,

58
00:04:27,760 --> 00:04:31,500
pour le moment, c'est le schéma utilisateur que nous avons créé,

59
00:04:31,500 --> 00:04:38,150
créons un module à partir de cela et exportons à partir de

60
00:04:38,150 --> 00:04:47,075
ce module un modèle Mongoose de l'utilisateur nom.

61
00:04:47,075 --> 00:04:51,115
Donc, c'est le modèle Mongoose et le schéma est

62
00:04:51,115 --> 00:04:55,840
le schéma utilisateur que nous venons de définir un peu plus tôt.

63
00:04:55,840 --> 00:05:00,615
Donc, c'est ainsi que nous définissons notre schéma utilisateur.

64
00:05:00,615 --> 00:05:03,770
Donc, maintenant que nous avons défini notre schéma utilisateur,

65
00:05:03,770 --> 00:05:08,660
allons dans le routeur qui a déjà été configuré

66
00:05:08,660 --> 00:05:15,610
par le générateur express lorsqu'il génère cette application express.

67
00:05:15,610 --> 00:05:17,775
Donc, si vous allez dans le dossier routes,

68
00:05:17,775 --> 00:05:20,890
vous verrez ce fichier appelé users.js.

69
00:05:20,890 --> 00:05:26,780
Donc, ce fichier users.js sera étendu pour créer le routeur.

70
00:05:26,780 --> 00:05:36,720
Donc, juste là ce que je vais faire est d'importer l'analyseur de corps,

71
00:05:41,510 --> 00:05:46,395
puis ils vont déclarer le routeur express,

72
00:05:46,395 --> 00:05:50,145
et puis nous dirons également importer

73
00:05:50,145 --> 00:05:57,100
le schéma utilisateur et le

74
00:05:57,100 --> 00:06:03,420
modèle de l'utilisateur de modèles utilisateur,

75
00:06:03,950 --> 00:06:09,220
puis pour le routeur express, nous dirons,

76
00:06:09,220 --> 00:06:13,380
routeur utiliser l'analyseur de corps.

77
00:06:16,190 --> 00:06:20,690
Donc, maintenant que nous avons déclaré l'analyseur de corps là-dedans,

78
00:06:20,690 --> 00:06:23,650
nous allons laisser cette partie en tant que telle,

79
00:06:23,650 --> 00:06:28,040
plus tard nous allons modifier ceci pour permettre

80
00:06:28,040 --> 00:06:30,470
à l'administrateur de pouvoir récupérer

81
00:06:30,470 --> 00:06:33,750
tous les utilisateurs qui sont enregistrés dans le système mais pour le moment,

82
00:06:33,750 --> 00:06:37,705
nous allons quitter cette route en tant que telle.

83
00:06:37,705 --> 00:06:40,500
Nous allons ajouter quelques autres routes ici,

84
00:06:40,500 --> 00:06:42,965
donc nous allons dire, « Poste de routeur ».

85
00:06:42,965 --> 00:06:49,970
Nous prendrons donc en charge la post-opération sur un itinéraire appelé inscription et comme vous vous y attendez,

86
00:06:49,970 --> 00:06:55,790
cette route d'inscription permettra à un utilisateur de s'

87
00:06:55,790 --> 00:07:04,920
inscrire sur le système, donc cela prendra en charge l'inscription de l'utilisateur.

88
00:07:04,920 --> 00:07:08,355
Donc, nous allons dire, « Rec, res, suivant. »

89
00:07:08,355 --> 00:07:16,090
Et donc ce serait l'inscription de post routeur,

90
00:07:16,590 --> 00:07:23,410
les méthodes restantes ne seront pas autorisées sur la partie de fin d'inscription.

91
00:07:23,410 --> 00:07:25,865
Donc, pour y accéder,

92
00:07:25,865 --> 00:07:31,420
puisque ce routeur d'utilisateurs est monté sur les utilisateurs de barre oblique,

93
00:07:31,420 --> 00:07:35,645
nous spécifierons ce point de terminaison comme slash utilisateurs slash sup,

94
00:07:35,645 --> 00:07:41,765
et c'est le point final qui sera utilisé pour inscrire de nouveaux utilisateurs dans le système.

95
00:07:41,765 --> 00:07:45,080
Donc, la première chose que nous allons faire est d'utiliser

96
00:07:45,080 --> 00:07:53,300
la méthode utilisateur et l'attente est que pour un utilisateur de s'inscrire,

97
00:07:53,300 --> 00:07:58,145
le nom d'utilisateur et le mot de passe seront fournis sous la forme d'une chaîne JSON

98
00:07:58,145 --> 00:08:03,185
dans le corps de la demande de publication entrante.

99
00:08:03,185 --> 00:08:05,160
Donc, à partir du corps,

100
00:08:05,160 --> 00:08:09,200
puisque le corps aurait déjà été analysé par l'analyseur de corps,

101
00:08:09,200 --> 00:08:10,370
donc à partir du corps,

102
00:08:10,370 --> 00:08:13,920
vérifiera d'abord que

103
00:08:13,920 --> 00:08:22,130
l'utilisateur avec ce nom d'utilisateur n'existe pas dans le système.

104
00:08:22,130 --> 00:08:24,380
Si l'utilisateur avec ce nom d'utilisateur existe,

105
00:08:24,380 --> 00:08:26,900
vous essayez d'inscrire un utilisateur en double

106
00:08:26,900 --> 00:08:29,715
et cela ne devrait pas être autorisé dans le système.

107
00:08:29,715 --> 00:08:37,340
Donc, nous allons dire, « Les utilisateurs en trouvent un », puis nous allons essayer de trouver s'

108
00:08:37,340 --> 00:08:41,090
il y a un utilisateur avec le nom d'utilisateur qui a été

109
00:08:41,090 --> 00:08:45,405
sélectionné par le client qui essaie d'inscrire un nouvel utilisateur.

110
00:08:45,405 --> 00:08:47,020
Si l'utilisateur existe déjà,

111
00:08:47,020 --> 00:08:51,850
il est évident que vous n'autorisez pas le nouvel utilisateur à s'inscrire avec le même nom d'utilisateur.

112
00:08:51,850 --> 00:08:55,665
Donc, nous allons dire, « Alors utilisateur. »

113
00:08:55,665 --> 00:09:03,295
Donc, cela retournera l'utilisateur ici et à l'intérieur de ce champ utilisateur,

114
00:09:03,295 --> 00:09:09,080
alors nous allons vérifier le fait que l'utilisateur existe déjà,

115
00:09:09,080 --> 00:09:12,350
puis laissez-moi attraper l'erreur ici.

116
00:09:12,350 --> 00:09:19,140
Donc, nous allons dire, « Attraper erreur », puis, « prochaine erreur ».

117
00:09:19,140 --> 00:09:26,160
Donc, nous allons simplement le transmettre au gestionnaire d'erreurs là-bas.

118
00:09:26,160 --> 00:09:33,345
Donc, si cette recherche pour l'utilisateur renvoie le champ utilisateur,

119
00:09:33,345 --> 00:09:40,460
si l'utilisateur n'est pas égal à null.

120
00:09:40,460 --> 00:09:45,170
Donc, si l'utilisateur qui est renvoyé par cette recherche

121
00:09:45,170 --> 00:09:50,510
n'est pas nul, cela signifie que l'utilisateur avec ce nom d'utilisateur donné existe déjà,

122
00:09:50,510 --> 00:09:53,420
donc vous ne devriez pas autoriser une inscription en double.

123
00:09:53,420 --> 00:09:58,765
Donc, nous allons dire, « Var err nouvelle erreur. »

124
00:09:58,765 --> 00:10:09,075
Et nous dirons, « Nom d'utilisateur req. body. »

125
00:10:09,075 --> 00:10:15,410
Existe déjà. Donc, fondamentalement,

126
00:10:15,410 --> 00:10:20,565
vous empêchez un utilisateur en double de s'inscrire, puis nous dirons

127
00:10:20,565 --> 00:10:29,280
err.status 403 par rapport à l'interdit, puis quitterons,

128
00:10:29,280 --> 00:10:33,735
appelant le gestionnaire d'erreur, prochaine erreur.

129
00:10:33,735 --> 00:10:36,880
Sinon, cela signifie que l'utilisateur n'existe pas

130
00:10:36,880 --> 00:10:39,670
, donc vous devriez autoriser l'utilisateur à être approuvé.

131
00:10:39,670 --> 00:10:41,950
Donc, dans la partie autre,

132
00:10:41,950 --> 00:10:46,150
nous allons dire, retourner User.create ().

133
00:10:47,200 --> 00:10:56,165
Nous allons créer un nouvel utilisateur avec le nom d'utilisateur défini sur req.body.username,

134
00:10:56,165 --> 00:11:02,555
puis laissez-moi le mettre dans la ligne suivante afin que ce soit plus clair pour vous,

135
00:11:02,555 --> 00:11:09,620
et nous dirons mot de passe : req.body.password.

136
00:11:09,620 --> 00:11:14,550
Maintenant, nous savons déjà que l'indicateur admin par défaut sera défini sur false,

137
00:11:14,550 --> 00:11:17,700
donc nous allons le laisser en tant que tel,

138
00:11:17,730 --> 00:11:28,175
et cela permettra à notre nouvel utilisateur d'être inscrit et lorsque le nouvel utilisateur sera inscrit,

139
00:11:28,175 --> 00:11:37,880
cela retournera une promesse et à l'intérieur du « puis » nous gérerons cette promesse ici.

140
00:11:37,880 --> 00:11:41,460
Donc, cela va retourner la promesse de

141
00:11:41,460 --> 00:11:45,625
ce « puis » et ensuite nous allons la gérer dans le prochain « puis » ici.

142
00:11:45,625 --> 00:12:02,120
Dire alors, RES.statusCode est 200,

143
00:12:02,120 --> 00:12:10,640
RES.setHeader et nous dirons application/json de type de contenu

144
00:12:19,830 --> 00:12:38,000
et nous dirons, res.json (statut : Enregistrement réussi),

145
00:12:42,960 --> 00:12:45,760
et si vous voulez,

146
00:12:45,760 --> 00:12:49,659
nous pouvons charger l'utilisateur dans

147
00:12:49,659 --> 00:12:58,270
ce message de réponse ici comme une propriété dans le json.

148
00:13:02,790 --> 00:13:06,890
Sera que l'inscription a réussi.

149
00:13:07,830 --> 00:13:14,950
Ensuite, s'il y a une erreur dans

150
00:13:14,950 --> 00:13:22,790
cette opération dira « prochaine erreur ».

151
00:13:22,790 --> 00:13:25,200
Donc, cela va gérer l'erreur.

152
00:13:25,440 --> 00:13:29,220
Si la promesse ne résout pas avec succès,

153
00:13:29,220 --> 00:13:32,020
alors sera gérée par cela. Alors c'est tout.

154
00:13:32,020 --> 00:13:36,150
Donc, ici, nous avons un moyen pour l'utilisateur de s'inscrire.

155
00:13:36,150 --> 00:13:38,280
Ainsi, pour que l'utilisateur s'inscrive,

156
00:13:38,280 --> 00:13:46,570
l'utilisateur fera un post sur /users/inscription et dans le corps du message,

157
00:13:46,570 --> 00:13:51,810
le client inclura une chaîne json

158
00:13:51,810 --> 00:13:57,760
avec les propriétés de nom d'utilisateur et de mot de passe dans cette chaîne json.

159
00:13:57,760 --> 00:14:01,200
C' est ainsi que vous vous inscrivez pour un nouvel utilisateur.

160
00:14:01,200 --> 00:14:06,135
Maintenant, voyons comment nous allons nous connecter à l'utilisateur.

161
00:14:06,135 --> 00:14:14,605
Maintenant, nous allons toujours utiliser les sessions Express que nous avons faites plus tôt pour suivre l'utilisateur.

162
00:14:14,605 --> 00:14:24,270
Donc, pour la journalisation, un utilisateur dira « router.post » sur le point de fin/login.

163
00:14:24,820 --> 00:14:29,370
Donc, sur le point de terminaison /login,

164
00:14:32,280 --> 00:14:35,800
nous allons faire un router.post.

165
00:14:35,800 --> 00:14:42,460
Nous allons évidemment au lieu de dire la fonction,

166
00:14:42,460 --> 00:14:48,575
vous pouvez utiliser la fonction flèche ici pour le router.post,

167
00:14:48,575 --> 00:14:50,780
je vais faire la même chose ici.

168
00:14:50,780 --> 00:14:53,930
J' ai aimé les fonctions de flèche.

169
00:14:53,930 --> 00:14:57,125
Donc, nous allons faire une fonction de flèche ici.

170
00:14:57,125 --> 00:15:00,080
Donc, pour la connexion, comment se déroule la connexion ?

171
00:15:00,080 --> 00:15:01,880
Donc, pour la connexion,

172
00:15:01,880 --> 00:15:10,850
ce que nous allons faire est que nous allons aller au fichier app.js et puis à l'intérieur de cette authentification,

173
00:15:11,760 --> 00:15:17,050
nous faisions cela s'inscrire pour l'utilisateur là-bas.

174
00:15:17,050 --> 00:15:20,315
Donc, ce que je vais faire, c'est que je vais copier

175
00:15:20,315 --> 00:15:25,730
tout ça parce que je ne ferais pas tout ça de toute façon.

176
00:15:25,730 --> 00:15:32,970
Donc, plutôt laissez-moi copier tout le chemin à partir de ce point jusqu'au req.session.user.

177
00:15:32,970 --> 00:15:36,925
Donc, la partie si de req.session.user je vais copier,

178
00:15:36,925 --> 00:15:44,120
puis venir au users.js et pour la connexion.

179
00:15:44,120 --> 00:15:47,305
C' est exactement comme ça que je vais faire l'authentification.

180
00:15:47,305 --> 00:15:51,025
Donc, nous allons dire si ce n'est pas req.session.user.

181
00:15:51,025 --> 00:15:55,965
Cela signifie donc que l'utilisateur ne s'est pas encore authentifié lui-même.

182
00:15:55,965 --> 00:15:59,420
Ensuite, vous vous attendez à l'authentification de base comme

183
00:15:59,420 --> 00:16:02,780
un mécanisme que l'utilisateur doit utiliser pour l'authentification.

184
00:16:02,780 --> 00:16:07,890
Donc, nous allons dire var AuthHeader si ! AuthHeader alors nous allons soulever l'erreur,

185
00:16:07,890 --> 00:16:17,760
sinon nous allons récupérer le nom d'utilisateur et le mot de passe de l'en-tête.

186
00:16:17,760 --> 00:16:25,235
Maintenant, ici, nous faisions si le nom d'utilisateur est égal à admin et mot de passe est égal à mot de passe.

187
00:16:25,235 --> 00:16:30,535
Mais maintenant, nous allons faire une recherche dans

188
00:16:30,535 --> 00:16:36,695
la base de données pour voir si cet utilisateur en particulier existe.

189
00:16:36,695 --> 00:16:39,595
Donc, au lieu de le faire ici,

190
00:16:39,595 --> 00:16:42,995
au lieu de le faire si le nom d'utilisateur et le mot de passe,

191
00:16:42,995 --> 00:16:48,380
nous dirons, user.findone

192
00:16:49,650 --> 00:16:56,020
et nous dirons que le nom d'utilisateur est le nom d'utilisateur.

193
00:16:56,020 --> 00:17:00,730
Donc, cette propriété est égale à ce nom d'utilisateur que nous venons de récupérer

194
00:17:00,730 --> 00:17:06,820
et puis nous dirons alors utilisateur.

195
00:17:09,770 --> 00:17:18,600
Donc, à l'intérieur de ce « puis ».

196
00:17:18,600 --> 00:17:23,110
Donc, je vais déplacer ce code dans ce « puis » parce que

197
00:17:23,110 --> 00:17:28,395
maintenant ce que je vais vérifier est maintenant que j'ai récupéré l'utilisateur,

198
00:17:28,395 --> 00:17:35,625
je dois vérifier pour m'assurer que cet utilisateur est exactement ce que je cherche.

199
00:17:35,625 --> 00:17:37,405
Donc, à ce stade,

200
00:17:37,405 --> 00:17:42,485
nous allons d'abord vérifier que l'utilisateur n'est pas nul.

201
00:17:42,485 --> 00:17:49,915
Donc, nous dirons si l'utilisateur est nul.

202
00:17:49,915 --> 00:17:51,390
Donc, si l'utilisateur est nul,

203
00:17:51,390 --> 00:17:55,930
ce qui signifie que nous ne pouvions pas trouver un utilisateur avec ce nom d'utilisateur particulier.

204
00:17:55,930 --> 00:17:59,860
Donc, vous devrez retourner une erreur ici.

205
00:17:59,860 --> 00:18:04,540
Alors laissez-moi juste copier cette partie et puis collez-la

206
00:18:04,540 --> 00:18:09,840
ici et puis nous reviendrons dire var nouvelle erreur

207
00:18:09,840 --> 00:18:14,575
et nous dirons que le nom

208
00:18:14,575 --> 00:18:23,120
d'utilisateur de l'espace utilisateur

209
00:18:23,580 --> 00:18:28,750
n'existe pas.

210
00:18:28,750 --> 00:18:30,600
Donc, dans ce cas,

211
00:18:30,600 --> 00:18:35,230
cet utilisateur n'existe pas donc je vais juste supprimer cette partie et

212
00:18:35,230 --> 00:18:41,840
alors le statut d'erreur correspondant serait 403 ici.

213
00:18:42,450 --> 00:18:44,960
C' est donc la première partie.

214
00:18:44,960 --> 00:18:55,000
Si l'utilisateur est nul alors nous allons évidemment dire que l'utilisateur n'existe pas.

215
00:18:55,000 --> 00:19:03,780
La deuxième partie que nous allons vérifier est Else si mot de passe utilisateur.

216
00:19:03,780 --> 00:19:06,800
Donc, ce qui signifie que l'utilisateur existe à ce stade.

217
00:19:06,800 --> 00:19:12,420
Donc, la deuxième vérification que nous allons faire est que le mot de passe de l'utilisateur n'est pas

218
00:19:12,420 --> 00:19:22,330
égal à mot de passe alors.

219
00:19:22,330 --> 00:19:25,090
Nous devons à nouveau indiquer l'erreur là.

220
00:19:25,090 --> 00:19:28,820
Donc, l'erreur serait de dire,

221
00:19:29,790 --> 00:19:34,570
dans ce cas, nous dirons

222
00:19:34,570 --> 00:19:41,390
« votre mot de passe est incorrect ».

223
00:19:41,390 --> 00:19:44,085
Donc c'est la deuxième partie ici.

224
00:19:44,085 --> 00:19:49,650
Donc votre mot de passe est incorrect, puis la dernière partie.

225
00:19:49,650 --> 00:19:52,515
Nous dirons « autre ».

226
00:19:52,515 --> 00:19:59,755
Alors laissez-moi mettre en retrait ce code.

227
00:19:59,755 --> 00:20:05,775
Donc, sinon si

228
00:20:05,775 --> 00:20:15,815
user.username est un nom d'utilisateur qui devrait évidemment être vrai dans ce cas.

229
00:20:15,815 --> 00:20:17,990
Ensuite, la deuxième partie,

230
00:20:17,990 --> 00:20:27,620
user.password est égale au mot de passe qui devrait également être correct à ce stade.

231
00:20:27,620 --> 00:20:29,720
Mais en tout cas,

232
00:20:29,720 --> 00:20:38,885
je vais vérifier ce problème ici et cela ne se produira pas du tout dans ce cas.

233
00:20:38,885 --> 00:20:41,695
Donc, au moment où vous atteignez ce point,

234
00:20:41,695 --> 00:20:45,410
le nom d'utilisateur devrait être le

235
00:20:45,410 --> 00:20:48,980
même que le nom d'utilisateur et le mot de passe devrait être le même qu'un mot de passe,

236
00:20:48,980 --> 00:20:55,240
mais en tout cas j'ai mis dans une double vérification à ce stade juste pour être doublement sûr.

237
00:20:55,240 --> 00:20:56,590
Ensuite, dans ce cas,

238
00:20:56,590 --> 00:21:02,765
nous dirons que req.session.user est authentifié.

239
00:21:02,765 --> 00:21:05,440
Donc, nous allons définir ceci sur authentifié

240
00:21:05,440 --> 00:21:16,480
et aussi celui-ci, nous dirons que

241
00:21:16,480 --> 00:21:18,660
RES.StatusCode est 200.

242
00:21:18,660 --> 00:21:21,870
Nous avons donc réussi à authentifier l'utilisateur.

243
00:21:21,870 --> 00:21:29,030
Donc, nous dirons que RES.StatusCode est 200, puis nous dirons Res.setHeader

244
00:21:30,540 --> 00:21:43,690
Content-Type texte plain et

245
00:21:43,690 --> 00:21:51,500
res.end, nous allons simplement envoyer un message disant « Vous êtes authentifié ».

246
00:21:53,700 --> 00:22:00,825
C' est ça. Donc, cela couvre la partie alors de l'utilisateur finDone.

247
00:22:00,825 --> 00:22:05,360
Donc, d'abord, nous vérifions que si l'utilisateur est nul,

248
00:22:05,360 --> 00:22:07,410
cela signifie que nous n'avons pas pu trouver l'utilisateur,

249
00:22:07,410 --> 00:22:12,025
donc nous retournons évidemment une erreur indiquant que le nom d'utilisateur n'existe pas.

250
00:22:12,025 --> 00:22:15,195
Si le mot de passe de l'utilisateur ne correspond pas au mot de passe,

251
00:22:15,195 --> 00:22:16,450
donc à ce stade,

252
00:22:16,450 --> 00:22:19,150
l'utilisateur existe mais le mot de passe ne correspond pas, donc nous allons dire,

253
00:22:19,150 --> 00:22:22,640
« Votre mot de passe est incorrect », et puis, enfin,

254
00:22:22,640 --> 00:22:29,050
nous atteignons ce point alors le nom d'utilisateur et le mot de passe doivent être correctement identifiés.

255
00:22:29,330 --> 00:22:35,780
Bien que je n'ai pas besoin de cette vérification, mais je l'ai juste mis en place et puis à ce stade,

256
00:22:35,780 --> 00:22:38,680
je vais définir le req.session.user pour l'authentifier,

257
00:22:38,680 --> 00:22:41,830
puis définir le code d'état sur 200 ce qui signifie que vous avez

258
00:22:41,830 --> 00:22:48,880
réussi à authentifier l'utilisateur et ensuite vous pouvez terminer à ce stade.

259
00:22:48,880 --> 00:22:51,490
Parce que c'est un alors,

260
00:22:51,490 --> 00:22:54,685
je vais mettre un catch à ce stade,

261
00:22:54,685 --> 00:23:03,845
donc nous allons dire catch error et si l'erreur se produit,

262
00:23:03,845 --> 00:23:09,130
alors je vais simplement passer

263
00:23:09,130 --> 00:23:14,560
l'erreur à

264
00:23:14,560 --> 00:23:20,090
la suivante afin que le gestionnaire d'erreur puisse traiter l'erreur correctement.

265
00:23:20,090 --> 00:23:24,415
Donc, cela se termine cet utilisateur finDone.

266
00:23:24,415 --> 00:23:31,020
Maintenant, c'est le cas lorsque req.session.user n'est pas défini.

267
00:23:31,020 --> 00:23:32,905
Si cela est déjà défini,

268
00:23:32,905 --> 00:23:38,095
cela signifie que l'utilisateur est déjà connecté.

269
00:23:38,095 --> 00:23:40,630
Donc, dans ce cas,

270
00:23:40,630 --> 00:23:50,650
l'autre partie traite ici de la situation en disant que nous allons définir

271
00:23:50,650 --> 00:23:52,660
le StatusCode sur 200

272
00:23:52,660 --> 00:24:12,205
et le Content-Type sur text/plain, puis nous dirons,

273
00:24:12,205 --> 00:24:17,680
« Vous êtes déjà authentifié. »

274
00:24:17,680 --> 00:24:21,910
Donc, si vous atteignez cette autre partie,

275
00:24:22,690 --> 00:24:29,060
vous viendrez ici parce que req.session.user n'est pas déjà null,

276
00:24:29,060 --> 00:24:32,150
ce qui signifie que l'utilisateur a déjà été authentifié, ce

277
00:24:32,150 --> 00:24:34,995
qui signifie que lorsque vous atteignez ce point,

278
00:24:34,995 --> 00:24:38,200
l'utilisateur s'est déjà connecté plus tôt,

279
00:24:38,200 --> 00:24:41,100
donc vous n'avez pas besoin de vérifier.

280
00:24:41,100 --> 00:24:42,220
Donc, vous allez simplement dire,

281
00:24:42,220 --> 00:24:46,270
« Vous êtes déjà authentifié », puis terminer à ce stade.

282
00:24:46,270 --> 00:24:54,975
D' accord. Donc maintenant, la dernière méthode que nous allons implémenter est de déconnecter l'utilisateur.

283
00:24:54,975 --> 00:24:59,180
Donc, nous allons faire un routeur .get sur /logout.

284
00:24:59,180 --> 00:25:02,170
Vous devez vous demander pourquoi on fait un get sur

285
00:25:02,170 --> 00:25:07,000
la déconnexion plutôt qu'un post que nous avons fait lors de la connexion ?

286
00:25:07,000 --> 00:25:11,090
Lors de la connexion, vous devez soumettre le nom d'utilisateur et le mot de passe.

287
00:25:11,090 --> 00:25:14,900
Pour la déconnexion, vous vous déconnectez simplement du système, de

288
00:25:14,900 --> 00:25:17,590
sorte que vous n'avez pas besoin de fournir d'autres informations car

289
00:25:17,590 --> 00:25:20,910
le serveur vous suit déjà en fonction de

290
00:25:20,910 --> 00:25:30,665
votre ID de session et à l'intérieur de ce cookie de session ici.

291
00:25:30,665 --> 00:25:32,620
C' est pourquoi nous n'avons pas

292
00:25:32,620 --> 00:25:38,890
explicitement besoin d'envoyer d'autres informations dans le corps du message.

293
00:25:38,890 --> 00:25:46,120
Donc, nous dirons si req.session donc ce qui signifie que la session doit exister

294
00:25:46,120 --> 00:25:50,070
, sinon, vous essayez de déconnecter un utilisateur qui ne s'est pas connecté.

295
00:25:50,070 --> 00:25:52,280
Donc ça n'a pas de sens.

296
00:25:52,280 --> 00:25:57,490
Maintenant, la session elle-même fournit cette méthode

297
00:25:57,490 --> 00:26:03,415
appelée destroy et lorsque vous appelez la méthode destroy,

298
00:26:03,415 --> 00:26:07,520
la session est détruite et les informations sont

299
00:26:07,520 --> 00:26:12,945
supprimées du côté serveur relatives à cette session.

300
00:26:12,945 --> 00:26:16,970
Donc, ce qui signifie que si le client essaie à nouveau d'envoyer

301
00:26:16,970 --> 00:26:19,190
les informations de session qui sont stockées sous la forme

302
00:26:19,190 --> 00:26:21,430
d'un cookie signé côté client,

303
00:26:21,430 --> 00:26:22,640
ce sera invalide.

304
00:26:22,640 --> 00:26:27,870
Nous avons donc besoin d'une méthode pour supprimer le cookie qui est stocké du côté client.

305
00:26:27,870 --> 00:26:31,110
Maintenant, cette opération supprimera

306
00:26:31,110 --> 00:26:36,805
les informations de session du côté serveur afin que la session ne soit plus valide.

307
00:26:36,805 --> 00:26:38,060
Donc, à ce stade,

308
00:26:38,060 --> 00:26:45,115
nous dirons req.session.destroy et ensuite nous dirons, RES.clearCookie.

309
00:26:45,115 --> 00:26:49,640
Ainsi, le ClearCookie est un moyen de demander au client de

310
00:26:49,640 --> 00:26:54,875
supprimer le cookie et le nom du cookie est l'ID de session.

311
00:26:54,875 --> 00:26:56,630
Ainsi, dans l'exercice précédent,

312
00:26:56,630 --> 00:27:00,910
nous avons vu que le cookie était stocké avec le nom de l'ID de session côté client.

313
00:27:00,910 --> 00:27:05,430
Nous demandons donc au client de supprimer ce cookie du

314
00:27:05,430 --> 00:27:10,935
côté client dans le message de réponse, puis nous dirons,

315
00:27:10,935 --> 00:27:16,835
res.redirect et nous allons le rediriger vers la page d'accueil ici.

316
00:27:16,835 --> 00:27:21,540
Donc, c'est une façon de rediriger l'utilisateur pour entrer dans sa page standard,

317
00:27:21,540 --> 00:27:24,790
donc par exemple, la page d'accueil de votre application.

318
00:27:24,790 --> 00:27:31,090
Donc, c'est la façon dont vous gérez la déconnexion du système.

319
00:27:31,090 --> 00:27:33,200
Si req.session n'existe pas,

320
00:27:33,200 --> 00:27:35,380
cela signifie que vous n'êtes pas connecté,

321
00:27:35,380 --> 00:27:37,310
donc nous devrons générer une erreur.

322
00:27:37,310 --> 00:27:38,945
Donc, nous allons dire var err,

323
00:27:38,945 --> 00:27:46,370
nouvelle erreur, « Vous n'êtes pas connecté »,

324
00:27:47,100 --> 00:27:52,615
et nous allons définir l'état d'erreur sur 403,

325
00:27:52,615 --> 00:27:54,760
c'est une opération interdite,

326
00:27:54,760 --> 00:28:01,060
puis générer l'erreur au gestionnaire d'erreur, c'est tout.

327
00:28:01,060 --> 00:28:08,830
Donc maintenant, vous voyez que nous avons étendu le routeur de l'utilisateur pour prendre en charge trois nouveaux terminaux,

328
00:28:08,830 --> 00:28:13,330
le point de terminaison d'inscription qui permet à un utilisateur de s'inscrire,

329
00:28:13,330 --> 00:28:17,785
le point de terminaison de connexion qui permet à un utilisateur inscrit de se connecter,

330
00:28:17,785 --> 00:28:24,730
puis le point de terminaison de déconnexion qui permet à un utilisateur connecté de se déconnecter du système.

331
00:28:24,730 --> 00:28:26,970
Dans le processus de déconnexion,

332
00:28:26,970 --> 00:28:29,340
vous détruisez la session côté serveur,

333
00:28:29,340 --> 00:28:31,890
vous effacez également le cookie côté client, de

334
00:28:31,890 --> 00:28:40,350
sorte que le client ne peut pas être utilisé dans la session expirée pour essayer de contacter ce serveur.

335
00:28:40,350 --> 00:28:43,480
Une correction mineure dans users.js,

336
00:28:43,480 --> 00:28:49,225
cela devrait être var User require.. /models/user,

337
00:28:49,225 --> 00:28:58,095
rappelez-vous que le fichier users.js se trouve dans le dossier routes, puis

338
00:28:58,095 --> 00:29:01,130
le fichier user.js se trouve dans

339
00:29:01,130 --> 00:29:07,440
le dossier models qui est d'un niveau, puis dans le dossier models.

340
00:29:07,440 --> 00:29:11,620
Donc, ça devrait être.. /models/user,

341
00:29:11,620 --> 00:29:15,655
alors faites cette correction mineure, c'est tout.

342
00:29:15,655 --> 00:29:19,040
Nous avons modifié le fichier users.js,

343
00:29:19,040 --> 00:29:23,690
maintenant la dernière chose que nous devons faire est d'aller réparer le fichier app.js.

344
00:29:23,690 --> 00:29:25,965
Dans le fichier app.js de l'application,

345
00:29:25,965 --> 00:29:29,520
si vous naviguez dans le fichier app.js,

346
00:29:29,520 --> 00:29:31,160
vous verrez que nous avons

347
00:29:31,160 --> 00:29:37,240
cet index barre oblique ici et slash utilisateurs ici après l'authentification.

348
00:29:37,240 --> 00:29:43,360
Maintenant, cela ne fonctionnera pas pour nous parce que si vous devez vous inscrire,

349
00:29:43,360 --> 00:29:49,140
alors l'utilisateur s'inscrirait et se connecterait avant que l'autorisation soit confirmée, de

350
00:29:49,140 --> 00:29:54,910
toute façon si l'inscription et la connexion sont pour le processus d'inscription,

351
00:29:54,910 --> 00:30:04,295
donc je vais les déplacer vers le haut avant l'étape d'authentification ici.

352
00:30:04,295 --> 00:30:09,280
Donc, nous allons déplacer ça à cet endroit.

353
00:30:09,280 --> 00:30:15,430
Ainsi, un utilisateur entrant peut accéder

354
00:30:15,430 --> 00:30:21,589
au fichier d'index à la barre oblique et également accéder au point de terminaison des utilisateurs sans être authentifié,

355
00:30:21,589 --> 00:30:23,205
mais tout autre point de terminaison,

356
00:30:23,205 --> 00:30:25,400
l'utilisateur doit être authentifié,

357
00:30:25,400 --> 00:30:28,665
donc c'est la façon dont nous avons configuré cela.

358
00:30:28,665 --> 00:30:32,375
À l'intérieur de l'authentification de la fonction, nous dirons,

359
00:30:32,375 --> 00:30:40,695
« Si ce n'est pas req.session.user », alors notez que cet endroit,

360
00:30:40,695 --> 00:30:47,980
nous ne permettrions pas à l'utilisateur de venir ici sans que l'utilisateur s'est connecté.

361
00:30:47,980 --> 00:30:50,450
Donc, si ce n'est pas req.session.user,

362
00:30:50,450 --> 00:30:55,170
alors nous dirions simplement que vous n'êtes pas authentifié.

363
00:31:03,600 --> 00:31:09,330
Cette authentification doit être effectuée en utilisant la méthode de connexion ici.

364
00:31:09,330 --> 00:31:13,510
Donc, je vais enlever toute cette partie ici.

365
00:31:17,340 --> 00:31:22,285
Donc, nous dirons, sinon req.session.user,

366
00:31:22,285 --> 00:31:28,670
nous dirons que vous n'êtes pas authentifié et nous devrons donc envoyer une photo trois ici, ce

367
00:31:28,670 --> 00:31:31,560
qui signifie que vous ne devriez jamais revenir à ce point du

368
00:31:31,560 --> 00:31:34,785
tout sans que l'utilisateur se connecte.

369
00:31:34,785 --> 00:31:37,575
Donc, nous dirons que vous n'êtes pas authentifié.

370
00:31:37,575 --> 00:31:41,990
Rappelez-vous que vous devez vous authentifier en effectuant un POST sur

371
00:31:41,990 --> 00:31:47,120
le point de fin de connexion des utilisateurs barre oblique.

372
00:31:47,120 --> 00:31:50,930
Donc, nous dirons que vous n'êtes pas authentifié, sinon,

373
00:31:50,930 --> 00:31:56,175
si req.session.user est égal à,

374
00:31:56,175 --> 00:32:01,720
rappelez-vous que dans la fonction de connexion dans le

375
00:32:01,720 --> 00:32:07,780
users.js, nous avons défini l'utilisateur de session suivante sur la chaîne authentifiée.

376
00:32:07,780 --> 00:32:10,055
C' est donc ce que nous allons vérifier.

377
00:32:10,055 --> 00:32:14,355
Nous dirons, si req.session.user est authentifié,

378
00:32:14,355 --> 00:32:21,955
nous dirons ensuite, sinon vous n'êtes pas authentifié à nouveau.

379
00:32:21,955 --> 00:32:31,990
Ensuite, nous enverrons un message interdit. C'est ça.

380
00:32:31,990 --> 00:32:33,995
Donc, avec cette mise à jour,

381
00:32:33,995 --> 00:32:36,375
mon fichier app.js est également prêt.

382
00:32:36,375 --> 00:32:38,590
Maintenant, après avoir fait ces mises à jour,

383
00:32:38,590 --> 00:32:42,470
allons vérifier comment fonctionne notre application maintenant.

384
00:32:42,470 --> 00:32:44,350
Aller au terminal,

385
00:32:44,350 --> 00:32:49,655
si votre serveur est en cours d'exécution, arrêtez-le, puis redémarrez votre serveur.

386
00:32:49,655 --> 00:32:51,600
Mon serveur ne fonctionne pas pour le moment,

387
00:32:51,600 --> 00:32:53,405
donc je vais dire npm start,

388
00:32:53,405 --> 00:32:56,440
et mon serveur devrait être opérationnel.

389
00:32:56,440 --> 00:33:00,540
Voyons maintenant comment nous allons accéder au serveur.

390
00:33:00,540 --> 00:33:04,150
Aller à Postman, laissez-moi faire un GET sur

391
00:33:04,150 --> 00:33:07,290
localhost : 3000/plats et puis vous verrez immédiatement

392
00:33:07,290 --> 00:33:10,375
qu'il se plaint en disant que vous n'êtes pas authentifié.

393
00:33:10,375 --> 00:33:13,095
Évidemment, je ne suis pas authentifié ici.

394
00:33:13,095 --> 00:33:19,560
Laissez-moi essayer d'accéder seulement au localhost : 3000 et vous verrez

395
00:33:19,560 --> 00:33:22,625
que, cette racine est disponible pour nous.

396
00:33:22,625 --> 00:33:29,850
Maintenant, bien sûr, nous voulons d'abord enregistrer un utilisateur, puis nous connecter en

397
00:33:29,850 --> 00:33:37,745
tant qu'utilisateur, puis obtenir l'accès au reste des points de terminaison de l'API REST.

398
00:33:37,745 --> 00:33:40,480
Donc, d'abord, laissez-moi enregistrer un utilisateur.

399
00:33:40,480 --> 00:33:41,925
Pour enregistrer l'utilisateur,

400
00:33:41,925 --> 00:33:51,410
j'ai besoin de faire un POST à l'hôte local:3000/users/inscription.

401
00:33:53,700 --> 00:33:57,710
Pour ce message POST,

402
00:33:57,930 --> 00:34:01,635
dans le corps du message,

403
00:34:01,635 --> 00:34:07,860
je dois inclure dans le corps

404
00:34:07,860 --> 00:34:15,080
du message une chaîne JSON avec le nom d'utilisateur.

405
00:34:15,080 --> 00:34:19,390
Donc, laissez-moi me connecter et

406
00:34:19,390 --> 00:34:27,770
ensuite je vais juste utiliser le mot de passe comme mot de passe.

407
00:34:28,810 --> 00:34:31,835
Il s'agit d'une inscription valide.

408
00:34:31,835 --> 00:34:35,505
Donc, lorsque je m'inscrit

409
00:34:35,505 --> 00:34:42,150
en tant qu'utilisateur avec cette information sous la forme d'une chaîne JSON incluse dans le corps du message,

410
00:34:42,150 --> 00:34:47,590
laissez-moi voir que l'en-tête contient maintenant l'application de type de contenu,

411
00:34:47,590 --> 00:34:50,440
JSON parce que j'ai configuré le JSON dans le corps du

412
00:34:50,440 --> 00:34:54,660
message, puis envoyer le POST à l'inscription.

413
00:34:54,660 --> 00:34:57,175
Ensuite, lorsque j'envoie le POST à l'inscription,

414
00:34:57,175 --> 00:35:02,460
vous voyez immédiatement ce qui est retourné par le serveur ici.

415
00:35:02,460 --> 00:35:05,630
Donc, vous voyez que le serveur est revenu en disant,

416
00:35:05,630 --> 00:35:10,205
« Enregistrement réussi » et lui-même,

417
00:35:10,205 --> 00:35:13,485
il me donne les détails de l'utilisateur ici.

418
00:35:13,485 --> 00:35:19,340
Donc, c'est un enregistrement qui existe dans mon MongoDB et

419
00:35:19,340 --> 00:35:25,090
notez que le type de modèle est le type de modèle utilisateur que nous avions configuré.

420
00:35:25,090 --> 00:35:28,300
Donc, nous avons le nom d'utilisateur et

421
00:35:28,300 --> 00:35:33,535
le mot de passe et l'indicateur admin comme vous pouvez le voir est défini sur false par défaut.

422
00:35:33,535 --> 00:35:37,285
Une fois que nous avons enregistré l'utilisateur,

423
00:35:37,285 --> 00:35:40,370
cet utilisateur est maintenant un utilisateur valide.

424
00:35:40,370 --> 00:35:45,640
Donc, laissez-moi essayer de nouveau POST le même utilisateur et voir ce qui se passe.

425
00:35:45,640 --> 00:35:48,935
Donc, quand je POST le même utilisateur évidemment,

426
00:35:48,935 --> 00:35:50,385
là du côté serveur,

427
00:35:50,385 --> 00:35:52,840
il répond en disant que cet utilisateur existe déjà.

428
00:35:52,840 --> 00:35:58,480
Ainsi, vous pouvez voir que nous avons mis en place notre procédure d'inscription pour ne pas permettre à

429
00:35:58,480 --> 00:36:04,580
l'utilisateur de dupliquer le registre avec le même ID utilisateur.

430
00:36:04,580 --> 00:36:07,135
D' accord. Donc, c'est la deuxième partie.

431
00:36:07,135 --> 00:36:13,570
Maintenant, faisons un login de l'utilisateur.

432
00:36:13,570 --> 00:36:15,770
Pour faire une connexion de l'utilisateur,

433
00:36:15,770 --> 00:36:20,400
laissez-moi supprimer le type de contenu, puis je vais également

434
00:36:20,400 --> 00:36:25,440
supprimer le corps parce que pour la connexion, ce n'est pas nécessaire.

435
00:36:25,440 --> 00:36:28,200
Donc, je ne remplit rien dans

436
00:36:28,200 --> 00:36:31,790
l'en-tête, puis essaie de me connecter et quand j'ai essayé de me connecter,

437
00:36:31,790 --> 00:36:34,805
il répond en disant que vous n'êtes pas authentifié.

438
00:36:34,805 --> 00:36:36,175
Vous êtes non autorisé.

439
00:36:36,175 --> 00:36:39,595
Maintenant, je dois me connecter.

440
00:36:39,595 --> 00:36:42,940
Donc, c'est là que je peux utiliser l'authentification de base.

441
00:36:42,940 --> 00:36:46,240
Donc, dans l'authentification de base,

442
00:36:46,240 --> 00:36:51,170
je vais juste taper mon nom d'utilisateur et mon mot de

443
00:36:51,170 --> 00:36:56,575
passe que je viens d'enregistrer à l'étape précédente, puis mettre à jour ma demande,

444
00:36:56,575 --> 00:37:00,060
puis faire un POST sur la connexion.

445
00:37:00,060 --> 00:37:02,400
Donc, quand je fais un POST sur la connexion,

446
00:37:02,400 --> 00:37:06,935
vous voyez que le serveur répond en disant, « Vous êtes authentifié ».

447
00:37:06,935 --> 00:37:08,740
Donc, à ce stade,

448
00:37:08,740 --> 00:37:11,400
je peux effectuer les

449
00:37:11,400 --> 00:37:16,115
requêtes GET, PUT, POST et DELETE sur tous les autres points de terminaison.

450
00:37:16,115 --> 00:37:26,370
Donc, à ce stade, si je fais un GET sur le point de terminaison des plats,

451
00:37:28,760 --> 00:37:32,675
vous verrez que cela renvoie

452
00:37:32,675 --> 00:37:39,160
le champ vide car ma base de données est actuellement vide.

453
00:37:39,160 --> 00:37:44,370
Permettez-moi d'effacer l'autorisation et aussi de l'en-tête supprimer

454
00:37:44,370 --> 00:37:49,575
l'autorisation, puis faire le GET et c'est la boîte à outils très bien.

455
00:37:49,575 --> 00:37:52,480
Donc, vous pouvez voir que je suis maintenant en mesure d'

456
00:37:52,480 --> 00:37:56,065
accéder aux points de terminaison parce que je me suis connecté.

457
00:37:56,065 --> 00:38:00,040
Alors maintenant, laissez-moi faire une déconnexion de l'utilisateur.

458
00:38:00,040 --> 00:38:05,910
Donc, nous allons dire, localhost : 3000 et déconnexion.

459
00:38:05,910 --> 00:38:08,875
Notez également que, dans les cookies,

460
00:38:08,875 --> 00:38:12,290
un cookie a été installé à l'ID de session juste là.

461
00:38:12,290 --> 00:38:17,080
Donc, ce cookie existe sur mon site client.

462
00:38:17,080 --> 00:38:22,715
Alors maintenant, laissez-moi me déconnecter en disant GET localhost : 3000/users/déconnexion.

463
00:38:22,715 --> 00:38:26,580
Donc, quand je fais une déconnexion de l'utilisateur,

464
00:38:26,580 --> 00:38:29,765
vous verrez immédiatement que je suis redirigé vers

465
00:38:29,765 --> 00:38:37,830
ce point de terminaison localhost:3000 et remarquerez également que le cookie a disparu.

466
00:38:37,830 --> 00:38:40,140
Donc, quand je regarde les cookies,

467
00:38:40,140 --> 00:38:42,040
vous voyez que le localhost,

468
00:38:42,040 --> 00:38:46,470
le cookie est parti parce que de mon côté serveur quand je fais la déconnexion,

469
00:38:46,470 --> 00:38:51,495
il renvoie un cookie clair de repos au côté client et donc le cookie est parti.

470
00:38:51,495 --> 00:38:54,555
Maintenant, si j'essaie de faire un GET

471
00:38:54,555 --> 00:39:02,480
sur le point de terminaison localhost:3000/plats,

472
00:39:02,480 --> 00:39:05,899
cela ne fonctionnera pas car je ne suis pas authentifié.

473
00:39:05,899 --> 00:39:11,610
Donc, cela vous montre comment vous pouvez étendre votre serveur Express pour

474
00:39:11,610 --> 00:39:17,190
permettre aux utilisateurs de s'enregistrer eux-mêmes, puis permettre à l'utilisateur de se connecter au système,

475
00:39:17,190 --> 00:39:19,860
puis également se déconnecter du système.

476
00:39:19,860 --> 00:39:25,520
Côté serveur, vous suivez un utilisateur connecté à l'aide de la session et en utilisant

477
00:39:25,520 --> 00:39:28,260
le cookie côté client et lorsque l'utilisateur

478
00:39:28,260 --> 00:39:31,375
se déconnecte, le cookie est détruit côté client.

479
00:39:31,375 --> 00:39:34,540
Avec cela, nous complétons cet exercice.

480
00:39:34,540 --> 00:39:37,390
C' est un bon moment pour vous de faire un commit Git,

481
00:39:37,390 --> 00:39:42,420
avec le message, les sessions Express deuxième partie.