1
00:00:03,950 --> 00:00:09,180
Agora que temos entendido passaporte e como passaporte adiciona

2
00:00:09,180 --> 00:00:14,294
em um middleware de autenticação simples para o nosso aplicativo NodeJS,

3
00:00:14,294 --> 00:00:18,435
e fornece uma

4
00:00:18,435 --> 00:00:22,935
maneira flexível fácil de configurar e fornece várias estratégias para autenticação de usuário,

5
00:00:22,935 --> 00:00:27,850
vamos em uma jornada com o nosso passaporte.

6
00:00:27,890 --> 00:00:31,020
Para começar este exercício,

7
00:00:31,020 --> 00:00:33,945
como primeiro passo, vamos instalar

8
00:00:33,945 --> 00:00:40,135
módulos de passaporte, passaporte-local e passaporte-local-mangusto em nosso servidor de confusão.

9
00:00:40,135 --> 00:00:44,030
Então, no prompt, digite npm instal_passport,

10
00:00:44,030 --> 00:00:49,820
passport-local,

11
00:00:49,820 --> 00:00:59,430
passaporte mnus local-mangusto menos salvar e instalar esses três módulos.

12
00:00:59,430 --> 00:01:05,980
Como você pode ver no momento, estamos começando com o passaporte 0.4.0,

13
00:01:05,980 --> 00:01:15,004
passaporte-local 1.0.0 e passaporte-local-mangusto 5.0.1 versões neste curso.

14
00:01:15,004 --> 00:01:20,110
Agora que instalamos passaporte, passaporte-local e passaporte-local-mangusto,

15
00:01:20,110 --> 00:01:25,640
vamos para o servidor de confusão e ir para o arquivo user.js.

16
00:01:25,640 --> 00:01:31,325
Vamos atualizar o esquema do usuário e modelo para usar o passport-local-mangusto.

17
00:01:31,325 --> 00:01:33,735
Para fazer isso, aqui vamos dizer

18
00:01:33,735 --> 00:01:41,060
var PassportLocalMongoose

19
00:01:41,060 --> 00:01:45,390
exigem passaporte-local-mangusto.

20
00:01:46,190 --> 00:01:50,330
Então isso vamos instalar como

21
00:01:50,330 --> 00:01:56,780
o plugin mangusto em nossa aplicação e podemos remover o nome de usuário e

22
00:01:56,780 --> 00:02:00,440
senha, porque estes seriam automaticamente adicionados

23
00:02:00,440 --> 00:02:04,535
pelo plugin passport-local-mangusto aqui e

24
00:02:04,535 --> 00:02:12,980
usar isso como um plugin em nosso esquema mangusto e modelo.

25
00:02:12,980 --> 00:02:20,160
Nós diremos que o usuário conecte e o passaporte local-mangusto.

26
00:02:20,160 --> 00:02:23,360
Então, isso será automaticamente como eu disse adicionando suporte para

27
00:02:23,360 --> 00:02:28,040
nome de usuário e armazenamento hash da senha usando

28
00:02:28,040 --> 00:02:33,305
o hash e salt e adicionando

29
00:02:33,305 --> 00:02:37,235
métodos adicionais no esquema do usuário

30
00:02:37,235 --> 00:02:40,880
e o modelo que são úteis para autenticação de passaporte.

31
00:02:40,880 --> 00:02:48,390
Então, uma vez que tenhamos concluído a atualização do arquivo user.js, em seguida, em nossa pasta do projeto,

32
00:02:48,390 --> 00:02:55,160
vamos criar um novo arquivo e nomeá-lo como authenticate.js.

33
00:02:55,160 --> 00:02:57,800
No arquivo authentic.js,

34
00:02:57,800 --> 00:03:03,420
deixe-me importar passaporte.

35
00:03:03,940 --> 00:03:10,700
Então, vamos dizer exigir passaporte e vamos

36
00:03:10,700 --> 00:03:16,700
usar este arquivo para armazenar as estratégias de autenticação que vamos configurar.

37
00:03:16,700 --> 00:03:26,195
Então vamos dizer var. LocalStrategy requer passaporte-local, de

38
00:03:26,195 --> 00:03:36,140
modo que o módulo local passaporte exporta uma estratégia que podemos usar para nossa aplicação.

39
00:03:36,140 --> 00:03:39,800
Então, vamos dizer Passport-local.Strategy

40
00:03:39,800 --> 00:03:56,700
e, em seguida, vamos importar usuário de modelos usuário.

41
00:03:58,550 --> 00:04:06,270
Vamos agora configurar o passaporte com a nova estratégia local

42
00:04:06,270 --> 00:04:13,970
e, em seguida, vamos exportar isso a partir deste arquivo porque este vai ser um módulo de nó.

43
00:04:13,970 --> 00:04:23,940
Então vamos dizer exports.local e vamos dizer passaporte e você

44
00:04:23,940 --> 00:04:28,580
pode ver que o passaporte suporta os vários métodos

45
00:04:28,580 --> 00:04:33,710
aqui, então vamos dizer uso de passaporte e dizer

46
00:04:33,710 --> 00:04:39,125
novo LocalStrategy e então é aqui que

47
00:04:39,125 --> 00:04:47,715
as funções que são suportadas pelo passaporte-local-mangusto vem em nossa ajuda.

48
00:04:47,715 --> 00:04:52,225
Assim, a estratégia local precisará ser fornecida com a função de verificação.

49
00:04:52,225 --> 00:04:55,210
Dentro desta função, verificamos o usuário.

50
00:04:55,210 --> 00:04:59,090
Esta função de verificação será chamada com o nome de usuário e senha que o

51
00:04:59,090 --> 00:05:03,380
passaporte extrairá de nossa solicitação recebida.

52
00:05:03,380 --> 00:05:09,620
Agora, na solicitação de entrada para o LocalStrategy, o nome de usuário e

53
00:05:09,620 --> 00:05:16,800
a senha devem ser fornecidos no corpo da mensagem na forma de uma string Json.

54
00:05:17,680 --> 00:05:21,560
Novamente, porque estamos fazendo corpo-parser para que será

55
00:05:21,560 --> 00:05:24,500
adicionado ao corpo da mensagem e, em seguida, a partir daí passaporte

56
00:05:24,500 --> 00:05:29,000
vamos recuperar isso e, em seguida, usar isso e fornecer o nome de usuário e senha

57
00:05:29,000 --> 00:05:34,775
como parâmetros para a função de verificação que vamos fornecer para o LocalStrategy.

58
00:05:34,775 --> 00:05:37,565
Uma vez que estamos usando plugin de mangusto passaporte,

59
00:05:37,565 --> 00:05:44,915
o plugin de mangusto em si adiciona esta função chamada user.authenticate.

60
00:05:44,915 --> 00:05:51,495
Então, ele adiciona esse método para o esquema do usuário e o modelo.

61
00:05:51,495 --> 00:05:55,775
Vamos fornecer isso como a função

62
00:05:55,775 --> 00:06:00,350
que fornecerá a autenticação para a LocalStrategy.

63
00:06:00,350 --> 00:06:02,540
Agora, se você não estiver usando

64
00:06:02,540 --> 00:06:06,875
passport-local-mangusto quando você configurar um plugin mangusto que fizemos,

65
00:06:06,875 --> 00:06:08,060
se você não estiver usando isso,

66
00:06:08,060 --> 00:06:12,540
então você precisa escrever sua própria função de autenticação de usuário aqui.

67
00:06:12,540 --> 00:06:15,720
Na palestra anterior,

68
00:06:15,720 --> 00:06:18,860
eu tinha mostrado uma função de autenticação de usuário simples

69
00:06:18,860 --> 00:06:22,580
que pode ser usada aqui, mas a que é

70
00:06:22,580 --> 00:06:25,610
fornecida pelo módulo passport-local-mangusto é mais

71
00:06:25,610 --> 00:06:30,200
abrangente e é isso que vamos fazer uso em nossa aplicação.

72
00:06:30,200 --> 00:06:36,365
Além disso, uma vez que ainda estamos usando sessões para rastrear usuários em nosso aplicativo,

73
00:06:36,365 --> 00:06:43,775
precisamos serializar e desserializar o usuário.

74
00:06:43,775 --> 00:06:47,345
Então isso basicamente leva a informação do usuário.

75
00:06:47,345 --> 00:06:54,815
Agora lembre-se que a autenticação do passaporte irá montar o req.user ou a propriedade do usuário para

76
00:06:54,815 --> 00:06:58,715
a mensagem de solicitação e para

77
00:06:58,715 --> 00:07:04,610
que as informações do usuário serão serializadas e desserializadas realizadas usando

78
00:07:04,610 --> 00:07:17,295
este dizendo serializar usuário e passaporte desserializar usuário.

79
00:07:17,295 --> 00:07:22,235
Além disso, diremos usuário desserializar usuário.

80
00:07:22,235 --> 00:07:27,920
Estas duas funções que serializar usuário e desserializar usuário são fornecidos

81
00:07:27,920 --> 00:07:35,030
no esquema do usuário e modelo pelo uso do passport-local-mongusto plugin aqui.

82
00:07:35,030 --> 00:07:38,240
Então, isso vai cuidar de tudo o que é necessário para o

83
00:07:38,240 --> 00:07:42,860
nosso apoio para sessões no passaporte.

84
00:07:42,860 --> 00:07:48,375
Assim que tivermos concluído esta atualização para o arquivo authenticate.js,

85
00:07:48,375 --> 00:07:54,200
este arquivo será necessário onde quer que seja necessário para usarmos em nossa autenticação.

86
00:07:54,200 --> 00:07:57,695
Em seguida, indo para o arquivo users.js,

87
00:07:57,695 --> 00:07:59,795
no arquivo users.js,

88
00:07:59,795 --> 00:08:04,170
primeiro importaremos passaporte.

89
00:08:04,170 --> 00:08:09,525
Então vamos dizer passaporte var exigir passaporte.

90
00:08:09,525 --> 00:08:16,100
Então, porque estamos usando o plugin de mangusto local passaporte,

91
00:08:16,100 --> 00:08:20,525
o plugin de mangusto em si fornece algumas métricas que são

92
00:08:20,525 --> 00:08:25,380
úteis para nós usar no processo de inscrição e no processo de login.

93
00:08:25,380 --> 00:08:29,030
Então, indo até a postagem do roteador aqui,

94
00:08:29,030 --> 00:08:34,120
o plugin mangusto nos fornece um método chamado register,

95
00:08:34,120 --> 00:08:37,275
no esquema do usuário e modelo.

96
00:08:37,275 --> 00:08:44,460
Então, vamos dizer registro de usuário e isso será transformado em dizer novo usuário.

97
00:08:44,460 --> 00:08:51,035
Este novo usuário é o primeiro parâmetro que o registro toma

98
00:08:51,035 --> 00:08:58,245
e o segundo parâmetro é a senha do corpo req.

99
00:08:58,245 --> 00:09:05,440
Assim, a senha que vem como um segundo parâmetro no corpo da mensagem.

100
00:09:05,440 --> 00:09:08,460
Portanto, lembre-se de que o nome de usuário e senha são passados

101
00:09:08,460 --> 00:09:12,020
quando você se inscrever no corpo da mensagem.

102
00:09:12,020 --> 00:09:14,255
Agora, neste caso,

103
00:09:14,255 --> 00:09:19,855
isso resultará em uma função de retorno de chamada fornecendo erro

104
00:09:19,855 --> 00:09:25,825
e o usuário como os dois valores de retorno de chamada aqui e, infelizmente,

105
00:09:25,825 --> 00:09:28,790
isso então não funciona neste caso.

106
00:09:28,790 --> 00:09:33,045
Então eu vou ter que cortar isso daqui e,

107
00:09:33,045 --> 00:09:39,415
em vez disso, lidar com isso dentro deste método callback aqui.

108
00:09:39,415 --> 00:09:43,820
Então, deixe-me apenas recuo

109
00:09:43,820 --> 00:09:48,060
isso, para que seja mais fácil ver o código aqui.

110
00:09:48,060 --> 00:09:51,830
Então eu vou dizer, registro de usuário eo primeiro parâmetro é

111
00:09:51,830 --> 00:09:53,630
um novo usuário criado com

112
00:09:53,630 --> 00:09:57,590
o nome de usuário fonte aqui eo segundo parâmetro é a senha,

113
00:09:57,590 --> 00:10:02,550
e então o resultado é esta função de retorno de chamada que vai chamar,

114
00:10:02,550 --> 00:10:06,100
vamos dizer erro usuário aqui.

115
00:10:06,100 --> 00:10:11,260
Neste caso, temos que editar um pouco o código aqui.

116
00:10:11,260 --> 00:10:14,620
Então, na primeira parte,

117
00:10:14,620 --> 00:10:21,850
vamos dizer se erro,

118
00:10:21,850 --> 00:10:28,150
então eles terão que enviar explicitamente de volta a resposta.

119
00:10:28,150 --> 00:10:34,945
Então, eu só vou copiar estes dois aqui.

120
00:10:34,945 --> 00:10:37,670
Então vamos dizer, se erro,

121
00:10:37,740 --> 00:10:40,860
então res código de status,

122
00:10:40,860 --> 00:10:46,970
vamos definir isso para 500 e definir tipo de conteúdo de cabeçalho e, em seguida,

123
00:10:46,970 --> 00:10:52,520
vamos definir res json e, em seguida, erro, erro.

124
00:10:52,520 --> 00:10:56,790
Então vamos construir um objeto json com o erro como o

125
00:10:56,790 --> 00:11:01,590
valor para a propriedade error lá e, em seguida, enviar isso de volta.

126
00:11:01,590 --> 00:11:06,145
Então é assim que você lidaria com o erro neste caso.

127
00:11:06,145 --> 00:11:11,110
Caso contrário, o que fazemos aqui é que vamos

128
00:11:11,110 --> 00:11:18,970
dizer passaporte autenticar local.

129
00:11:18,970 --> 00:11:23,810
Então, se vamos usar passaporte para autenticar o usuário novamente.

130
00:11:23,810 --> 00:11:25,930
Então, diremos que o passaporte autentique local.

131
00:11:25,930 --> 00:11:28,820
Para garantir que o registro do usuário foi bem-sucedido.

132
00:11:28,820 --> 00:11:33,145
vamos tentar autenticar o mesmo usuário que acabamos de registrar e

133
00:11:33,145 --> 00:11:38,335
aqui vamos dizer req res e isso

134
00:11:38,335 --> 00:11:48,355
retornará como um terceiro valor essa função dentro do qual,

135
00:11:48,355 --> 00:11:52,300
vamos enviar de volta a resposta ao nosso cliente.

136
00:11:52,300 --> 00:12:01,140
Então vamos dizer. Deixe-me remover isso e depois adicioná-lo aqui.

137
00:12:01,140 --> 00:12:03,190
Podemos agora remover isso então,

138
00:12:03,190 --> 00:12:11,070
porque isso não é necessário para nós e este é o fechamento do registro do usuário.

139
00:12:11,070 --> 00:12:12,990
Na outra parte,

140
00:12:12,990 --> 00:12:16,810
vamos fazer passaporte autenticar local.

141
00:12:16,970 --> 00:12:19,510
Olhe para a sintaxe aqui.

142
00:12:19,510 --> 00:12:23,425
Então este é o passaporte autenticar local e depois disso,

143
00:12:23,425 --> 00:12:29,325
temos que chamar esta função aqui que os parâmetros req,

144
00:12:29,325 --> 00:12:35,245
res e que o terceiro sendo uma função de retorno de chamada aqui.

145
00:12:35,245 --> 00:12:42,275
Então esta é a maneira que isso é implementado porque passaporte espera que você faça isso dessa maneira.

146
00:12:42,275 --> 00:12:46,495
Aqui, vamos definir req res código de status é 200,

147
00:12:46,495 --> 00:12:49,930
definir cabeçalho conteúdo aplicativo json e, em seguida, vamos

148
00:12:49,930 --> 00:12:59,410
res json registro status bem-sucedido e não vamos passar o valor do usuário aqui.

149
00:12:59,410 --> 00:13:03,240
Em vez disso, o que eu vou fazer é

150
00:13:03,240 --> 00:13:10,695
colocar uma bandeira chamada sucesso aqui como verdadeira aqui.

151
00:13:10,695 --> 00:13:15,620
Agora, desta forma, no lado do nosso cliente quando este json é recebido,

152
00:13:15,620 --> 00:13:20,550
o cliente pode simplesmente extrair a propriedade success e, em seguida, verificar se é verdade

153
00:13:20,550 --> 00:13:25,695
ou não para verificar rapidamente se o registro foi bem sucedido ou não.

154
00:13:25,695 --> 00:13:32,000
Então é assim que vamos lidar com o processo de registro do usuário aqui.

155
00:13:32,000 --> 00:13:35,470
Então, observe como o código simplificou significativamente.

156
00:13:35,470 --> 00:13:38,924
Se o usuário não se registrou corretamente

157
00:13:38,924 --> 00:13:45,665
, isso enviará de volta um erro adequadamente e também a autenticação falhará.

158
00:13:45,665 --> 00:13:51,115
Portanto, ambos os casos, você detectará a situação quando a autenticação do usuário falhar.

159
00:13:51,115 --> 00:13:56,270
Agora, o processo de login em si também fica significativamente simplificado.

160
00:13:56,270 --> 00:14:01,650
Então, não precisamos fazer tudo isso na rota de login aqui.

161
00:14:01,650 --> 00:14:07,220
Então eu vou remover todo esse código e esta rota de login se torna simplificada aqui.

162
00:14:07,220 --> 00:14:14,365
Agora, para a rota de login - para a postagem do roteador quando fazemos isso aqui,

163
00:14:14,365 --> 00:14:19,150
aqui também esperamos que o nome de usuário e senha para ser incluído

164
00:14:19,150 --> 00:14:24,240
no corpo da mensagem de post que está chegando ela.

165
00:14:24,240 --> 00:14:32,030
Ao contrário do caso anterior em que estávamos incluindo isso no cabeçalho de autorização,

166
00:14:32,030 --> 00:14:37,865
aqui esperamos que isso seja incluído no corpo da mensagem de postagem de entrada.

167
00:14:37,865 --> 00:14:47,730
Então, para autenticar, vamos simplesmente dizer passaporte autenticar e vamos dizer local aqui.

168
00:14:47,730 --> 00:14:52,320
Então esta será a segunda chamada aqui.

169
00:14:52,320 --> 00:14:55,360
Então este é o segundo middleware aqui que vamos cortar.

170
00:14:55,360 --> 00:15:01,690
Então, quando a postagem do roteador entra no ponto final de login,

171
00:15:01,690 --> 00:15:06,095
vamos primeiro chamar o passaporte autenticar local.

172
00:15:06,095 --> 00:15:09,660
Se isso for bem sucedido, então isso

173
00:15:09,660 --> 00:15:13,485
entrará e a próxima função que se segue será executada.

174
00:15:13,485 --> 00:15:15,760
Se houver algum erro na autenticação,

175
00:15:15,760 --> 00:15:18,850
este passaporte autenticar local

176
00:15:18,850 --> 00:15:24,210
enviará automaticamente uma resposta ao cliente sobre a falha da autenticação.

177
00:15:24,210 --> 00:15:26,190
Então isso já está resolvido.

178
00:15:26,190 --> 00:15:33,345
Portanto, observe como o código no processo de login fica significativamente simplificado.

179
00:15:33,345 --> 00:15:36,565
Então, se isso passar com sucesso,

180
00:15:36,565 --> 00:15:42,775
eu só preciso verificar o req e res e aqui o que eu vou fazer

181
00:15:42,775 --> 00:15:49,665
é simplesmente enviar de volta uma mensagem para o lado do cliente com esta informação aqui.

182
00:15:49,665 --> 00:15:53,775
Vamos dizer res código de status 200,

183
00:15:53,775 --> 00:16:02,145
res definir cabeçalho conteúdo tipo aplicativo json e res json sucesso verdadeiro status.

184
00:16:02,145 --> 00:16:13,010
Nós diremos, você está logado com sucesso.

185
00:16:13,010 --> 00:16:18,100
É isso. Esta é a mudança que vamos fazer no arquivo users.js.

186
00:16:18,100 --> 00:16:21,275
Então, observe como, por causa do passaporte do usuário,

187
00:16:21,275 --> 00:16:24,655
tanto o processo de inscrição quanto o processo de login,

188
00:16:24,655 --> 00:16:28,205
o código simplificou significativamente neste caso.

189
00:16:28,205 --> 00:16:34,465
Agora vamos passar para atualizar o arquivo app.js indo para app.js agora.

190
00:16:34,465 --> 00:16:37,555
Em app.js bem aqui

191
00:16:37,555 --> 00:16:50,540
vamos inserir passaporte.

192
00:16:51,270 --> 00:16:55,310
Em seguida, vamos importar

193
00:16:59,820 --> 00:17:07,120
o módulo de autenticação que acabamos de implementar.

194
00:17:07,120 --> 00:17:15,390
Vamos dizer var autenticar e no arquivo app.js abaixo aqui após a sessão,

195
00:17:15,390 --> 00:17:25,320
adicionamos app.use (passport.initialize)

196
00:17:25,320 --> 00:17:32,100
e app.use (.session).

197
00:17:32,950 --> 00:17:37,810
Se o usuário estiver conectado,

198
00:17:37,810 --> 00:17:42,945
então o que acontece é que quando a sessão é iniciada novamente,

199
00:17:42,945 --> 00:17:47,095
você se lembra que quando você fizer login aqui,

200
00:17:47,095 --> 00:17:48,735
você estará fazendo login aqui,

201
00:17:48,735 --> 00:17:51,705
e uma chamada para o passaporte autenticar local,

202
00:17:51,705 --> 00:17:53,730
quando isso for feito no estágio de login,

203
00:17:53,730 --> 00:17:56,460
o passaporte autenticar local irá

204
00:17:56,460 --> 00:18:00,625
adiciona automaticamente a propriedade do usuário à mensagem de solicitação.

205
00:18:00,625 --> 00:18:03,415
Então, ele irá adicionar req.user e, em seguida,

206
00:18:03,415 --> 00:18:07,265
a sessão de passaporte que fizemos aqui irá

207
00:18:07,265 --> 00:18:12,575
serializar automaticamente as informações do usuário e, em seguida, armazená-lo na sessão.

208
00:18:12,575 --> 00:18:15,925
Então, e posteriormente, sempre que

209
00:18:15,925 --> 00:18:19,135
uma solicitação de entrada vem do lado do cliente

210
00:18:19,135 --> 00:18:22,630
com o cookie de sessão já em vigor,

211
00:18:22,630 --> 00:18:29,250
então isso carregará automaticamente o req.user na solicitação de entrada.

212
00:18:29,250 --> 00:18:32,735
Então, é assim que a sessão de passaporte em si é organizada.

213
00:18:32,735 --> 00:18:34,445
Então, uma vez feito isso,

214
00:18:34,445 --> 00:18:40,075
até mesmo nosso código de autenticação se tornará muito mais simples aqui.

215
00:18:40,075 --> 00:18:42,400
Então, no código de autenticação,

216
00:18:42,400 --> 00:18:49,450
vamos simplesmente dizer, se req.user.

217
00:18:49,450 --> 00:18:55,690
Então, o req.user será carregado pelo middleware da sessão do passaporte automaticamente,

218
00:18:55,690 --> 00:18:58,845
e assim diremos req.user.

219
00:18:58,845 --> 00:19:03,940
Se não req.user vamos dizer var err, novo erro,

220
00:19:03,940 --> 00:19:09,495
você não está autenticado, e todas essas mensagens aqui.

221
00:19:09,495 --> 00:19:15,410
Caso contrário, veja a outra parte também agora fica simplificado.

222
00:19:17,280 --> 00:19:20,010
Vamos dizer outra coisa a seguir.

223
00:19:20,010 --> 00:19:27,335
Então, seu código de autenticação se torna muito mais simples porque se req.user não estiver presente,

224
00:19:27,335 --> 00:19:31,695
então isso significa que a autenticação não foi feita corretamente,

225
00:19:31,695 --> 00:19:33,345
é por isso que você indica o erro.

226
00:19:33,345 --> 00:19:35,470
Caso contrário, você está autenticado.

227
00:19:35,470 --> 00:19:37,110
Se req.user estiver presente,

228
00:19:37,110 --> 00:19:39,900
isso significa que o passaporte fez a autenticação e o

229
00:19:39,900 --> 00:19:42,970
usuário req.user é carregado na mensagem de solicitação,

230
00:19:42,970 --> 00:19:46,410
e assim você pode simplesmente ir mais para baixo.

231
00:19:46,410 --> 00:19:49,815
Então, essa é a mudança que precisamos fazer para app.js.

232
00:19:49,815 --> 00:19:57,775
Vamos salvar todas as alterações e, em seguida, olhar para o aplicativo no Postman.

233
00:19:57,775 --> 00:20:01,385
Depois de salvar todas as alterações, reinicie o servidor.

234
00:20:01,385 --> 00:20:02,600
Se o servidor estiver em execução,

235
00:20:02,600 --> 00:20:04,700
pare-o e reinicie o servidor.

236
00:20:04,700 --> 00:20:07,680
Deixe-me iniciar o meu servidor.

237
00:20:08,160 --> 00:20:10,450
Uma vez que o servidor está funcionando,

238
00:20:10,450 --> 00:20:13,900
vamos para o Postman e fazer alguns pedidos.

239
00:20:13,900 --> 00:20:17,650
Indo para o Postman, deixe-me agora tentar registrar um novo usuário

240
00:20:17,650 --> 00:20:22,120
fazendo uma postagem no endpoint de inscrição dos usuários.

241
00:20:22,120 --> 00:20:28,485
Quando o registro é publicado,

242
00:20:28,485 --> 00:20:31,850
você vê que no corpo da mensagem de resposta ele diz,

243
00:20:31,850 --> 00:20:35,805
sucesso verdadeiro e registro de status bem-sucedido.

244
00:20:35,805 --> 00:20:40,430
Então, o usuário foi registrado com sucesso no lado do cliente.

245
00:20:40,430 --> 00:20:44,870
Então, agora, deixe-me fazer um login do usuário.

246
00:20:44,870 --> 00:20:50,000
Então, diremos “Login” e ainda fornecemos

247
00:20:50,000 --> 00:20:55,765
o nome de usuário e a senha no corpo da mensagem aqui.

248
00:20:55,765 --> 00:20:58,345
Então, quando eu clicar no botão “Enviar”,

249
00:20:58,345 --> 00:21:02,550
você notará imediatamente que na parte inferior,

250
00:21:02,550 --> 00:21:05,050
ele diz, sucesso, verdadeiro e status,

251
00:21:05,050 --> 00:21:09,440
você está logado e, em seguida, no cabeçalho

252
00:21:09,440 --> 00:21:13,515
em si, você veria um set-cookie chegando porque estamos configurando a sessão,

253
00:21:13,515 --> 00:21:17,390
e então você vê o cookie no lugar lá.

254
00:21:17,390 --> 00:21:19,465
Quando você clica nos cookies,

255
00:21:19,465 --> 00:21:23,875
você vê o ID da sessão no lugar bem ali.

256
00:21:23,875 --> 00:21:26,980
Então, agora estamos logados com sucesso.

257
00:21:26,980 --> 00:21:35,630
Vamos enviar uma solicitação para o ponto final Get localhost: 3000 pratos.

258
00:21:35,630 --> 00:21:42,210
Você vê que sua solicitação entrou com sucesso e, em seguida, uma resposta foi enviada.

259
00:21:42,210 --> 00:21:43,350
É claro

260
00:21:43,350 --> 00:21:48,330
que, neste momento, meu banco de dados está vazio, então é por isso que ele envia de volta um array vazio

261
00:21:48,330 --> 00:21:54,530
do site do servidor quando eu peço localhost: 3000/pratos.

262
00:21:55,050 --> 00:21:58,165
Isto está perfeitamente bem.

263
00:21:58,165 --> 00:22:00,610
Deixe-me agora fazer logout do usuário.

264
00:22:00,610 --> 00:22:02,995
Então, quando eu sair do usuário, agora,

265
00:22:02,995 --> 00:22:10,450
você vai notar que o usuário foi desconectado e quando você clicar nos cookies,

266
00:22:10,450 --> 00:22:14,660
você vai notar que, esse cookie para localhost já foi embora.

267
00:22:14,660 --> 00:22:19,245
Então, agora, se você tentar fazer um get no localhost:pratos,

268
00:22:19,245 --> 00:22:24,910
você vê que a resposta diz,

269
00:22:24,910 --> 00:22:26,640
você não está autenticado.

270
00:22:26,640 --> 00:22:32,760
Vamos entrar mais uma vez fazendo uma postagem no login dos usuários

271
00:22:32,760 --> 00:22:36,290
e, em seguida, você vê que podemos fazer login com sucesso neste ponto.

272
00:22:36,290 --> 00:22:37,830
Você também percebe que,

273
00:22:37,830 --> 00:22:40,075
esse novo cookie foi configurado aqui.

274
00:22:40,075 --> 00:22:44,480
Então, se fizermos um get no localhost:pratos aqui,

275
00:22:44,480 --> 00:22:46,465
agora, isso será bem sucedido.

276
00:22:46,465 --> 00:22:51,624
Uma vez que estamos usando o mangusto local passaporte como o plugin mangusto,

277
00:22:51,624 --> 00:22:55,790
vamos também verificar o nosso servidor MongoDB para ver como

278
00:22:55,790 --> 00:23:00,410
as informações do usuário é realmente armazenado em nosso MongoDB.

279
00:23:00,410 --> 00:23:04,880
Então, em seu terminal,

280
00:23:04,880 --> 00:23:06,970
você pode abrir a ondulação Mongo,

281
00:23:06,970 --> 00:23:11,775
então vamos dizer Mongo no terminal e, em seguida, conectar-se ao nosso servidor MongoDB,

282
00:23:11,775 --> 00:23:16,500
e, em seguida, dizer use Confusion.

283
00:23:16,500 --> 00:23:26,285
Então vamos dizer db.users.find () .pretty () e, em seguida, imprimir as informações do usuário.

284
00:23:26,285 --> 00:23:31,180
Então, quando você imprime as informações do usuário como você vê aqui,

285
00:23:31,180 --> 00:23:35,235
há um usuário que temos registrado anteriormente.

286
00:23:35,235 --> 00:23:40,840
Então, você verá que o registro do usuário contém o ID do objeto e, em seguida,

287
00:23:40,840 --> 00:23:42,665
o nome de usuário abaixo aqui,

288
00:23:42,665 --> 00:23:46,060
e o sinalizador admin que é falso e, em seguida,

289
00:23:46,060 --> 00:23:53,720
também notar que em vez de armazenar a senha em si o que o

290
00:23:53,720 --> 00:23:57,515
plugin mongoose passaporte local faz é que ele armazena

291
00:23:57,515 --> 00:24:01,865
seu valor salt aqui e um valor de hash aqui.

292
00:24:01,865 --> 00:24:08,655
Agora, o plugin do Mongo faz é que ele vai usar o salt como uma forma de

293
00:24:08,655 --> 00:24:15,990
criptografar a senha e instalar a senha hash neste campo de hash aqui.

294
00:24:15,990 --> 00:24:17,980
Então, quando você tenta fazer login,

295
00:24:17,980 --> 00:24:23,130
ele irá aplicar a mesma transformação para a senha de entrada

296
00:24:23,130 --> 00:24:27,330
e, em seguida, tentar combiná-lo com esse valor de hash que é armazenado aqui.

297
00:24:27,330 --> 00:24:29,580
Então, você pode ver que no próprio banco de dados,

298
00:24:29,580 --> 00:24:32,855
a senha não é armazenada diretamente dentro

299
00:24:32,855 --> 00:24:38,280
do valor hash da senha que é hash usando esta chave salt aqui,

300
00:24:38,280 --> 00:24:39,435
que vemos aqui,

301
00:24:39,435 --> 00:24:42,780
é armazenada no registro lá.

302
00:24:42,780 --> 00:24:47,440
Então, é assim que o plugin Mangusto passaporte local nos permite

303
00:24:47,440 --> 00:24:53,905
armazenar as informações do usuário dentro de nosso banco de dados.

304
00:24:53,905 --> 00:24:58,680
Com esta rápida compreensão de como passaporte, passaporte-local

305
00:24:58,680 --> 00:25:02,590
e Passaporte-local-mangusto nos ajudam a simplificar

306
00:25:02,590 --> 00:25:09,390
a estratégia local de nome de usuário e senha em nossa aplicação.

307
00:25:09,390 --> 00:25:11,660
Completamos este exercício.

308
00:25:11,660 --> 00:25:18,390
Este é um bom momento para você fazer um commit Git com o passaporte de mensagem.