1
00:00:03,890 --> 00:00:11,670
Agora que entendemos a autenticação baseada em token usando os Tokens Web JSON,

2
00:00:11,670 --> 00:00:16,035
e também compreendemos as vantagens de usar essa abordagem.

3
00:00:16,035 --> 00:00:22,185
O fato de que agora estamos construindo um servidor baseado em API Rest,

4
00:00:22,185 --> 00:00:24,420
neste curso significa que

5
00:00:24,420 --> 00:00:27,585
a autenticação baseada em JSON Web Token

6
00:00:27,585 --> 00:00:31,410
é mais adequada para este servidor que estamos construindo.

7
00:00:31,410 --> 00:00:40,585
Então, vamos atualizar nosso servidor de API Rest para fazer uso de JSON Web Tokens neste exercício.

8
00:00:40,585 --> 00:00:45,755
Para começar a atualizar o servidor em seu terminal,

9
00:00:45,755 --> 00:00:51,935
vamos primeiro instalar o JSON Web Token e o módulo Nó JWT passaporte.

10
00:00:51,935 --> 00:00:56,445
Então, no prompt, digite npm, instale,

11
00:00:56,445 --> 00:01:05,640
passaporte JWT JSON Web Token e menos menos salvar.

12
00:01:05,640 --> 00:01:15,435
Como você pode ver, estou usando JSON Web Token 8.3.0 e passaporte JWT 4.0.0 neste curso.

13
00:01:15,435 --> 00:01:23,180
Agora que concluímos a instalação, vamos atualizar nosso servidor expresso.

14
00:01:23,180 --> 00:01:25,700
Indo agora para o nosso código,

15
00:01:25,700 --> 00:01:30,289
vamos adicionar um arquivo chamado

16
00:01:30,289 --> 00:01:36,335
conflict.js na pasta raiz do nosso projeto.

17
00:01:36,335 --> 00:01:39,455
Agora, este arquivo conflict.js eu vou usá-lo

18
00:01:39,455 --> 00:01:43,220
para armazenar algumas informações de configuração para o nosso servidor.

19
00:01:43,220 --> 00:01:49,790
Agora, esta é uma maneira de centralizar toda a configuração para o nosso servidor.

20
00:01:49,790 --> 00:01:53,600
Neste arquivo conflict.js,

21
00:01:53,600 --> 00:01:59,825
deixe-me exportar um objeto JSON aqui.

22
00:01:59,825 --> 00:02:02,490
Então vamos dizer, secretKey,

23
00:02:08,510 --> 00:02:11,550
e este é o lugar onde

24
00:02:19,450 --> 00:02:28,705
eu vou especificar a chave secreta que eu vou estar usando para assinar meu JSON Web Token,

25
00:02:28,705 --> 00:02:36,700
e também deixe-me especificar um URL Mongo aqui,

26
00:02:36,700 --> 00:02:41,275
que será o URL para o

27
00:02:41,275 --> 00:02:51,710
meu servidor localhost 27017 MongoDB.

28
00:02:52,200 --> 00:02:55,060
Uma vez que tenhamos concluído isso,

29
00:02:55,060 --> 00:02:59,260
então vamos para o arquivo authenticate.js,

30
00:02:59,260 --> 00:03:01,780
e no arquivo authenticate.js vamos

31
00:03:01,780 --> 00:03:10,700
agora criar a estratégia JWT.

32
00:03:11,250 --> 00:03:16,175
Esta é a estratégia de token da web JSON que é fornecida pelo

33
00:03:16,175 --> 00:03:25,830
nosso módulo de nó JWT passaporte que acabamos de incluir e assim vamos dizer,

34
00:03:26,300 --> 00:03:32,895
generatividade estratégia passaporte generatividy.strategy.

35
00:03:32,895 --> 00:03:35,370
Isso nos fornecerá

36
00:03:35,370 --> 00:03:40,550
uma estratégia baseada em JSON Web Token para configurar nosso módulo de passaporte,

37
00:03:40,550 --> 00:03:46,820
em seguida, extrair JWT, que eu

38
00:03:46,820 --> 00:03:53,745
também obterá do passaporte JWT.

39
00:03:53,745 --> 00:03:55,935
Vamos precisar do passaporte JWT,

40
00:03:55,935 --> 00:03:59,565
então vamos dizer “Extrair JWT”.

41
00:03:59,565 --> 00:04:02,655
Então vamos importar

42
00:04:02,655 --> 00:04:10,240
o módulo JSON Web Token

43
00:04:10,240 --> 00:04:12,265
que acabamos de instalar.

44
00:04:12,265 --> 00:04:15,340
Uma vez que tenhamos importado estes,

45
00:04:15,340 --> 00:04:18,370
vamos em frente e começar a configurar algumas coisas.

46
00:04:18,370 --> 00:04:26,205
Junto com estes, deixe-me importar a configuração que

47
00:04:26,205 --> 00:04:35,840
criei o arquivo config.js que acabei de adicionar ao meu projeto.

48
00:04:35,840 --> 00:04:40,100
Uma vez que eu completar isso, então deixe-me ir em frente e

49
00:04:40,100 --> 00:04:45,650
introduzir algumas funções adicionais que eu vou exportar a partir daqui.

50
00:04:45,650 --> 00:04:49,200
Vamos dizer, exports.getToken,

51
00:04:55,160 --> 00:05:02,840
esta função quando fornecer com um parâmetro lá que eu vou simplesmente chamar usuário,

52
00:05:02,840 --> 00:05:06,335
que será um objeto JSON,

53
00:05:06,335 --> 00:05:10,145
isso irá criar o token e dar-lhe para nós.

54
00:05:10,145 --> 00:05:16,685
Para criar o token, estaremos usando o módulo jsonwebtoken que acabamos de importar.

55
00:05:16,685 --> 00:05:22,140
Então, aqui vamos dizer retorno JWT.sign,

56
00:05:23,750 --> 00:05:31,355
isso nos ajuda a criar o JSON Web Token e assim dentro que ele vai

57
00:05:31,355 --> 00:05:34,430
me permitir fornecer a carga útil e

58
00:05:34,430 --> 00:05:38,825
a carga aqui vem como o parâmetro aqui chamado usuário,

59
00:05:38,825 --> 00:05:42,620
e então o segundo parâmetro é

60
00:05:42,620 --> 00:05:51,050
a chave secreta ou privada que eu recebo da configuração. chave secreta,

61
00:05:51,050 --> 00:05:55,260
que eu acabei de configurar um pouco mais cedo.

62
00:05:55,630 --> 00:06:02,835
Podemos fornecer opções adicionais aqui.

63
00:06:02,835 --> 00:06:07,055
Uma opção que vou fornecer a isto é...

64
00:06:07,055 --> 00:06:09,410
Ok, deixe-me ir para a próxima linha aqui,

65
00:06:09,410 --> 00:06:14,160
a opção que eu vou fornecer é ExpireSin.

66
00:06:14,530 --> 00:06:20,945
O ExpireSin irá dizer-lhe quanto tempo o jsonwebtoken será

67
00:06:20,945 --> 00:06:27,185
válido então, neste caso, eu digo 3.600 significando 3.600 segundos ou cerca de uma hora.

68
00:06:27,185 --> 00:06:32,825
Uma hora depois, você terá que renovar o jsonwebtoken.

69
00:06:32,825 --> 00:06:36,790
Uma hora é tempo suficiente para podermos testar nossa aplicação.

70
00:06:36,790 --> 00:06:40,370
Você pode definir isso para ser muito mais longo se você escolher.

71
00:06:40,370 --> 00:06:45,110
Em um aplicativo real você pode definir isso para ser um valor muito mais longo talvez

72
00:06:45,110 --> 00:06:50,075
alguns dias e esperar que o usuário se autentique novamente a cada poucos dias.

73
00:06:50,075 --> 00:06:52,670
Agora, vamos também configurar

74
00:06:52,670 --> 00:06:58,025
a estratégia baseada em jsonwebtoken para a nossa aplicação de passaporte.

75
00:06:58,025 --> 00:07:02,900
Então, deixe-me declarar uma variável chamada opts,

76
00:07:02,900 --> 00:07:12,140
que não é nada além das opções que eu vou especificar para a minha estratégia baseada em JWT.

77
00:07:12,140 --> 00:07:18,905
Então, vamos dizer opts JWTFromRequest.

78
00:07:18,905 --> 00:07:22,925
Agora esta opção especifica

79
00:07:22,925 --> 00:07:28,580
como o jsonwebtoken deve ser extraído da mensagem de solicitação recebida.

80
00:07:28,580 --> 00:07:33,755
Aqui é onde vamos usar o extrato JWT.

81
00:07:33,755 --> 00:07:39,290
Esta extração JWT suporta vários métodos

82
00:07:39,290 --> 00:07:44,970
para extrair informações do cabeçalho.

83
00:07:44,970 --> 00:07:49,580
Ele vai dizer de AuthHeader de AuthHeader como token portador,

84
00:07:49,580 --> 00:07:51,510
do cabeçalho qual esquema e assim por diante.

85
00:07:51,510 --> 00:07:54,380
Se você ler a documentação, ele irá

86
00:07:54,380 --> 00:07:58,040
dizer-lhe várias maneiras de extrair o jsonwebtoken.

87
00:07:58,040 --> 00:08:00,770
Você pode passar o token no corpo da

88
00:08:00,770 --> 00:08:04,970
mensagem de solicitação de entrada e, em seguida, você pode extraí-lo de lá,

89
00:08:04,970 --> 00:08:08,255
você também pode usar extratores personalizados e assim por diante.

90
00:08:08,255 --> 00:08:14,180
Neste curso, eu vou usar o método mais simples chamado

91
00:08:14,180 --> 00:08:20,745
de cabeçalho de autenticação como um token portador.

92
00:08:20,745 --> 00:08:22,220
Já estamos familiarizados com

93
00:08:22,220 --> 00:08:25,055
o cabeçalho de autenticação porque como temos usado isso com

94
00:08:25,055 --> 00:08:30,440
a autenticação básica e a autenticação baseada em cookies anteriormente.

95
00:08:30,440 --> 00:08:32,180
Então, eu só vou usar

96
00:08:32,180 --> 00:08:38,350
esse mesmo campo de cabeçalho na mensagem de solicitação para carregar o jsonwebtoken.

97
00:08:38,350 --> 00:08:45,270
Então eu vou dizer opts como portador token jsonwebtoken.

98
00:08:45,270 --> 00:08:51,160
O próximo, vamos dizer opts.secretorKey,

99
00:08:56,980 --> 00:09:02,795
este é o segundo parâmetro que me ajuda a

100
00:09:02,795 --> 00:09:11,670
fornecer a chave secreta que eu vou estar usando dentro da minha estratégia para o login.

101
00:09:11,670 --> 00:09:15,875
Então essa é a outra opção que eu vou especificar aqui.

102
00:09:15,875 --> 00:09:18,065
Uma vez que eu estou especificando esses dois,

103
00:09:18,065 --> 00:09:26,390
deixe-me exportar a estratégia Passport

104
00:09:26,390 --> 00:09:30,680
que eu vou configurar aqui então vamos dizer ExportJWTPassport,

105
00:09:30,680 --> 00:09:34,355
então vamos dizer passport.use.

106
00:09:34,355 --> 00:09:37,940
Lembre-se da forma como especificou a estratégia local anteriormente.

107
00:09:37,940 --> 00:09:42,035
Aqui estamos especificando a estratégia baseada em JWT,

108
00:09:42,035 --> 00:09:47,895
então vamos criar uma nova estratégia JWT,

109
00:09:47,895 --> 00:09:51,320
lembre-se que acabamos de importar a estratégia JWT

110
00:09:51,320 --> 00:09:56,615
aqui que é o que vamos usar para criar uma nova estratégia.

111
00:09:56,615 --> 00:10:01,235
Esta estratégia JWT leva

112
00:10:01,235 --> 00:10:07,675
o objeto opções que eu acabei de criar como o primeiro parâmetro.

113
00:10:07,675 --> 00:10:14,210
As opções de estratégia e a segunda é a função de verificação que eu preciso fornecer,

114
00:10:14,210 --> 00:10:18,050
e assim a função de verificação eu vou fornecê-lo na próxima linha aqui,

115
00:10:18,050 --> 00:10:28,545
vamos dizer FunctionJWT_PayLoad.

116
00:10:28,545 --> 00:10:33,900
Feito. Então, quando esta função é chamada,

117
00:10:33,900 --> 00:10:39,270
o feito é o retorno de chamada que é fornecido pelo passaporte.

118
00:10:39,270 --> 00:10:44,270
Então, sempre que você tem passaporte que você está configurando com uma nova estratégia,

119
00:10:44,270 --> 00:10:46,750
você precisa fornecer o segundo parâmetro feito.

120
00:10:46,750 --> 00:10:48,460
Através deste parâmetro feito,

121
00:10:48,460 --> 00:10:52,235
você estará passando de volta informações para o passaporte que ele irá então

122
00:10:52,235 --> 00:10:57,780
usar para carregar coisas na mensagem de solicitação.

123
00:10:57,780 --> 00:11:00,710
Então, quando passaporte analisa a mensagem de solicitação,

124
00:11:00,710 --> 00:11:04,110
ele vai usar a estratégia e, em seguida, extrair informações

125
00:11:04,110 --> 00:11:09,540
e, em seguida, carregá-lo em nossa mensagem de solicitação.

126
00:11:09,540 --> 00:11:13,905
Então, como isso acontece de ser uma função,

127
00:11:13,905 --> 00:11:19,795
eu só vou usar uma função de seta aqui,

128
00:11:19,795 --> 00:11:22,160
eu tenho gostado de funções de seta.

129
00:11:22,160 --> 00:11:25,650
Então, deixe-me criar isso como uma função de seta aqui,

130
00:11:25,650 --> 00:11:28,345
e dentro desta função,

131
00:11:28,345 --> 00:11:30,465
estaremos definindo a função.

132
00:11:30,465 --> 00:11:32,970
Então, o que fazemos dentro da função?

133
00:11:32,970 --> 00:11:37,420
Deixe-me fazer um console.log de

134
00:11:38,370 --> 00:11:44,020
JWT payload e,

135
00:11:44,660 --> 00:11:49,995
em seguida, deixe-me apenas logout a opção vindo aqui,

136
00:11:49,995 --> 00:11:51,770
a JWT payload Option vindo aqui,

137
00:11:51,770 --> 00:11:55,420
para que você possa ver o que está dentro da carga JWT.

138
00:11:55,420 --> 00:12:04,250
Em seguida, vamos procurar um usuário dizendo user.findOne,

139
00:12:04,250 --> 00:12:14,020
e então eu sei que no jwt.payload,

140
00:12:14,020 --> 00:12:17,210
há um campo ID que entra.

141
00:12:17,210 --> 00:12:21,360
Então, isso é o que eu vou ser atribuindo como o campo ID aqui.

142
00:12:21,360 --> 00:12:26,040
Então, eu vou dizer, User.Findone e o segundo

143
00:12:26,040 --> 00:12:36,190
é uma função de retorno de chamada.

144
00:12:36,870 --> 00:12:45,295
Como você percebe, este método de mangusto usuário e você tenta encontrar.

145
00:12:45,295 --> 00:12:54,665
Então, vamos dizer que se errar então, retorno feito.

146
00:12:54,665 --> 00:12:57,945
O que é que isto fez? Isto feito é o retorno de chamada que o

147
00:12:57,945 --> 00:13:02,155
passaporte passará para a sua estratégia aqui.

148
00:13:02,155 --> 00:13:04,965
Então, vamos chamar essa função feita.

149
00:13:04,965 --> 00:13:11,200
Isso feito no passaporte leva três parâmetros.

150
00:13:12,890 --> 00:13:20,400
Então, você pode ver as três peças de informação que isso feito espera que ele diz, erro: qualquer.

151
00:13:20,400 --> 00:13:24,525
Então, se você tiver um erro, você irá passá-lo como o primeiro parâmetro.

152
00:13:24,525 --> 00:13:26,495
O segundo parâmetro, usuário? ,

153
00:13:26,495 --> 00:13:28,245
Se um usuário existir,

154
00:13:28,245 --> 00:13:33,770
então o valor do usuário será passado em e, em seguida, se alguma informação? :, qualquer.

155
00:13:33,770 --> 00:13:37,100
Então, estes dois são parâmetros opcionais e assim,

156
00:13:37,100 --> 00:13:38,690
se você passar em qualquer informação,

157
00:13:38,690 --> 00:13:42,145
então que será usado dentro do aplicativo.

158
00:13:42,145 --> 00:13:44,650
Se eu passar false como o segundo parâmetro,

159
00:13:44,650 --> 00:13:47,515
então isso significa que o usuário não existe ou isso.

160
00:13:47,515 --> 00:13:50,810
Então, ele vai interpretar que o usuário não existe.

161
00:13:50,810 --> 00:13:52,335
Então, eu poderia dizer, err,

162
00:13:52,335 --> 00:13:54,900
falso, porque isso é um erro.

163
00:13:54,900 --> 00:13:58,080
Então, eu não vou estar passando em um valor de usuário lá,

164
00:13:58,080 --> 00:14:00,660
eu vou apenas passar em falso.

165
00:14:00,660 --> 00:14:06,040
Lá, o próximo,

166
00:14:06,040 --> 00:14:11,510
podemos dizer, else if (usuário).

167
00:14:11,510 --> 00:14:15,860
Então, se o usuário não é nulo,

168
00:14:15,860 --> 00:14:18,960
vamos dizer retorno feito (nulo).

169
00:14:19,230 --> 00:14:22,210
Não há erro, então, o primeiro parâmetro será

170
00:14:22,210 --> 00:14:25,080
nulo e o segundo parâmetro é o usuário,

171
00:14:25,080 --> 00:14:29,895
mas acabamos de receber do MongoDB.

172
00:14:29,895 --> 00:14:35,445
Caso contrário, vamos retornar

173
00:14:35,445 --> 00:14:41,395
feito com null, false.

174
00:14:41,395 --> 00:14:43,650
Então, no último caso,

175
00:14:43,650 --> 00:14:45,100
não conseguimos encontrar o usuário,

176
00:14:45,100 --> 00:14:47,120
então vamos passar em falso.

177
00:14:47,120 --> 00:14:50,200
Então, vamos lidar com isso assim.

178
00:14:50,200 --> 00:14:53,345
Se você quiser, você pode criar uma nova conta de usuário neste momento,

179
00:14:53,345 --> 00:14:58,365
mas eu vou manter isso simples apenas para que seja fácil para nós entender.

180
00:14:58,365 --> 00:15:00,810
Então, vamos apenas dizer, nulo, falso. Isso é seis.

181
00:15:00,810 --> 00:15:07,475
Então, esta é a estratégia de passaporte JSONWebToken que acabei de configurar aqui.

182
00:15:07,475 --> 00:15:11,420
Além disso, deixe-me exportar

183
00:15:11,420 --> 00:15:19,450
mais uma função daqui chamada VerifyUser.

184
00:15:19,450 --> 00:15:21,110
Agora, esta função

185
00:15:21,110 --> 00:15:24,935
VerifyUser, eu vou usá-lo para verificar um usuário de entrada.

186
00:15:24,935 --> 00:15:28,810
Então, é aqui que vou usar passaporte.authenticate.

187
00:15:28,890 --> 00:15:36,440
Então, o passport.authenticate, a estratégia é estratégia jwt que eu acabei de configurar,

188
00:15:36,440 --> 00:15:39,490
a estratégia JSONWebToken que eu acabei de configurar.

189
00:15:39,490 --> 00:15:41,625
Então, a segunda parte,

190
00:15:41,625 --> 00:15:46,305
eu diria, sessão: falsa.

191
00:15:46,305 --> 00:15:47,740
Então, isso significa que,

192
00:15:47,740 --> 00:15:51,305
nós não vamos criar sessões neste caso.

193
00:15:51,305 --> 00:15:58,215
Como você se lembra, um aplicativo inverso,

194
00:15:58,215 --> 00:16:00,530
estamos usando autenticação baseada em tokens.

195
00:16:00,530 --> 00:16:02,435
Então não vamos criar sessões.

196
00:16:02,435 --> 00:16:07,690
Então, é por isso que eu defini esta sessão

197
00:16:07,690 --> 00:16:11,795
de opção como false aqui, e claro, o primeiro especificou a estratégia que eu vou usar.

198
00:16:11,795 --> 00:16:14,050
Então, para verificar um usuário,

199
00:16:14,050 --> 00:16:15,930
usarei a estratégia JWT.

200
00:16:15,930 --> 00:16:18,110
Como funciona a estratégia JWT?

201
00:16:18,110 --> 00:16:20,540
Na solicitação de entrada,

202
00:16:21,040 --> 00:16:26,845
o token será incluído no cabeçalho de autenticação como vimos aqui.

203
00:16:26,845 --> 00:16:29,950
Nós dissemos cabeçalho de autenticação como token portador.

204
00:16:29,950 --> 00:16:33,530
Se isso estiver incluído, então isso será extraído e que será

205
00:16:33,530 --> 00:16:38,210
usado para autenticar o usuário com base no token.

206
00:16:38,210 --> 00:16:47,770
Uma pequena correção aqui, deve ser user.findone_id é igual a jwt_payload. _id,

207
00:16:47,770 --> 00:16:56,475
porque esse é o valor de id que está dentro da carga do meu JSONWebToken.

208
00:16:56,475 --> 00:17:01,615
Então, estamos procurando o usuário com esse ID fornecido.

209
00:17:01,615 --> 00:17:06,170
Então, uma vez que tenhamos concluído isso, então agora,

210
00:17:06,170 --> 00:17:11,790
a segunda parte que precisamos fazer é que precisamos criar o token em algum lugar.

211
00:17:11,790 --> 00:17:14,005
Agora, onde criamos o token?

212
00:17:14,005 --> 00:17:20,290
Então, é aqui que algo que estamos fazendo no arquivo users.js é muito útil para nós.

213
00:17:20,290 --> 00:17:22,270
No arquivo users.js,

214
00:17:22,270 --> 00:17:27,180
lembre-se de que você já tem esse endpoint chamado login.

215
00:17:27,180 --> 00:17:28,700
No ponto de extremidade de login,

216
00:17:28,700 --> 00:17:33,410
você estava usando o nome de usuário e a senha para autenticar o usuário.

217
00:17:33,410 --> 00:17:38,030
Então, mesmo com o JSONWebToken para emitir o JSONWebToken,

218
00:17:38,030 --> 00:17:41,959
primeiro você precisa autenticar o usuário usando uma das outras estratégias,

219
00:17:41,959 --> 00:17:44,630
e se você estiver usando a estratégia local primeiro,

220
00:17:44,630 --> 00:17:49,715
vamos autenticar o usuário usando o nome de usuário e senha.

221
00:17:49,715 --> 00:17:53,415
Uma vez que o usuário é autenticado com o nome de usuário e senha,

222
00:17:53,415 --> 00:17:55,885
então emitiremos o token para o usuário dizendo:

223
00:17:55,885 --> 00:17:57,330
“Ok, você é um usuário válido,

224
00:17:57,330 --> 00:17:58,630
eu vou lhe dar o token”.

225
00:17:58,630 --> 00:18:02,390
Todas as solicitações subseqüentes simplesmente carregarão o token

226
00:18:02,390 --> 00:18:06,860
no cabeçalho da mensagem de solicitação de entrada.

227
00:18:06,860 --> 00:18:10,415
Então, anteriormente, nós usamos para criar sessões.

228
00:18:10,415 --> 00:18:11,840
Quando o usuário é autenticado,

229
00:18:11,840 --> 00:18:13,935
não vamos usar mais sessões.

230
00:18:13,935 --> 00:18:17,640
Em vez disso, quando o usuário é autenticado usando a estratégia local,

231
00:18:17,640 --> 00:18:20,110
emitiremos um token para o usuário.

232
00:18:20,110 --> 00:18:25,955
Então, dentro deste método Router.post que fizemos naquele ponto de extremidade /login,

233
00:18:25,955 --> 00:18:31,730
eu vou criar um token e passar esse token de volta para o usuário.

234
00:18:31,730 --> 00:18:36,980
Então, aqui, vamos dizer um roteador.post.

235
00:18:38,550 --> 00:18:40,785
Deixe-me criar um token.

236
00:18:40,785 --> 00:18:42,630
Para criar um token,

237
00:18:42,630 --> 00:18:50,150
temos essa função no módulo de autenticação chamado Authenticate.getToken.

238
00:18:51,250 --> 00:18:54,325
Então, lembre-se, que já temos,

239
00:18:54,325 --> 00:18:57,050
para fazer uso disso, é claro,

240
00:18:57,050 --> 00:18:59,210
mesmo antes de começarmos lá,

241
00:18:59,210 --> 00:19:02,750
eu preciso importar o autenticado.

242
00:19:05,940 --> 00:19:17,720
Módulo aqui. Então, vamos dizer autenticar exigir. /autenticar.

243
00:19:18,000 --> 00:19:26,740
Então, então, quando em seu código aqui,

244
00:19:26,740 --> 00:19:29,270
podemos agora dizer Authenticate.getToken,

245
00:19:31,530 --> 00:19:37,585
e o getToken toma parâmetro aqui.

246
00:19:37,585 --> 00:19:41,875
Agora, lembre-se, voltando arquivo authenticate.js.

247
00:19:41,875 --> 00:19:46,665
O arquivo authenticate.js tem um parâmetro aqui

248
00:19:46,665 --> 00:19:53,105
que será usado como a carga útil quando você estiver criando o JSONWebToken.

249
00:19:53,105 --> 00:19:55,785
Então, no arquivo users.js,

250
00:19:55,785 --> 00:19:59,230
vou criar um token dando uma carga útil,

251
00:19:59,230 --> 00:20:02,890
que contém apenas o ID do usuário.

252
00:20:02,890 --> 00:20:06,070
Então, vamos dizer id: req.user. _id.

253
00:20:06,740 --> 00:20:11,940
Isso é suficiente para criar o JSONWebToken.

254
00:20:11,940 --> 00:20:15,315
Não queremos incluir nenhuma outra informação do usuário.

255
00:20:15,315 --> 00:20:18,690
Se você optar por, você pode incluir outras partes das informações do usuário,

256
00:20:18,690 --> 00:20:21,715
mas eu sugiro que mantenha o JSONWebToken pequeno.

257
00:20:21,715 --> 00:20:25,700
O ID do usuário é suficiente porque se você precisa procurar o usuário,

258
00:20:25,700 --> 00:20:32,840
o ID do usuário é suficiente para pesquisar no MongoDB para o usuário.

259
00:20:32,840 --> 00:20:39,230
Então, eu só vou codificar apenas o ID do usuário aqui.

260
00:20:39,230 --> 00:20:44,930
Agora, você sabe que o req.user já estaria presente,

261
00:20:44,930 --> 00:20:50,530
porque quando o passport.authenticate ('local') autenticar com êxito o usuário,

262
00:20:50,530 --> 00:20:54,650
isso irá carregar a propriedade user na mensagem request.

263
00:20:54,650 --> 00:20:57,300
Então, é por isso que eu sou capaz de fazer isso aqui.

264
00:20:57,300 --> 00:21:01,830
Então, isso é o que vou usar para criar o token.

265
00:21:01,900 --> 00:21:05,120
Agora, uma vez que o token é criado,

266
00:21:05,120 --> 00:21:09,720
eu quero passar esse token de volta para o usuário.

267
00:21:09,720 --> 00:21:15,715
Então, no objeto rest.json que estou fornecendo aqui, eu

268
00:21:15,715 --> 00:21:21,755
já estou carregando a verdadeira bandeira de sucesso e também,

269
00:21:21,755 --> 00:21:23,855
uma mensagem de status aqui.

270
00:21:23,855 --> 00:21:28,270
Deixe-me adicionar o token

271
00:21:28,270 --> 00:21:34,880
como uma das propriedades na mensagem de resposta aqui.

272
00:21:36,480 --> 00:21:39,475
Então, o token que eu acabei de criar,

273
00:21:39,475 --> 00:21:47,595
vou passar isso de volta como a segunda propriedade dentro desta string Json aqui.

274
00:21:47,595 --> 00:21:55,370
Então agora, quando meu cliente recebe essa string Json no corpo da mensagem de resposta,

275
00:21:55,370 --> 00:21:59,870
ele pode entrar e extrair o token de lá.

276
00:22:00,140 --> 00:22:05,500
É isso. Então, agora atualizamos o arquivo users.js,

277
00:22:05,500 --> 00:22:08,630
e agora você pode ver como o token será

278
00:22:08,630 --> 00:22:12,690
criado e enviado de volta ao usuário quando o usuário for autenticado com sucesso.

279
00:22:12,690 --> 00:22:16,330
Agora, este esquema também pode ser usado

280
00:22:16,330 --> 00:22:21,250
quando você usa autenticação de terceiros como baseado em OAuth 2.0,

281
00:22:21,250 --> 00:22:23,525
que vamos examinar no próximo módulo.

282
00:22:23,525 --> 00:22:25,695
Agora, o procedimento será semelhante.

283
00:22:25,695 --> 00:22:28,880
Você criará um token quando o usuário for autenticado

284
00:22:28,880 --> 00:22:32,560
pelo provedor de autenticação de terceiros ou OAuth

285
00:22:32,560 --> 00:22:35,640
e, em seguida, passará o token de volta para o usuário,

286
00:22:35,640 --> 00:22:39,010
em uma abordagem semelhante à que você vê aqui.

287
00:22:39,010 --> 00:22:41,285
Agora, uma vez que fizemos isso,

288
00:22:41,285 --> 00:22:44,255
então vamos para o arquivo app.js.

289
00:22:44,255 --> 00:22:53,660
No arquivo app.js, porque incluímos um arquivo de configuração aqui.

290
00:22:53,660 --> 00:22:59,005
Então, deixe-me exigir o arquivo de configuração aqui,

291
00:22:59,005 --> 00:23:06,465
e então a URL que eu estou usando aqui em vez de codificar este URL,

292
00:23:06,465 --> 00:23:11,345
eu vou dizer config.Mongourl.

293
00:23:11,345 --> 00:23:16,680
Então, agora, você vê como meu arquivo config.js pode ser usado como

294
00:23:16,680 --> 00:23:23,520
um lugar centralizado onde eu posso preparar a configuração para o meu aplicativo.

295
00:23:23,520 --> 00:23:29,200
É isso. Então, o que acontece agora é que quando o usuário

296
00:23:29,200 --> 00:23:35,010
se autentica no ponto de extremidade /login e o usuário é autenticado com sucesso,

297
00:23:35,010 --> 00:23:40,840
então o token será criado pelo servidor e enviado de volta para o cliente ou o usuário.

298
00:23:40,840 --> 00:23:43,765
Assim, o cliente incluirá o token em

299
00:23:43,765 --> 00:23:47,765
cada solicitação de entrada subseqüente no cabeçalho de autorização.

300
00:23:47,765 --> 00:23:50,590
Agora, como ele inclui o cabeçalho de autorização?

301
00:23:50,590 --> 00:23:54,220
Vamos voltar para authentic.js e aqui,

302
00:23:54,220 --> 00:24:01,625
você vê que dissemos extractJwt.FromAuthHeaderasBearerToken aqui.

303
00:24:01,625 --> 00:24:06,290
Então, isso será incluído no cabeçalho de autenticação como um token portador.

304
00:24:06,290 --> 00:24:08,385
Vou mostrar-lhe como isso é feito,

305
00:24:08,385 --> 00:24:15,535
em seguida, usamos o carteiro para incluir o token portador no cabeçalho de autenticação.

306
00:24:15,535 --> 00:24:17,690
Agora, quando isso chega,

307
00:24:17,690 --> 00:24:21,060
então você se lembra que logo abaixo aqui,

308
00:24:21,060 --> 00:24:25,095
você configurou este método aqui chamado VerifyUser,

309
00:24:25,095 --> 00:24:30,635
que chama o passaporte autenticar com JWT.

310
00:24:30,635 --> 00:24:34,460
Então, este usa o token que

311
00:24:34,460 --> 00:24:38,620
vem no cabeçalho de autenticação e, em seguida, verifica o usuário.

312
00:24:38,620 --> 00:24:41,980
Então, sempre que eu quiser verificar a autenticidade do usuário,

313
00:24:41,980 --> 00:24:43,855
eu posso simplesmente chamar verificar usuário,

314
00:24:43,855 --> 00:24:49,115
e que irá iniciar a chamada para o passport.authenticate e verificar o sser.

315
00:24:49,115 --> 00:24:50,315
Se isto for bem sucedido,

316
00:24:50,315 --> 00:24:51,800
permitir-me-á prosseguir.

317
00:24:51,800 --> 00:24:55,620
Este procedimento é muito semelhante ao que você fez no

318
00:24:55,620 --> 00:25:01,610
arquivo users.js, onde você chama o mesmo passport.authenticate ('local').

319
00:25:01,720 --> 00:25:04,320
Então, se isso for bem sucedido,

320
00:25:04,320 --> 00:25:05,885
então vá em frente.

321
00:25:05,885 --> 00:25:10,930
Se falhar, a função de autenticação retornará a mensagem de erro

322
00:25:10,930 --> 00:25:16,050
ao cliente dizendo que o usuário não está autorizado.

323
00:25:16,050 --> 00:25:18,345
Então, isso já está resolvido.

324
00:25:18,345 --> 00:25:23,020
Então, agora, que incluímos isso no meu arquivo authenticate.js,

325
00:25:23,020 --> 00:25:26,050
qualquer lugar que eu queira verificar o usuário,

326
00:25:26,050 --> 00:25:27,480
eu posso simplesmente chamar

327
00:25:27,480 --> 00:25:31,210
essa função VerifyUser

328
00:25:31,210 --> 00:25:34,320
que eu especifiquei aqui ou a exportação que eu especifiquei aqui,

329
00:25:34,320 --> 00:25:37,220
que vamos chamar o passport.authenticate usando

330
00:25:37,220 --> 00:25:40,540
a estratégia JWT para autenticar o usuário.

331
00:25:40,540 --> 00:25:42,440
Agora, como fazemos uso disso?

332
00:25:42,440 --> 00:25:47,785
Agora, o que vamos fazer é entrar em cada um de nossos roteadores,

333
00:25:47,785 --> 00:25:56,945
e controlar as opções em todas as rotas que queremos controlar.

334
00:25:56,945 --> 00:26:00,300
Então, voltando para o arquivo app.js, agora,

335
00:26:00,300 --> 00:26:07,925
que nós não estamos usando sessões eu vou remover esta sessão daqui,

336
00:26:07,925 --> 00:26:10,150
porque nós não estamos mais usando sessões.

337
00:26:10,150 --> 00:26:14,990
Da mesma forma, vou remover este passaporte.session daqui também.

338
00:26:14,990 --> 00:26:17,580
Isso também não é necessário.

339
00:26:17,580 --> 00:26:20,430
Além disso, essa autenticação, consulte anteriormente,

340
00:26:20,430 --> 00:26:21,940
quando configurei essa autenticação,

341
00:26:21,940 --> 00:26:25,490
essa autenticação foi aplicada a cada solicitação de entrada.

342
00:26:25,490 --> 00:26:28,705
Agora, eu vou mudar meu aplicativo,

343
00:26:28,705 --> 00:26:35,055
pelo qual eu vou exigir autenticação apenas em certas rotas e não em todas as rotas.

344
00:26:35,055 --> 00:26:39,665
Então, deixe-me remover esta autenticação completamente de app.js.

345
00:26:39,665 --> 00:26:41,995
Então, agora, quando a solicitação chega,

346
00:26:41,995 --> 00:26:45,850
se ela estiver em/endpoint,

347
00:26:45,850 --> 00:26:47,080
o índice será atendido.

348
00:26:47,080 --> 00:26:52,040
Se ele estiver no endpoint /users, ele permitirá que você navegue para

349
00:26:52,040 --> 00:26:57,815
as várias rotas que são montadas no /users no users.js

350
00:26:57,815 --> 00:27:00,900
e, posteriormente, o resto dos outros.

351
00:27:00,900 --> 00:27:03,420
O que vou fazer agora é deixar

352
00:27:03,420 --> 00:27:07,250
a pasta pública aberta para qualquer um acessar.

353
00:27:07,250 --> 00:27:09,145
Agora, em muitas aplicações,

354
00:27:09,145 --> 00:27:10,665
isso pode ser muito bom.

355
00:27:10,665 --> 00:27:13,045
Então, vou deixar isso aberto.

356
00:27:13,045 --> 00:27:14,825
Agora, sobre os pratos,

357
00:27:14,825 --> 00:27:17,920
promoções, e o ponto final dos líderes,

358
00:27:17,920 --> 00:27:20,875
todos os pedidos de obter.

359
00:27:20,875 --> 00:27:28,205
Deixarei que essas pessoas sejam respondidas sem exigir nenhuma autenticação.

360
00:27:28,205 --> 00:27:30,200
Agora, por que eu iria querer fazer isso?

361
00:27:30,200 --> 00:27:33,190
Se um usuário estiver fazendo uma solicitação get,

362
00:27:33,190 --> 00:27:35,455
o usuário só deseja recuperar informações.

363
00:27:35,455 --> 00:27:40,490
Então, por exemplo, no lado do cliente, se eu estou implementando um aplicativo web usando Angular

364
00:27:40,490 --> 00:27:46,290
ou um aplicativo cliente usando Ionic ou script nativo,

365
00:27:46,290 --> 00:27:49,920
então talvez eu queira implementar meu aplicativo

366
00:27:49,920 --> 00:27:54,310
de tal forma que a página principal irá exibir informações já,

367
00:27:54,310 --> 00:27:57,715
a informação genética que você deseja disponibilizar para qualquer pessoa que

368
00:27:57,715 --> 00:28:01,590
visite seu site ou que abra seu aplicativo.

369
00:28:01,590 --> 00:28:04,360
Assim, informações básicas podem ser exibidas lá.

370
00:28:04,360 --> 00:28:08,060
Mas se você quiser alterar qualquer coisa,

371
00:28:08,060 --> 00:28:12,110
então você espera que o usuário seja autenticado.

372
00:28:12,110 --> 00:28:16,255
Assim, você permitirá que as operações POST, operações de

373
00:28:16,255 --> 00:28:21,110
colocação e operações de exclusão sejam feitas somente por usuários autenticados.

374
00:28:21,110 --> 00:28:23,605
Da mesma forma, para comentários, por exemplo,

375
00:28:23,605 --> 00:28:30,280
você pode dizer que os comentários só podem ser postados ou modificados por usuários autenticados.

376
00:28:30,280 --> 00:28:34,570
Assim, você pode restringir apenas algumas rotas para usuários autenticados,

377
00:28:34,570 --> 00:28:37,940
a outra rota que você pode deixá-los abertos. Como é que fazemos isso?

378
00:28:37,940 --> 00:28:41,180
Agora é aqui que o usuário de verificação que

379
00:28:41,180 --> 00:28:45,055
exportamos do arquivo authenticate.js vem a calhar.

380
00:28:45,055 --> 00:28:49,460
Agora, em vez de controlar todos os pontos finais,

381
00:28:49,460 --> 00:28:53,190
todas as várias operações sobre os pratos, promoções

382
00:28:53,190 --> 00:28:54,740
e líderes em pontos,

383
00:28:54,740 --> 00:28:58,240
abriremos apenas as operações get para qualquer um,

384
00:28:58,240 --> 00:29:00,830
mas as

385
00:29:00,830 --> 00:29:04,995
operações post, put e delete serão restritas apenas a usuários autenticados.

386
00:29:04,995 --> 00:29:10,350
Na atribuição, você adicionará mais uma categoria de usuários chamados usuários administradores.

387
00:29:10,350 --> 00:29:15,320
Agora você restringe determinadas operações a serem executadas apenas por usuários administradores.

388
00:29:15,320 --> 00:29:18,460
Assim, por exemplo, modificar os pratos

389
00:29:18,460 --> 00:29:22,530
ou excluir as informações dos pratos do banco de dados,

390
00:29:22,530 --> 00:29:24,600
será restrito apenas aos usuários administrativos.

391
00:29:24,600 --> 00:29:30,000
Mas os usuários básicos podem postar comentários,

392
00:29:30,000 --> 00:29:32,470
modificar os comentários que eles publicaram

393
00:29:32,470 --> 00:29:35,450
e talvez até salvar alguns pratos favoritos.

394
00:29:35,450 --> 00:29:38,520
Faremos essa parte no quarto módulo.

395
00:29:38,520 --> 00:29:42,735
Então, como controlamos rotas específicas?

396
00:29:42,735 --> 00:29:46,210
Então é aqui que temos que ir para cada um dos roteadores

397
00:29:46,210 --> 00:29:50,365
e, em seguida, importar controles em rotas específicas.

398
00:29:50,365 --> 00:29:53,945
Então, vamos começar com a rota dos pratos.

399
00:29:53,945 --> 00:29:55,770
Então, para a rota dos pratos,

400
00:29:55,770 --> 00:29:59,950
você lembrará que isso é controlado no arquivo dishRouter.js.

401
00:29:59,950 --> 00:30:02,515
Então, indo para dishRouter.js,

402
00:30:02,515 --> 00:30:07,450
vamos primeiro importar a autenticação aqui.

403
00:30:07,450 --> 00:30:13,400
Então, vamos dizer, const authenticate

404
00:30:17,010 --> 00:30:24,700
require../authenticate porque este

405
00:30:24,700 --> 00:30:29,110
arquivo authenticator.js está na pasta de nível superior.

406
00:30:29,110 --> 00:30:32,105
Então, lembre-se... autentique aqui.

407
00:30:32,105 --> 00:30:34,505
Então, uma vez que você importar a autenticação,

408
00:30:34,505 --> 00:30:37,965
para a rota do roteador prato para esta rota,

409
00:30:37,965 --> 00:30:42,560
a operação get, eu vou permitir sem qualquer problema.

410
00:30:42,560 --> 00:30:44,820
Então, isso está aberto.

411
00:30:44,820 --> 00:30:47,025
Então eu não vou impor nenhuma restrição.

412
00:30:47,025 --> 00:30:51,750
A partir do post, se quisermos aplicar vários middleware,

413
00:30:51,750 --> 00:30:56,035
podemos simplesmente adicionar o principal dentro deste atrás do outro.

414
00:30:56,035 --> 00:30:58,050
Agora, quando o post é chamado,

415
00:30:58,050 --> 00:31:02,295
agora você está simplesmente executando esta função aqui.

416
00:31:02,295 --> 00:31:04,150
Agora, pouco antes disso,

417
00:31:04,150 --> 00:31:12,400
eu posso entrar e dizer, autenticate.VerifyUser, lá.

418
00:31:12,400 --> 00:31:13,805
Então, o que isso faz?

419
00:31:13,805 --> 00:31:17,210
Isso diz que se uma solicitação de post entrar,

420
00:31:17,210 --> 00:31:20,940
eu primeiro executaria este middleware,

421
00:31:20,940 --> 00:31:24,805
que eu exportei do arquivo authentic.js,

422
00:31:24,805 --> 00:31:26,100
eu primeiro aplico isso, o

423
00:31:26,100 --> 00:31:32,075
que é equivalente a dizer passaporte autenticar JWT e você está verificando o usuário.

424
00:31:32,075 --> 00:31:34,655
Então, se isso for bem sucedido,

425
00:31:34,655 --> 00:31:38,890
então eu vou seguir em frente para fazer o resto.

426
00:31:38,890 --> 00:31:42,955
Se a autenticação falhar neste ponto, em

427
00:31:42,955 --> 00:31:46,290
seguida, a autenticação do passaporte responderá de

428
00:31:46,290 --> 00:31:49,395
volta ao cliente com a mensagem de erro apropriada.

429
00:31:49,395 --> 00:31:51,640
Então isso já é tratado pelo passaporte autenticado,

430
00:31:51,640 --> 00:31:54,350
então eu não tenho que me preocupar com nada além desse ponto.

431
00:31:54,350 --> 00:31:58,300
Se eu cruzei este middleware e, em seguida, começar a

432
00:31:58,300 --> 00:32:02,990
executar a próxima função que significa que a minha autenticação foi bem sucedida,

433
00:32:02,990 --> 00:32:05,560
então eu sou capaz de prosseguir a partir deste ponto.

434
00:32:05,560 --> 00:32:11,760
Então, isso está atuando como a barreira para este método post.

435
00:32:11,760 --> 00:32:14,860
Agora usando o mesmo argumento,

436
00:32:14,860 --> 00:32:21,435
eu posso simplesmente aplicar este middleware particular a todos os outros métodos.

437
00:32:21,435 --> 00:32:23,845
Posso fazer isso com o posto.

438
00:32:23,845 --> 00:32:26,030
Embora neste caso,

439
00:32:26,030 --> 00:32:28,640
colocar não vai estar fazendo nada.

440
00:32:28,640 --> 00:32:30,110
Mas, em qualquer caso,

441
00:32:30,110 --> 00:32:33,980
eu vou simplesmente apenas por uma questão de uniformidade,

442
00:32:33,980 --> 00:32:38,490
Vou aplicar o usuário de verificação para também colocar e, claro

443
00:32:38,490 --> 00:32:41,315
, para excluir também, Vou aplicar colocar.

444
00:32:41,315 --> 00:32:44,805
Da mesma forma, indo para baixo para o /DISHID,

445
00:32:44,805 --> 00:32:48,915
eu vou permitir que para trabalhar sem qualquer problema.

446
00:32:48,915 --> 00:32:52,470
Post, aplicarei o usuário de verificação.

447
00:32:52,470 --> 00:32:59,600
Coloque também vou aplicar o usuário verificar e para excluir também mesmo.

448
00:32:59,600 --> 00:33:09,105
Para o /dishid/comentários, eu vou deixar o get aberto,

449
00:33:09,105 --> 00:33:14,030
está tudo bem para qualquer um para recuperar comentários sobre um prato específico.

450
00:33:14,030 --> 00:33:17,140
Post, vou fechar isso, para

451
00:33:17,140 --> 00:33:21,995
que apenas usuários verificados possam postar comentários.

452
00:33:21,995 --> 00:33:27,710
Coloque também vou fechar isso e excluir também.

453
00:33:29,280 --> 00:33:33,035
Você precisa ir um passo adiante e dizer:

454
00:33:33,035 --> 00:33:38,230
“Somente os usuários que publicaram o comentário podem excluir suas próprias postagens.”

455
00:33:38,230 --> 00:33:40,310
Mas faremos isso no próximo módulo.

456
00:33:40,310 --> 00:33:41,840
No momento, eu vou dizer,

457
00:33:41,840 --> 00:33:44,415
“Ok, um usuário verificado pode excluir qualquer comentário.”

458
00:33:44,415 --> 00:33:46,715
Isso é claro que não é verdade,

459
00:33:46,715 --> 00:33:48,850
podemos colocar um cheque adicional,

460
00:33:48,850 --> 00:33:52,145
mas vamos fazer isso no próximo módulo deste curso.

461
00:33:52,145 --> 00:33:54,405
Então, para excluir também eu aplicar o mesmo.

462
00:33:54,405 --> 00:33:58,060
Mais uma vez, para o roteador prato comentários/comentários Id,

463
00:33:58,060 --> 00:34:00,300
eu vou deixá-lo como aberto.

464
00:34:00,300 --> 00:34:04,485
Post, vou deixá-lo fechado.

465
00:34:04,485 --> 00:34:12,640
Coloque também fechá-lo e, em seguida, para excluir também vou fechar isso fora.

466
00:34:12,640 --> 00:34:14,970
Excluir, claro, como eu disse,

467
00:34:14,970 --> 00:34:19,180
a operação de exclusão deve ser permitido apenas um usuário que

468
00:34:19,180 --> 00:34:24,150
criou o comentário deve ser solicitado

469
00:34:24,150 --> 00:34:27,960
a excluir isso, mas você precisa configurar algumas coisas adicionais para que funcione corretamente,

470
00:34:27,960 --> 00:34:30,825
o que faremos no próximo módulo.

471
00:34:30,825 --> 00:34:36,455
No momento, estamos dizendo que um usuário verificado pode excluir um comentário específico, é isso.

472
00:34:36,455 --> 00:34:42,820
Agora vamos aplicar o mesmo princípio ao roteador promocional e também ao roteador líder.

473
00:34:42,820 --> 00:34:44,950
Então, indo para o roteador promocional,

474
00:34:44,950 --> 00:34:53,100
deixe-me importar autenticar

475
00:34:57,320 --> 00:35:00,870
e, em seguida, get está aberto,

476
00:35:00,870 --> 00:35:03,540
então este é o roteador líder.

477
00:35:03,540 --> 00:35:05,380
Então, ficar aberto.

478
00:35:05,380 --> 00:35:08,365
Post, eu vou controlar isso,

479
00:35:08,365 --> 00:35:12,865
colocar, controlar, excluir, controlar,

480
00:35:12,865 --> 00:35:14,790
roteador líder, ID líder,

481
00:35:14,790 --> 00:35:17,255
ficar tudo bem, postar,

482
00:35:17,255 --> 00:35:22,330
controlado, colocar é controlado e excluir é controlado.

483
00:35:22,330 --> 00:35:24,795
A mesma coisa com o roteador promocional.

484
00:35:24,795 --> 00:35:38,652
Deixe-me, exigir a autenticação

485
00:35:38,652 --> 00:35:43,570
e, em seguida, para a rota get é aberto,

486
00:35:43,570 --> 00:35:47,109
POST é controlado, colocar é controlado,

487
00:35:47,109 --> 00:35:50,790
excluir é controlado, mesma coisa para o promorouter/promoid.

488
00:35:50,790 --> 00:35:54,460
Get é aberto, POST é controlado,

489
00:35:54,460 --> 00:35:58,395
colocar e excluir também são controlados, é isso.

490
00:35:58,395 --> 00:36:00,225
Vamos salvar todas as alterações.

491
00:36:00,225 --> 00:36:02,660
Então, uma vez que concluímos todas as alterações,

492
00:36:02,660 --> 00:36:04,185
vamos salvar as alterações.

493
00:36:04,185 --> 00:36:08,270
Agora, nossa aplicação está pronta para ser testada.

494
00:36:08,270 --> 00:36:11,485
Então, vamos reiniciar o nosso servidor,

495
00:36:11,485 --> 00:36:14,885
ou se o servidor não estiver em execução,

496
00:36:14,885 --> 00:36:16,590
vamos apenas iniciar o servidor.

497
00:36:16,590 --> 00:36:18,770
Indo para o terminal,

498
00:36:18,770 --> 00:36:20,040
meu servidor não está funcionando.

499
00:36:20,040 --> 00:36:23,930
Então, deixe-me iniciar o servidor digitando npm start.

500
00:36:24,620 --> 00:36:28,935
Curiosamente, ele acabou de lançar um erro aqui,

501
00:36:28,935 --> 00:36:32,330
eu só queria ilustrar para vocês que até eu posso cometer erros,

502
00:36:32,330 --> 00:36:34,840
então você verá que há um erro aqui que diz,

503
00:36:34,840 --> 00:36:40,275
“Não é possível encontrar module.authenticate”, e então se eu olhar através do código,

504
00:36:40,275 --> 00:36:45,255
eu acho que esse problema ocorreu no,

505
00:36:45,255 --> 00:36:46,850
Onde isso ocorreu?

506
00:36:46,850 --> 00:36:48,350
Então, eu apenas procuro aqui

507
00:36:48,350 --> 00:36:50,020
e, em algum lugar aqui embaixo,

508
00:36:50,020 --> 00:36:56,130
notei que esse problema ocorreu dentro do meu arquivo users.js.

509
00:36:56,130 --> 00:36:57,870
Então, aqui mesmo, ele diz,

510
00:36:57,870 --> 00:37:00,355
isso está no arquivo users.js.

511
00:37:00,355 --> 00:37:05,655
Então, indo para o arquivo users.js, vamos corrigir isso.

512
00:37:05,655 --> 00:37:09,015
Indo para

513
00:37:09,015 --> 00:37:14,285
o arquivo users.js, bem no topo quando eu precisava autenticar, eu disse,

514
00:37:14,285 --> 00:37:17,555
“.authenticate”, e como eu estava dizendo,

515
00:37:17,555 --> 00:37:21,200
isso deve ser um ponto ponto porque ele está na pasta superior.

516
00:37:21,200 --> 00:37:25,905
Este arquivo users.js na pasta Rotas

517
00:37:25,905 --> 00:37:31,985
e autenticar está na pasta Rota de Projetos, portanto, deve ser autenticar ponto ponto ponto.

518
00:37:31,985 --> 00:37:34,660
Então, se você cometer erros, lá vai você,

519
00:37:34,660 --> 00:37:40,450
é assim que você vai ser lembrado do erro que você introduziu.

520
00:37:40,450 --> 00:37:44,540
Então, vamos salvar as alterações e, em seguida, reiniciar nosso servidor.

521
00:37:44,540 --> 00:37:47,795
Novamente, voltando para esse terminal,

522
00:37:47,795 --> 00:37:54,735
deixe-me iniciar meu servidor e meu servidor agora está funcionando,

523
00:37:54,735 --> 00:38:00,235
vamos para o Postman e depois testar nosso aplicativo.

524
00:38:00,235 --> 00:38:04,695
Agora, no Postman, deixe-me primeiro tentar fazer

525
00:38:04,695 --> 00:38:11,170
um GET no localhost: 3000/pratos e, em seguida, quando eu faço um GET,

526
00:38:11,170 --> 00:38:15,620
ele é bem sucedido porque o ponto final GET não é controlado.

527
00:38:15,620 --> 00:38:18,595
Então eu posso fazer um GET em pratos,

528
00:38:18,595 --> 00:38:23,545
eu posso fazer um GET em promoções,

529
00:38:23,545 --> 00:38:25,420
e tudo funciona muito bem.

530
00:38:25,420 --> 00:38:28,300
Mas se eu tentar fazer um POST em pratos,

531
00:38:28,300 --> 00:38:32,435
então deixe-me encontrar onde eu fiz um POST em pratos.

532
00:38:32,435 --> 00:38:35,245
Aqui eu fiz um POST em pratos.

533
00:38:35,245 --> 00:38:38,030
Então, quando eu tentei fazer um POST em pratos,

534
00:38:38,030 --> 00:38:40,540
ele imediatamente diz não autorizado.

535
00:38:40,540 --> 00:38:47,410
Então meu módulo Passport percebeu que eu não estou autorizado, então eu não tenho permissão para fazer isso,

536
00:38:47,410 --> 00:38:49,825
então é isso que está me lembrando.

537
00:38:49,825 --> 00:38:52,750
Deixe-me limpar os cookies de,

538
00:38:52,750 --> 00:38:57,980
no caso de você encontrar um cookie em seu Postman basta remover o cookie

539
00:38:57,980 --> 00:39:00,410
correspondente ao localhost porque

540
00:39:00,410 --> 00:39:03,815
esse cookie não é mais necessário e não será necessário.

541
00:39:03,815 --> 00:39:06,100
Então, mesmo se eu remover o cookie e depois POST,

542
00:39:06,100 --> 00:39:07,990
ele ainda vai dizer não autorizado.

543
00:39:07,990 --> 00:39:11,715
Então, eu não estou autorizado para fazer essas operações.

544
00:39:11,715 --> 00:39:13,305
Então, eu tenho que fazer login.

545
00:39:13,305 --> 00:39:15,430
Agora, se você tiver feito o exercício anterior,

546
00:39:15,430 --> 00:39:19,390
você teria deixado o usuário que você se inscreveu anteriormente.

547
00:39:19,390 --> 00:39:25,865
Então, por exemplo, você teria inscrito esse usuário específico no exercício anterior,

548
00:39:25,865 --> 00:39:29,530
deixe-me tentar registrar o mesmo usuário novamente e

549
00:39:29,530 --> 00:39:36,090
meu servidor deve reclamar dizendo UserExistsError para que isso signifique que o usuário existe,

550
00:39:36,090 --> 00:39:38,455
então eu não preciso me inscrever novamente.

551
00:39:38,455 --> 00:39:42,290
Se você excluiu o usuário do seu MongoDB,

552
00:39:42,290 --> 00:39:47,275
basta se inscrever esse usuário mais uma vez e, em seguida, vamos fazer login.

553
00:39:47,275 --> 00:39:55,830
Então, vamos enviar uma solicitação de login para esse ponto final.

554
00:39:55,830 --> 00:40:00,640
Então, quando eu enviar a solicitação de login fazendo um POST para o usuário final,

555
00:40:00,640 --> 00:40:03,365
observe o que é retornado pelo meu servidor.

556
00:40:03,365 --> 00:40:06,965
Você imediatamente percebe que na mensagem de resposta

557
00:40:06,965 --> 00:40:10,830
junto com o sinalizador de sucesso e a mensagem de status,

558
00:40:10,830 --> 00:40:13,740
você também recebe um token aqui.

559
00:40:13,740 --> 00:40:16,365
Agora, este token em particular,

560
00:40:16,365 --> 00:40:17,960
eu preciso copiar este token,

561
00:40:17,960 --> 00:40:21,045
porque em meus pedidos subsequentes,

562
00:40:21,045 --> 00:40:23,535
eu precisarei incluir este token.

563
00:40:23,535 --> 00:40:31,610
Então, deixe-me ir para a versão bruta deste e que eu vou copiar este token.

564
00:40:31,610 --> 00:40:33,875
Este token não é nada além de uma longa corda lá,

565
00:40:33,875 --> 00:40:36,260
então deixe-me copiar este token.

566
00:40:36,260 --> 00:40:41,765
Então, agora, se você estiver curioso sobre o que está contido neste token,

567
00:40:41,765 --> 00:40:44,800
o JSON Web Token pode ser examinado.

568
00:40:44,800 --> 00:40:48,140
Há um site específico onde você pode entrar e digitar

569
00:40:48,140 --> 00:40:52,235
seu JSON Web Token e, em seguida, realmente verificar o que está dentro do JSON Web Token.

570
00:40:52,235 --> 00:40:54,980
Vamos fazer isso como o próximo passo.

571
00:40:54,980 --> 00:40:56,685
Em uma janela do navegador,

572
00:40:56,685 --> 00:41:05,565
basta digitar jwt.io e isso o levará a este site chamado JSON Web Token jwt.io.

573
00:41:05,565 --> 00:41:07,590
Se você se lembra, na palestra,

574
00:41:07,590 --> 00:41:10,685
eu tinha mostrado a estrutura do JSON Web Token

575
00:41:10,685 --> 00:41:14,290
e tinha mostrado a você que o JSON Web Token contém três partes: o cabeçalho,

576
00:41:14,290 --> 00:41:18,040
a carga útil e as informações lá.

577
00:41:18,040 --> 00:41:19,730
Agora, neste caso,

578
00:41:19,730 --> 00:41:25,880
a informação está aqui em cima então eu vou

579
00:41:25,880 --> 00:41:33,285
colar meu JSON Web Token neste lado esquerdo,

580
00:41:33,285 --> 00:41:37,270
então deixe-me selecionar isso e, em seguida, colar meu JSON Web Token

581
00:41:37,270 --> 00:41:41,920
no lado esquerdo na parte codificada e, em seguida, no lado direito,

582
00:41:41,920 --> 00:41:46,030
ele está mostrando exatamente o que é dentro do JSON Web Token que acabei de criar.

583
00:41:46,030 --> 00:41:49,580
Então, ele diz que o cabeçalho contém esses dois pedaços de informação.

584
00:41:49,580 --> 00:41:54,090
O aviso de carga que contém o ID

585
00:41:54,090 --> 00:41:59,245
do usuário e, em seguida, a assinatura na parte inferior aqui.

586
00:41:59,245 --> 00:42:03,995
Então, isso é o que está contido dentro do meu JSON Web Token.

587
00:42:03,995 --> 00:42:07,005
Voltando para o Carteiro,

588
00:42:07,005 --> 00:42:12,110
deixe-me tentar pegar os pratos.

589
00:42:12,110 --> 00:42:15,940
Então, quando eu digo GET localhost: 3000/pratos,

590
00:42:15,940 --> 00:42:18,650
ele ainda retornará uma string vazia,

591
00:42:18,650 --> 00:42:23,385
array vazio aqui porque meu banco de dados não o contém.

592
00:42:23,385 --> 00:42:29,635
Então, deixe-me POST um prato no meu banco de dados.

593
00:42:29,635 --> 00:42:33,290
Então, eu vou escolher a operação POST e no corpo,

594
00:42:33,290 --> 00:42:36,095
você vê que eu tenho o meu prato aqui.

595
00:42:36,095 --> 00:42:41,215
No cabeçalho, eu vou adicionar no novo cabeçalho chamado

596
00:42:41,215 --> 00:42:47,240
autorização e você lembra que anteriormente para autorização básica,

597
00:42:47,240 --> 00:42:53,425
você disse básico e, em seguida, você tinha a base 64 cadeia codificada lá.

598
00:42:53,425 --> 00:42:58,970
Se você quiser incluir seu JSON Web Token no cabeçalho de autorização,

599
00:42:58,970 --> 00:43:01,150
porque em nosso código,

600
00:43:01,150 --> 00:43:04,550
dissemos autorização como token portador.

601
00:43:04,550 --> 00:43:08,040
Então, se você quiser incluir o token no cabeçalho de autorização,

602
00:43:08,040 --> 00:43:13,275
na autorização vamos dizer portador e, em seguida, vamos colar

603
00:43:13,275 --> 00:43:19,080
essa string token que acabamos de copiar de nossa solicitação de entrada.

604
00:43:19,080 --> 00:43:21,935
Então, vamos colar a string token lá.

605
00:43:21,935 --> 00:43:24,360
Então, isso é o que será contido

606
00:43:24,360 --> 00:43:29,795
no cabeçalho de autorização da minha solicitação de saída aqui,

607
00:43:29,795 --> 00:43:33,845
solicitação POST de saída aqui.

608
00:43:33,845 --> 00:43:39,970
Então observe, o lado esquerdo diz portador e o lado direito é a string,

609
00:43:39,970 --> 00:43:43,230
o token que eu acabei de copiar

610
00:43:43,230 --> 00:43:48,460
do ponto onde eu fiz login e, em seguida, deixe-me enviar a mensagem POST

611
00:43:48,460 --> 00:43:57,590
agora e meu POST agora é bem sucedido e isso é postado no meu banco de dados.

612
00:43:57,590 --> 00:44:01,115
Agora, se você quiser ter certeza de que ele foi postado,

613
00:44:01,115 --> 00:44:04,555
vamos fazer um GET e quando você fizer um GET,

614
00:44:04,555 --> 00:44:12,935
você pode ver que de fato esse prato foi inserido no meu banco de dados como mostrado aqui.

615
00:44:12,935 --> 00:44:19,260
Então, é assim que você estará fazendo uso de JSON Web Tokens em seu aplicativo.

616
00:44:19,260 --> 00:44:22,230
Então, sempre que você precisar fazer uma

617
00:44:22,230 --> 00:44:25,505
operação POST, PUT ou DELETE em qualquer um dos endpoints,

618
00:44:25,505 --> 00:44:27,010
você estaria encerrando.

619
00:44:27,010 --> 00:44:33,895
Então, deixe-me voltar para este pedido POST aqui.

620
00:44:33,895 --> 00:44:35,890
No cabeçalho, você vai colocar

621
00:44:35,890 --> 00:44:41,540
este campo de autorização e, em seguida, isso seria incluído na autorização,

622
00:44:41,540 --> 00:44:47,540
você vai iniciá-lo com portador e, em seguida, a string token,

623
00:44:47,540 --> 00:44:50,200
depois que o espaço portador,

624
00:44:50,200 --> 00:44:54,215
um único espaço e, em seguida, a string token seguinte a isso.

625
00:44:54,215 --> 00:44:58,310
Então, é assim que suas mensagens de solicitação

626
00:44:58,310 --> 00:45:03,140
carregariam o JSON Web Token no cabeçalho da mensagem de solicitação de saída.

627
00:45:03,140 --> 00:45:08,220
Você também pode incluir o token no corpo da mensagem de solicitação de saída.

628
00:45:08,220 --> 00:45:10,310
Agora, para isso, você terá que configurar

629
00:45:10,310 --> 00:45:18,210
seu servidor express especialmente o JWT extra no

630
00:45:18,210 --> 00:45:21,120
arquivo authenticate.js para aceitá-lo

631
00:45:21,120 --> 00:45:24,455
do corpo para que você lembre que lá vimos que

632
00:45:24,455 --> 00:45:28,890
o JWT extra suporta muitas maneiras diferentes de extrair

633
00:45:28,890 --> 00:45:33,695
o JSON Web Token da entrada solicitação.

634
00:45:33,695 --> 00:45:35,090
Então, lá você precisa especificar,

635
00:45:35,090 --> 00:45:36,670
se você vai ser incluí-lo no corpo,

636
00:45:36,670 --> 00:45:39,115
você precisa especificar essa informação lá.

637
00:45:39,115 --> 00:45:42,395
Agora, os detalhes de como fazer isso você pode consultar

638
00:45:42,395 --> 00:45:49,885
a documentação do módulo Passport JWT para entender como isso é feito.

639
00:45:49,885 --> 00:45:54,610
Neste curso, eu vou simplesmente usar isso no cabeçalho de autorização

640
00:45:54,610 --> 00:45:59,835
como eu tenho mostrado aqui e isso funciona muito bem para a maioria dos casos.

641
00:45:59,835 --> 00:46:02,620
Agora, se você estiver desenvolvendo um aplicativo Web,

642
00:46:02,620 --> 00:46:06,635
um aplicativo Angular ou um aplicativo Ionic ou NativeScript,

643
00:46:06,635 --> 00:46:09,800
você precisa ser capaz de configurar

644
00:46:09,800 --> 00:46:16,615
esse aplicativo pelo qual o JSON Web Token será incluído no cabeçalho de autorização.

645
00:46:16,615 --> 00:46:22,215
Na última lição deste curso,

646
00:46:22,215 --> 00:46:26,255
mostrarei como integrar o cliente e o servidor,

647
00:46:26,255 --> 00:46:29,310
o cliente que você desenvolveu nos cursos anteriores com

648
00:46:29,310 --> 00:46:32,495
o servidor que desenvolvemos neste curso.

649
00:46:32,495 --> 00:46:35,120
Com isso, completamos este exercício.

650
00:46:35,120 --> 00:46:37,940
Neste exercício, vimos como

651
00:46:37,940 --> 00:46:42,200
podemos configurar nosso aplicativo para usar JSON Web Tokens,

652
00:46:42,200 --> 00:46:50,555
e vimos como lidamos com a autenticação do usuário usando o JSON Web Token,

653
00:46:50,555 --> 00:46:55,555
usando o suporte do módulo Passport e do módulo Passport JWT,

654
00:46:55,555 --> 00:46:58,605
e os módulos JSON Web Token Node.

655
00:46:58,605 --> 00:47:01,090
Com isso, completamos este exercício.

656
00:47:01,090 --> 00:47:09,110
Este é um bom momento para você fazer um Git Commit com a mensagem Passport JWT.