1
00:00:01,260 --> 00:00:02,480
‫Jonas: Então,

2
00:00:02,480 --> 00:00:04,560
‫nesta aula, vamos implementar a funcionalidade

3
00:00:04,560 --> 00:00:08,010
‫de login de usuários com base em uma determinada senha

4
00:00:08,010 --> 00:00:09,363
‫e endereço de e-mail.

5
00:00:10,920 --> 00:00:14,520
‫E, assim como antes, o conceito de login de um usuário

6
00:00:14,520 --> 00:00:17,400
‫basicamente significa assinar um token da Web JSON

7
00:00:17,400 --> 00:00:19,760
‫e enviá-lo de volta ao cliente.

8
00:00:19,760 --> 00:00:22,390
‫Mas, neste caso, só emitimos o

9
00:00:22,390 --> 00:00:24,860
‫token caso o usuário realmente exista

10
00:00:24,860 --> 00:00:27,310
‫e a senha esteja correta.

11
00:00:27,310 --> 00:00:29,773
‫Então, vamos começar a implementar isso.

12
00:00:31,480 --> 00:00:36,260
‫Exportações. login é ...

13
00:00:39,090 --> 00:00:42,253
‫solicitar, responder e em seguida.

14
00:00:44,370 --> 00:00:47,060
‫E a primeira coisa é que devemos

15
00:00:47,060 --> 00:00:50,020
‫realmente ler o e-mail e a senha do corpo.

16
00:00:50,020 --> 00:00:54,740
‫Então, digamos que const email é igual a req. corpo. o email.

17
00:00:58,920 --> 00:01:02,070
‫Ok, e agora o eslint nos dá esse aviso, ou

18
00:01:02,070 --> 00:01:04,160
‫na verdade esse erro, e

19
00:01:04,160 --> 00:01:07,080
‫diz que devemos usar a desestruturação de objetos, certo?

20
00:01:07,080 --> 00:01:09,620
‫E então eu deixo isso acontecer aqui de

21
00:01:09,620 --> 00:01:12,620
‫propósito apenas para que eu possa mostrar como podemos

22
00:01:12,620 --> 00:01:14,950
‫fazer isso com a desestruturação ES6.

23
00:01:14,950 --> 00:01:18,490
‫E acho que falei sobre isso antes no curso e

24
00:01:18,490 --> 00:01:20,930
‫também espero que você já esteja familiarizado

25
00:01:20,930 --> 00:01:23,330
‫com o conceito, mas de qualquer

26
00:01:23,330 --> 00:01:25,430
‫maneira, como o nome

27
00:01:25,430 --> 00:01:27,920
‫desta propriedade aqui é o mesmo que

28
00:01:27,920 --> 00:01:30,260
‫o nome da variável, podemos simplesmente

29
00:01:30,260 --> 00:01:34,150
‫fazer como isso e livre-se do nome da propriedade aqui, ok?

30
00:01:34,150 --> 00:01:36,520
‫E também queremos obter a senha.

31
00:01:36,520 --> 00:01:37,930
‫E isso seria o mesmo, então,

32
00:01:37,930 --> 00:01:42,470
‫basicamente, a senha é igual a uma solicitação. corpo. senha.

33
00:01:42,470 --> 00:01:43,647
‫E em

34
00:01:43,647 --> 00:01:47,940
‫vez de fazer isso, podemos simplesmente enviar e-mail e senha.

35
00:01:47,940 --> 00:01:50,250
‫E assim, basicamente

36
00:01:50,250 --> 00:01:54,480
‫criamos essas duas variáveis do objeto body, ok?

37
00:01:54,480 --> 00:01:56,380
‫Basicamente, é assim que

38
00:01:56,380 --> 00:02:00,223
‫o usuário enviará as credenciais de login para que possamos verificar.

39
00:02:01,070 --> 00:02:04,130
‫Ok, e esse processo de verificação tem algumas etapas,

40
00:02:04,130 --> 00:02:05,830
‫então vamos colocá-las aqui

41
00:02:05,830 --> 00:02:07,750
‫antes de começar a codificar.

42
00:02:07,750 --> 00:02:12,030
‫Portanto, primeiro precisamos verificar se

43
00:02:12,030 --> 00:02:17,030
‫o e-mail e as senhas realmente existem, certo?

44
00:02:17,900 --> 00:02:22,900
‫Em seguida, número dois, verifique se o usuário existe,

45
00:02:24,440 --> 00:02:29,440
‫e ao mesmo tempo se a senha está correta.

46
00:02:31,960 --> 00:02:33,943
‫E, em terceiro lugar, se tudo

47
00:02:39,440 --> 00:02:44,440
‫estiver bem, envie o token, ou seja, o token da Web JSON de volta ao cliente.

48
00:02:45,800 --> 00:02:48,490
‫Ok, então o primeiro é muito fácil.

49
00:02:48,490 --> 00:02:53,490
‫Portanto, se não houver e-mail ou senha, queremos enviar uma

50
00:02:56,810 --> 00:03:00,370
‫mensagem de erro ao nosso cliente.

51
00:03:00,370 --> 00:03:02,600
‫Agora, como vamos fazer isso?

52
00:03:02,600 --> 00:03:04,490
‫Bem, vamos fazer isso

53
00:03:04,490 --> 00:03:07,490
‫usando as ferramentas que implementamos na última seção.

54
00:03:07,490 --> 00:03:10,730
‫Então, basicamente, nosso erro de aplicativo, lembra disso?

55
00:03:10,730 --> 00:03:12,977
‫Portanto, vamos simplesmente criar um novo erro

56
00:03:12,977 --> 00:03:15,060
‫aqui, e nosso middleware de tratamento

57
00:03:15,060 --> 00:03:19,190
‫de erros global irá pegá-lo e enviar esse erro de volta ao cliente.

58
00:03:19,190 --> 00:03:22,483
‫E então vamos começar importando esse erro.

59
00:03:23,350 --> 00:03:25,260
‫Então lembre-se que é

60
00:03:25,260 --> 00:03:28,463
‫este aqui da nossa classe AppError, certo?

61
00:03:29,620 --> 00:03:34,620
‫Então, digamos AppError e, em seguida, require.

62
00:03:40,860 --> 00:03:44,150
‫Então, um nível acima daqui, em seguida, nos utilitários e, em

63
00:03:44,150 --> 00:03:45,050
‫seguida, appError.

64
00:03:48,990 --> 00:03:52,430
‫Ok, então precisamos chamar o próximo middleware,

65
00:03:52,430 --> 00:03:56,403
‫e então é aqui que passamos o erro, lembra disso?

66
00:03:57,260 --> 00:04:00,363
‫Então, novo AppError, e

67
00:04:02,510 --> 00:04:07,510
‫a mensagem é: forneça e-mail e senha.

68
00:04:07,530 --> 00:04:12,530
‫E o código de erro HTTP é 400 para solicitação incorreta, certo?

69
00:04:12,720 --> 00:04:14,340
‫E agora eu tenho

70
00:04:14,340 --> 00:04:19,090
‫alguns erros aqui, e isso novamente está me ajudando a consertar alguns bugs.

71
00:04:19,090 --> 00:04:20,710
‫Então, vejo que aqui

72
00:04:20,710 --> 00:04:24,010
‫em cima, novamente, usei-o com um T em vez

73
00:04:24,010 --> 00:04:27,740
‫de D, e se eu salvá-lo agora, está tudo correto.

74
00:04:27,740 --> 00:04:32,393
‫Ok, vamos começar a testar isso agora mesmo.

75
00:04:33,330 --> 00:04:34,700
‫E, para isso,

76
00:04:34,700 --> 00:04:39,700
‫vou simplesmente começar criando um token falso aqui por enquanto, ok.

77
00:04:39,930 --> 00:04:43,287
‫E então vamos dizer res. status 200 para ok.

78
00:04:51,202 --> 00:04:53,573
‫JSON e, claro, como

79
00:04:56,540 --> 00:05:01,010
‫sempre, o status definido como sucesso e também nosso token.

80
00:05:01,010 --> 00:05:02,870
‫E isso é tudo o

81
00:05:02,870 --> 00:05:05,130
‫que vamos enviar como resposta ao login, ok?

82
00:05:05,130 --> 00:05:08,290
‫Portanto, nenhum objeto de usuário, porque isso não é necessário.

83
00:05:08,290 --> 00:05:10,800
‫Tudo o que queremos como resposta para o login é

84
00:05:10,800 --> 00:05:12,140
‫na verdade o token.

85
00:05:12,140 --> 00:05:15,033
‫Isso é tudo que importa quando o usuário faz login.

86
00:05:16,210 --> 00:05:18,960
‫Em seguida, precisamos implementar a rota,

87
00:05:18,960 --> 00:05:23,600
‫então vamos fazer isso novamente em nosso roteador de usuário, ok?

88
00:05:23,600 --> 00:05:27,000
‫E este é realmente muito semelhante a este.

89
00:05:27,000 --> 00:05:30,310
‫Vamos apenas duplicá-lo e, em seguida,

90
00:05:30,310 --> 00:05:34,780
‫substituir a inscrição em ambas as instâncias por login, certo?

91
00:05:34,780 --> 00:05:38,220
‫E, novamente, isso só é válido para uma solicitação de

92
00:05:38,220 --> 00:05:40,360
‫postagem, porque é claro que

93
00:05:40,360 --> 00:05:43,200
‫queremos enviar as credenciais de login no corpo.

94
00:05:43,200 --> 00:05:44,630
‫E então novamente é

95
00:05:44,630 --> 00:05:47,610
‫um post, mas não um get, não um patch, e

96
00:05:47,610 --> 00:05:50,393
‫não um delete, porque isso não faz sentido neste caso.

97
00:05:51,590 --> 00:05:54,033
‫Então, vamos testar agora.

98
00:05:54,970 --> 00:05:57,033
‫Vou copiar este URL aqui também.

99
00:05:58,050 --> 00:06:03,050
‫Vai ser postar, fazer login e depois o corpo,

100
00:06:03,570 --> 00:06:05,140
‫é claro.

101
00:06:05,140 --> 00:06:08,700
‫Então, novamente, raw e JSON.

102
00:06:08,700 --> 00:06:11,443
‫Então, vamos criar um corpo simples aqui.

103
00:06:17,680 --> 00:06:19,960
‫Tudo bem, então vamos tentar

104
00:06:19,960 --> 00:06:22,993
‫enviar sem senha e ver o que acontece.

105
00:06:24,460 --> 00:06:27,470
‫E de fato funciona, então recebemos nossa mensagem

106
00:06:27,470 --> 00:06:30,030
‫aqui: forneça e-mail e senha.

107
00:06:30,030 --> 00:06:31,820
‫E, novamente, como estamos em

108
00:06:31,820 --> 00:06:34,110
‫desenvolvimento, estamos obtendo toda essa pilha de

109
00:06:34,110 --> 00:06:36,910
‫erros aqui, e o erro completo com nosso código

110
00:06:36,910 --> 00:06:39,350
‫de status, o status e também, é claro,

111
00:06:39,350 --> 00:06:41,330
‫dizendo que é um erro operacional.

112
00:06:41,330 --> 00:06:45,840
‫Assim como definimos na seção anterior, ok?

113
00:06:45,840 --> 00:06:48,433
‫Agora vamos tentar o mesmo com a senha.

114
00:06:50,750 --> 00:06:55,750
‫Então, a senha, defina-a como Acho que é essa e, em

115
00:06:56,400 --> 00:06:58,893
‫seguida, livre-se do e-mail.

116
00:07:00,590 --> 00:07:02,950
‫E isso, claro, aciona o mesmo.

117
00:07:02,950 --> 00:07:06,000
‫Ok, e com tudo correto, isso deve funcionar e,

118
00:07:06,000 --> 00:07:08,803
‫de fato, recebemos nosso token falso aqui.

119
00:07:10,300 --> 00:07:12,890
‫Agora, apenas uma coisa que devemos fazer

120
00:07:12,890 --> 00:07:14,880
‫aqui é retornar também.

121
00:07:14,880 --> 00:07:16,790
‫Então, já fizemos isso muitas vezes

122
00:07:16,790 --> 00:07:18,680
‫antes, e deixe-me explicar novamente.

123
00:07:18,680 --> 00:07:21,610
‫É simplesmente porque depois de chamar o

124
00:07:21,610 --> 00:07:24,380
‫próximo middleware, queremos ter certeza de

125
00:07:24,380 --> 00:07:27,873
‫que esta função de login aqui termine imediatamente, certo?

126
00:07:30,260 --> 00:07:32,080
‫E como não tínhamos isso

127
00:07:32,080 --> 00:07:34,560
‫antes, agora você vê esse erro aqui novamente.

128
00:07:34,560 --> 00:07:38,060
‫Então, isso já é meio familiar neste ponto, certo?

129
00:07:38,060 --> 00:07:40,940
‫Portanto, não é possível definir cabeçalhos depois de serem enviados

130
00:07:40,940 --> 00:07:43,360
‫ao cliente, porque, novamente, enviamos duas respostas.

131
00:07:43,360 --> 00:07:47,840
‫Primeiro a resposta de erro e, em seguida, também este código aqui executado, o

132
00:07:47,840 --> 00:07:50,040
‫que obviamente não deveria ter acontecido.

133
00:07:50,040 --> 00:07:52,933
‫E então, novamente, usamos return aqui para consertar isso.

134
00:07:53,790 --> 00:07:57,430
‫Ok, em seguida, vamos verificar se realmente existe um usuário

135
00:07:57,430 --> 00:07:59,870
‫para o e-mail que foi postado.

136
00:07:59,870 --> 00:08:04,870
‫Então const user, e agora vamos usar findOne na verdade, porque

137
00:08:09,940 --> 00:08:13,400
‫desta vez não estamos selecionando um usuário pelo

138
00:08:13,400 --> 00:08:16,650
‫ID, mas pelo seu e-mail, certo?

139
00:08:16,650 --> 00:08:19,460
‫E então precisamos passar aquele

140
00:08:19,460 --> 00:08:24,190
‫objeto de filtro onde podemos dizer e-mail igual a e-mail, ok?

141
00:08:24,190 --> 00:08:25,940
‫Portanto, o campo é chamado de

142
00:08:25,940 --> 00:08:28,270
‫e-mail e a variável também é chamada de e-mail.

143
00:08:28,270 --> 00:08:32,163
‫E assim, no ES6, podemos abreviar isso simplesmente como isso.

144
00:08:33,060 --> 00:08:34,490
‫Antes de prosseguirmos

145
00:08:34,490 --> 00:08:36,110
‫aqui, há algo importante

146
00:08:36,110 --> 00:08:38,520
‫que preciso fazer para a segurança.

147
00:08:38,520 --> 00:08:41,220
‫Deixe-me mostrar isso para você no

148
00:08:41,220 --> 00:08:43,970
‫Postman, onde nos inscrevemos para uma nova conta.

149
00:08:43,970 --> 00:08:46,540
‫E então você vê aqui que na

150
00:08:46,540 --> 00:08:49,810
‫saída do usuário, nós realmente obtemos a senha, ok?

151
00:08:49,810 --> 00:08:52,010
‫Na verdade, está criptografado, mas

152
00:08:52,010 --> 00:08:55,010
‫ainda assim não é uma boa prática vazar

153
00:08:55,010 --> 00:08:57,710
‫os dados da senha para o cliente, certo?

154
00:08:57,710 --> 00:09:01,090
‫Por exemplo, se tivéssemos nosso get todos os usuários

155
00:09:01,090 --> 00:09:03,480
‫aqui, e esta rota ainda não

156
00:09:03,480 --> 00:09:07,170
‫foi implementada, mas se fôssemos obter todos os usuários da

157
00:09:07,170 --> 00:09:09,440
‫coleção, então todos eles teriam

158
00:09:09,440 --> 00:09:12,720
‫a senha visível, e não queremos isso , OK?

159
00:09:12,720 --> 00:09:15,790
‫E então consertar é bem fácil, porque já

160
00:09:15,790 --> 00:09:17,850
‫tínhamos feito isso antes.

161
00:09:17,850 --> 00:09:19,973
‫Tudo o que precisamos fazer

162
00:09:20,820 --> 00:09:25,270
‫é dizer a senha e, em seguida, selecioná-la e defini-la como falsa.

163
00:09:25,270 --> 00:09:28,100
‫E assim, ele nunca aparecerá automaticamente em

164
00:09:28,100 --> 00:09:29,123
‫nenhuma saída.

165
00:09:30,520 --> 00:09:32,520
‫E para me deixar

166
00:09:32,520 --> 00:09:37,023
‫realmente provar isso para você, inscrevendo-se como outra coisa, algo assim.

167
00:09:39,070 --> 00:09:41,920
‫E vamos ver, ah, na verdade já temos

168
00:09:41,920 --> 00:09:45,833
‫um usuário com aquele e-mail, então vamos apenas fazer o test3.

169
00:09:47,300 --> 00:09:50,830
‫E agora a senha ainda está aqui, mas acho

170
00:09:50,830 --> 00:09:54,100
‫que é simplesmente porque poderíamos simplesmente criá-la, este

171
00:09:54,100 --> 00:09:55,610
‫novo documento aqui,

172
00:09:55,610 --> 00:09:58,030
‫e portanto não está realmente selecionando

173
00:09:58,030 --> 00:10:01,460
‫porque não estamos realmente lendo do banco de dados.

174
00:10:01,460 --> 00:10:03,250
‫Então, vamos implementar

175
00:10:03,250 --> 00:10:05,100
‫muito rapidamente essa rota

176
00:10:05,100 --> 00:10:07,690
‫aqui, isso só levará um minuto.

177
00:10:07,690 --> 00:10:10,300
‫Então, só para ver se isso aqui realmente funciona.

178
00:10:10,300 --> 00:10:12,230
‫Porque esta etapa é realmente

179
00:10:12,230 --> 00:10:15,170
‫importante para o que faremos a seguir, certo?

180
00:10:15,170 --> 00:10:18,820
‫Então, vamos seguir em frente e copiar este código de

181
00:10:18,820 --> 00:10:22,000
‫getAllTours, e não copiar realmente, mas o que faremos

182
00:10:22,000 --> 00:10:25,133
‫é bastante semelhante a isso, é claro.

183
00:10:26,750 --> 00:10:28,590
‫Vou simplesmente copiar isso,

184
00:10:28,590 --> 00:10:30,450
‫mas sem os recursos da API.

185
00:10:30,450 --> 00:10:33,700
‫Não estou realmente interessado nisso, certo?

186
00:10:33,700 --> 00:10:35,500
‫E então este eu

187
00:10:35,500 --> 00:10:39,170
‫vou fazer no controlador de usuário, porque obter todos os usuários

188
00:10:39,170 --> 00:10:41,350
‫não tem nada a ver com autenticação.

189
00:10:41,350 --> 00:10:43,570
‫E então, neste caso, o

190
00:10:43,570 --> 00:10:47,020
‫controlador do usuário é o lugar perfeito para fazer isso.

191
00:10:47,020 --> 00:10:49,440
‫Agora é claro que também preciso

192
00:10:49,440 --> 00:10:51,990
‫importar rapidamente o modelo de usuário aqui, então

193
00:10:51,990 --> 00:10:56,580
‫vamos também copiar isso do tourController, que não é o mesmo, mas semelhante.

194
00:10:56,580 --> 00:11:00,550
‫Então, vamos colocar tudo isso em nosso

195
00:11:04,200 --> 00:11:06,370
‫controlador de usuário.

196
00:11:06,370 --> 00:11:09,683
‫Este nós não precisamos, mas também precisamos catchAsync.

197
00:11:10,520 --> 00:11:13,640
‫Ok, então o tour

198
00:11:13,640 --> 00:11:18,400
‫será user, e aqui será userModel, certo?

199
00:11:18,400 --> 00:11:21,420
‫Então aqui temos tours, e aqui e aqui embaixo, então

200
00:11:21,420 --> 00:11:23,790
‫eu pressiono Command + D para selecionar

201
00:11:23,790 --> 00:11:26,033
‫todos eles e mudar para usuários.

202
00:11:27,190 --> 00:11:32,190
‫E então aqui é claro o que estamos aguardando é o usuário. achar.

203
00:11:34,870 --> 00:11:36,320
‫Agora, uma vez

204
00:11:36,320 --> 00:11:41,310
‫que temos um await aqui, precisamos async, então também precisamos em seguida, e

205
00:11:41,310 --> 00:11:42,810
‫já que temos uma

206
00:11:42,810 --> 00:11:46,580
‫async aqui, devemos agrupar tudo em um catch async.

207
00:11:46,580 --> 00:11:47,713
‫Então vamos fazer isso.

208
00:11:50,090 --> 00:11:51,700
‫Ok, e neste ponto

209
00:11:51,700 --> 00:11:53,810
‫isso não é mais nenhuma novidade

210
00:11:53,810 --> 00:11:58,120
‫para você, já estamos acostumados a fazer esse tipo de coisa, certo?

211
00:11:58,120 --> 00:12:00,670
‫Então, isso já deve funcionar neste

212
00:12:00,670 --> 00:12:02,470
‫ponto, então vamos tentar.

213
00:12:02,470 --> 00:12:06,460
‫Portanto, pegue todos os usuários e, agora, de fato, vemos

214
00:12:06,460 --> 00:12:10,030
‫que suas senhas não estão incluídas na saída.

215
00:12:10,030 --> 00:12:13,853
‫E isso é importante porque na verdade, no find, então

216
00:12:15,090 --> 00:12:17,093
‫de volta aqui no AuthController,

217
00:12:18,030 --> 00:12:21,490
‫isso aqui agora também não conterá a senha, ok?

218
00:12:21,490 --> 00:12:23,060
‫E então a saída

219
00:12:23,060 --> 00:12:25,920
‫disso aqui agora também não conterá a senha.

220
00:12:25,920 --> 00:12:28,890
‫Mas precisamos da senha para verificar se

221
00:12:28,890 --> 00:12:30,810
‫ela está correta, certo?

222
00:12:30,810 --> 00:12:34,500
‫E então precisamos selecioná-lo explicitamente também.

223
00:12:34,500 --> 00:12:37,460
‫Portanto, lembre-se de como usamos select antes

224
00:12:37,460 --> 00:12:40,150
‫para simplesmente selecionar alguns campos

225
00:12:40,150 --> 00:12:43,450
‫do banco de dados, apenas os que precisávamos?

226
00:12:43,450 --> 00:12:45,460
‫Agora, neste caso, quando queremos o

227
00:12:45,460 --> 00:12:47,640
‫campo que está por padrão não selecionado,

228
00:12:47,640 --> 00:12:50,853
‫precisamos do usuário plus e, em seguida, o nome do campo.

229
00:12:51,720 --> 00:12:53,610
‫Portanto, senha neste caso.

230
00:12:53,610 --> 00:12:58,220
‫E assim assim, vai voltar na saída, ok?

231
00:12:58,220 --> 00:13:01,750
‫É claro que precisamos aguardar essa

232
00:13:01,750 --> 00:13:06,260
‫consulta e, em seguida, marcar a função como assíncrona.

233
00:13:06,260 --> 00:13:08,140
‫E então,

234
00:13:08,140 --> 00:13:12,010
‫como antes, para evitar aquele feio bloco

235
00:13:12,010 --> 00:13:16,253
‫try catch, envolva toda a função em catchAsync.

236
00:13:18,520 --> 00:13:20,163
‫Tudo bem, faz sentido?

237
00:13:22,170 --> 00:13:26,770
‫Portanto, vamos rapidamente registrar o usuário no console, apenas para

238
00:13:26,770 --> 00:13:28,353
‫ver se funciona.

239
00:13:32,220 --> 00:13:34,033
‫Então, este aqui.

240
00:13:35,460 --> 00:13:39,600
‫Conseguimos nosso sucesso e, de fato, colocamos o usuário aqui.

241
00:13:39,600 --> 00:13:42,650
‫Então, exatamente com o e-mail que acabei de

242
00:13:42,650 --> 00:13:45,830
‫postar, e a senha agora também voltou a ser

243
00:13:45,830 --> 00:13:47,890
‫incluída na saída, certo?

244
00:13:47,890 --> 00:13:51,453
‫E então, novamente, isso é porque o selecionamos explicitamente aqui.

245
00:13:52,490 --> 00:13:54,950
‫E agora é hora de realmente comparar as

246
00:13:54,950 --> 00:13:57,400
‫senhas que temos no banco de dados com

247
00:13:57,400 --> 00:13:59,830
‫as que o usuário acabou de postar.

248
00:13:59,830 --> 00:14:01,930
‫Mas como vamos fazer isso?

249
00:14:01,930 --> 00:14:05,190
‫Porque, por exemplo, a senha

250
00:14:05,190 --> 00:14:09,169
‫pode ser, ou é neste exemplo, pass1234,

251
00:14:09,169 --> 00:14:13,983
‫mas aquela que armazenamos no documento tem esta aparência.

252
00:14:15,040 --> 00:14:17,220
‫Então, como vamos comparar isso?

253
00:14:17,220 --> 00:14:19,960
‫Não há realmente uma maneira de fazer isso, certo?

254
00:14:19,960 --> 00:14:22,300
‫Mas na verdade existe, tudo o

255
00:14:22,300 --> 00:14:25,890
‫que temos que fazer é usar novamente o pacote bcrypt, ok?

256
00:14:25,890 --> 00:14:29,400
‫Portanto, usamos bcrypt para gerar essa senha com hash e

257
00:14:29,400 --> 00:14:31,230
‫também podemos usar o mesmo pacote

258
00:14:31,230 --> 00:14:34,930
‫para comparar basicamente uma senha original como esta aqui com a

259
00:14:34,930 --> 00:14:36,283
‫senha com hash.

260
00:14:37,230 --> 00:14:40,700
‫Claro essa senha aqui, já que está criptografada,

261
00:14:40,700 --> 00:14:43,350
‫não tem como voltar a

262
00:14:43,350 --> 00:14:46,680
‫antiga, então a senha original dessa string, certo?

263
00:14:46,680 --> 00:14:48,150
‫Então esse é o

264
00:14:48,150 --> 00:14:50,550
‫ponto principal de realmente criptografar uma senha.

265
00:14:50,550 --> 00:14:52,410
‫E então a

266
00:14:52,410 --> 00:14:54,890
‫única maneira de fazer isso é

267
00:14:54,890 --> 00:14:58,100
‫para este pacote para este algoritmo criptografar

268
00:14:58,100 --> 00:15:02,210
‫essa senha também, e então compará-la com a criptografada, certo?

269
00:15:02,210 --> 00:15:05,110
‫Então, vamos implementar uma função que fará

270
00:15:05,110 --> 00:15:08,350
‫isso e, para isso, usaremos, novamente, o pacote bcrypt.

271
00:15:08,350 --> 00:15:11,280
‫E faremos isso no modelo de usuário.

272
00:15:11,280 --> 00:15:13,767
‫E você pode perguntar "Por que estamos fazendo

273
00:15:13,767 --> 00:15:16,310
‫isso em um modelo" e não apenas aqui ",

274
00:15:16,310 --> 00:15:19,730
‫mas isso é, novamente, porque isso está realmente relacionado aos próprios dados.

275
00:15:19,730 --> 00:15:22,930
‫E também já temos esse pacote lá, então

276
00:15:22,930 --> 00:15:26,090
‫é mais fácil simplesmente fazer lá.

277
00:15:26,090 --> 00:15:28,663
‫Então, vamos nos livrar dessa string e, em

278
00:15:30,600 --> 00:15:32,360
‫seguida, criar uma função

279
00:15:32,360 --> 00:15:34,580
‫aqui, que irá verificar se a senha

280
00:15:34,580 --> 00:15:37,473
‫fornecida é a mesma que está armazenada no documento.

281
00:15:38,520 --> 00:15:41,100
‫Então, pela primeira vez, vamos criar algo

282
00:15:41,100 --> 00:15:43,000
‫chamado método de instância.

283
00:15:43,000 --> 00:15:46,120
‫Portanto, um método de instância é basicamente um método

284
00:15:46,120 --> 00:15:48,500
‫que estará disponível em todos os documentos

285
00:15:48,500 --> 00:15:50,843
‫de uma determinada coleção, certo?

286
00:15:51,680 --> 00:15:53,320
‫E funciona assim.

287
00:15:53,320 --> 00:15:56,120
‫Então, novamente, é definido

288
00:15:56,120 --> 00:16:01,050
‫em um userSchema, e então dizemos métodos e agora,

289
00:16:01,050 --> 00:16:05,273
‫neste caso, queremos chamar a função correctPassword, certo?

290
00:16:10,340 --> 00:16:12,810
‫Então função, agora essa função vai aceitar

291
00:16:12,810 --> 00:16:14,470
‫um candidatePassword, então a

292
00:16:17,734 --> 00:16:19,650
‫senha que o usuário passa

293
00:16:19,650 --> 00:16:22,347
‫no corpo, e depois também o userPassword, ok?

294
00:16:26,010 --> 00:16:28,590
‫Agora, dentro desses métodos instanciados,

295
00:16:28,590 --> 00:16:31,470
‫uma vez que estão disponíveis no documento,

296
00:16:31,470 --> 00:16:35,430
‫a palavra-chave this realmente aponta para o documento atual.

297
00:16:35,430 --> 00:16:37,610
‫Mas nesse caso, já que

298
00:16:37,610 --> 00:16:42,080
‫temos a senha configurada para selecionar false, então isso aqui, lembra?

299
00:16:42,080 --> 00:16:43,690
‫Ok, e

300
00:16:43,690 --> 00:16:47,920
‫por causa disso, isso. a senha não estará disponível.

301
00:16:47,920 --> 00:16:50,780
‫Idealmente, faríamos assim e, dessa forma,

302
00:16:50,780 --> 00:16:52,360
‫precisaríamos apenas

303
00:16:52,360 --> 00:16:56,130
‫passar a senha candidata e não a senha_de_usuário.

304
00:16:56,130 --> 00:16:58,690
‫Mas, novamente, agora isso não é

305
00:16:58,690 --> 00:17:02,350
‫possível porque a senha não está disponível na saída.

306
00:17:02,350 --> 00:17:03,420
‫E é

307
00:17:03,420 --> 00:17:06,380
‫por isso que também temos que passar a userPassword.

308
00:17:06,380 --> 00:17:07,890
‫Portanto, o objetivo

309
00:17:07,890 --> 00:17:11,030
‫desta função é realmente retornar apenas verdadeiro ou falso.

310
00:17:11,030 --> 00:17:14,000
‫Portanto, basicamente verdadeiro se as senhas forem iguais e

311
00:17:14,000 --> 00:17:15,663
‫falso se não forem.

312
00:17:16,560 --> 00:17:21,410
‫Então volte e bcrypt que já sabemos, e então

313
00:17:21,410 --> 00:17:26,257
‫vamos usar a função de comparação, ok?

314
00:17:26,257 --> 00:17:29,190
‫E a função de comparação é realmente

315
00:17:29,190 --> 00:17:32,200
‫fácil, tudo o que precisamos é passar a

316
00:17:32,200 --> 00:17:37,060
‫senha do candidato e a senha do usuário, não userSchema, senha do usuário, certo?

317
00:17:39,270 --> 00:17:42,090
‫E, assim como a função

318
00:17:42,090 --> 00:17:45,383
‫hash aqui, esta também é uma função assíncrona.

319
00:17:46,270 --> 00:17:50,973
‫E assim como antes de usar o await, e aqui assíncrono.

320
00:17:53,330 --> 00:17:54,940
‫Ok, faz sentido?

321
00:17:54,940 --> 00:17:57,630
‫Portanto, novamente, esta função de comparação aqui

322
00:17:57,630 --> 00:17:59,800
‫simplesmente retornará true se

323
00:17:59,800 --> 00:18:04,470
‫essas duas senhas aqui forem iguais e false se não forem.

324
00:18:04,470 --> 00:18:07,030
‫E, novamente, não podemos

325
00:18:07,030 --> 00:18:10,020
‫compará-los manualmente porque a senha candidata não

326
00:18:10,020 --> 00:18:12,800
‫é hash, então é a senha

327
00:18:12,800 --> 00:18:15,580
‫original vindo do usuário, mas userPassword

328
00:18:15,580 --> 00:18:18,230
‫é, é claro, hash, e sem

329
00:18:18,230 --> 00:18:21,830
‫esta função aqui não teríamos como compará-los, ok?

330
00:18:21,830 --> 00:18:23,990
‫Portanto, aqui retornamos verdadeiro ou falso,

331
00:18:23,990 --> 00:18:26,893
‫agora tudo o que precisamos fazer é realmente chamar

332
00:18:26,893 --> 00:18:28,633
‫esta função no authController.

333
00:18:29,920 --> 00:18:31,873
‫Vamos fechar alguns deles.

334
00:18:34,080 --> 00:18:38,253
‫Tudo bem, então isso aqui estava aqui apenas para demonstração.

335
00:18:41,400 --> 00:18:43,563
‫Então, vamos simplesmente chamar isso de correto

336
00:18:44,400 --> 00:18:47,110
‫e agora lembrar que a função que acabamos de

337
00:18:47,110 --> 00:18:48,670
‫definir é um método instanciado.

338
00:18:48,670 --> 00:18:52,260
‫E, portanto, está disponível em todos os documentos do usuário.

339
00:18:52,260 --> 00:18:54,780
‫E então essa variável aqui agora é

340
00:18:54,780 --> 00:18:57,050
‫um documento do usuário, certo?

341
00:18:57,050 --> 00:19:00,270
‫Porque é o resultado da consulta ao modelo do usuário.

342
00:19:00,270 --> 00:19:03,637
‫E agora podemos dizer usuário. correctPassword.

343
00:19:06,760 --> 00:19:10,650
‫Agora tudo o que precisamos fazer é passar a senha do

344
00:19:10,650 --> 00:19:13,020
‫candidato, que é a senha, lembre-se.

345
00:19:13,020 --> 00:19:17,830
‫Então, este aqui, e então a userPassword.

346
00:19:17,830 --> 00:19:22,830
‫E isso está no usuário. senha, certo?

347
00:19:23,450 --> 00:19:26,373
‫E então isso aqui agora será verdadeiro ou falso.

348
00:19:27,990 --> 00:19:30,810
‫Certo, agora vamos usar essas duas variáveis para

349
00:19:30,810 --> 00:19:33,500
‫descobrir se o usuário existe e a

350
00:19:33,500 --> 00:19:35,200
‫senha está correta.

351
00:19:35,200 --> 00:19:36,710
‫Já descobrimos isso,

352
00:19:36,710 --> 00:19:40,390
‫mas agora precisamos realmente escrever nossa instrução if.

353
00:19:40,390 --> 00:19:45,390
‫Portanto, se não houver usuário ou a senha estiver incorreta, basicamente correto

354
00:19:46,160 --> 00:19:49,853
‫é falso, que é o que isso significa.

355
00:19:50,860 --> 00:19:54,590
‫Nesse caso, queremos, novamente, retornar e ir

356
00:19:54,590 --> 00:19:58,640
‫direto para nosso próximo middleware com um novo

357
00:19:58,640 --> 00:19:59,640
‫AppError.

358
00:20:00,980 --> 00:20:05,973
‫E nesse caso dizendo e-mail ou senha incorretos, ok?

359
00:20:08,990 --> 00:20:11,560
‫E então o código de status

360
00:20:11,560 --> 00:20:14,870
‫é 401, o que significa não autorizado, certo?

361
00:20:14,870 --> 00:20:16,910
‫Agora poderíamos ter feito isso separadamente,

362
00:20:16,910 --> 00:20:18,847
‫primeiro verificando o usuário

363
00:20:18,847 --> 00:20:21,440
‫e, em seguida, verificando a senha correta.

364
00:20:21,440 --> 00:20:24,600
‫Mas, nesse caso, forneceríamos a um invasor

365
00:20:24,600 --> 00:20:28,710
‫potencial informações se o e-mail ou a senha estão incorretos.

366
00:20:28,710 --> 00:20:31,550
‫E assim aqui fica um pouco mais vago.

367
00:20:31,550 --> 00:20:34,830
‫Portanto, não estamos realmente especificando o que está incorreto aqui.

368
00:20:34,830 --> 00:20:37,060
‫Então, se é e-mail ou se é a senha.

369
00:20:37,060 --> 00:20:38,700
‫E se houver algum

370
00:20:38,700 --> 00:20:41,150
‫invasor tentando inserir alguns dados aleatórios, eles

371
00:20:41,150 --> 00:20:43,640
‫não saberão se o e-mail realmente existe

372
00:20:43,640 --> 00:20:47,143
‫ou se é apenas a senha que está errada, certo?

373
00:20:47,990 --> 00:20:50,860
‫Agora, apenas duas coisas aqui, e a

374
00:20:50,860 --> 00:20:53,140
‫primeira é que realmente

375
00:20:53,140 --> 00:20:55,480
‫precisamos aguardar essa função assíncrona, certo?

376
00:20:55,480 --> 00:20:57,470
‫Portanto, lembre-se de que a senha correta

377
00:20:57,470 --> 00:20:59,000
‫é uma função assíncrona

378
00:20:59,000 --> 00:21:01,333
‫e, portanto, aqui também precisamos aguardar por isso.

379
00:21:02,690 --> 00:21:04,530
‫E também tem outro

380
00:21:04,530 --> 00:21:06,980
‫problema, porque esse usuário não existe aqui,

381
00:21:06,980 --> 00:21:10,950
‫então essa próxima linha de código não pode realmente ser executada, ok?

382
00:21:10,950 --> 00:21:13,550
‫Porque, por exemplo, usuário. a senha

383
00:21:13,550 --> 00:21:15,400
‫não estará disponível.

384
00:21:15,400 --> 00:21:18,800
‫E então, na verdade, precisamos mover tudo isso,

385
00:21:18,800 --> 00:21:20,690
‫ou apenas esse

386
00:21:20,690 --> 00:21:24,343
‫código, vamos movê-lo aqui para a instrução if else.

387
00:21:26,740 --> 00:21:29,000
‫Tá bom, e assim assim, se

388
00:21:29,000 --> 00:21:32,550
‫o usuário não existir, então se for verdade, então não

389
00:21:32,550 --> 00:21:34,900
‫vai nem rodar esse código aqui,

390
00:21:34,900 --> 00:21:37,070
‫aí não vai ter problema.

391
00:21:37,070 --> 00:21:40,510
‫Mas se o usuário existir, ele também executará este código

392
00:21:40,510 --> 00:21:43,600
‫e verificará se a senha está realmente correta.

393
00:21:43,600 --> 00:21:45,520
‫E se a senha

394
00:21:45,520 --> 00:21:50,010
‫estiver correta, só nesse caso chegaremos a esse pedaço de código aqui.

395
00:21:50,010 --> 00:21:52,710
‫Então essa é a ideia geral dessa função.

396
00:21:52,710 --> 00:21:55,030
‫Então, basicamente, verificamos os negativos.

397
00:21:55,030 --> 00:21:57,270
‫Portanto, se não houver nenhum e-mail e

398
00:21:57,270 --> 00:21:58,880
‫nenhuma senha, obteremos este erro.

399
00:21:58,880 --> 00:22:01,690
‫Se não houver nenhum usuário ou se houver uma

400
00:22:01,690 --> 00:22:03,540
‫senha errada, crie este erro.

401
00:22:03,540 --> 00:22:05,610
‫Mas se não houve nenhum erro,

402
00:22:05,610 --> 00:22:09,060
‫bem, nesse caso chegamos a esta parte do código, onde

403
00:22:09,060 --> 00:22:10,820
‫agora geramos um token

404
00:22:10,820 --> 00:22:13,490
‫e o enviamos de volta para o usuário.

405
00:22:13,490 --> 00:22:16,740
‫Agora, criar esse token será exatamente a mesma coisa

406
00:22:16,740 --> 00:22:18,500
‫que fizemos antes aqui.

407
00:22:18,500 --> 00:22:20,780
‫E então, em vez de repetir

408
00:22:20,780 --> 00:22:24,210
‫todo esse código, vamos criar uma função para isso, ok?

409
00:22:24,210 --> 00:22:25,840
‫Vou copiar

410
00:22:25,840 --> 00:22:29,427
‫esse código e, em seguida, const signToken,

411
00:22:31,900 --> 00:22:36,090
‫que receberá como única entrada o ID do usuário.

412
00:22:36,090 --> 00:22:41,090
‫Então ID, e ele retornará o token, certo?

413
00:22:43,370 --> 00:22:46,793
‫Portanto, ele simplesmente assinará e retornará imediatamente.

414
00:22:47,700 --> 00:22:50,920
‫Tudo bem, então aqui o

415
00:22:50,920 --> 00:22:55,920
‫que vamos fazer é assinarToken e passar esta ID.

416
00:23:04,970 --> 00:23:09,330
‫E é claro que também precisamos mudar isso aqui, ok?

417
00:23:09,330 --> 00:23:11,750
‫Portanto, defina este ID com este ID, que

418
00:23:11,750 --> 00:23:14,893
‫como você já sabe neste ponto, é o mesmo que este.

419
00:23:15,950 --> 00:23:19,763
‫Tudo bem, então vamos agora fazer o mesmo aqui.

420
00:23:22,547 --> 00:23:26,340
‫signToken e, neste caso, é o usuário. _identificação.

421
00:23:31,300 --> 00:23:33,910
‫Ufa, foi uma

422
00:23:33,910 --> 00:23:37,090
‫longa palestra, vamos agora experimentar.

423
00:23:37,090 --> 00:23:38,363
‫Portanto, agora deve funcionar.

424
00:23:39,250 --> 00:23:43,470
‫Então lembre-se, bem, este é agora outro usuário, mas eu sei que

425
00:23:43,470 --> 00:23:46,030
‫esta é a senha que usei.

426
00:23:46,030 --> 00:23:48,580
‫Então, por enquanto, vamos usar outro,

427
00:23:48,580 --> 00:23:52,003
‫então apenas test12, e vamos ver o que acontece.

428
00:23:53,540 --> 00:23:57,450
‫Vamos esperar, e de fato, e-mail ou senha incorretos.

429
00:23:57,450 --> 00:24:00,230
‫Obviamente, obtemos também nosso 401 e,

430
00:24:00,230 --> 00:24:04,600
‫de fato, isso significa que nosso código já está testando

431
00:24:04,600 --> 00:24:05,933
‫a senha.

432
00:24:06,780 --> 00:24:10,230
‫Portanto, se agora escolhermos a senha correta, ela deve

433
00:24:10,230 --> 00:24:12,793
‫passar, então vamos esperar por isso.

434
00:24:13,760 --> 00:24:16,760
‫Mas, ainda recebemos esse erro.

435
00:24:16,760 --> 00:24:20,453
‫Bem, então vamos simplesmente nos livrar de todos os nossos usuários aqui,

436
00:24:22,170 --> 00:24:24,420
‫apenas para ter certeza de que não

437
00:24:24,420 --> 00:24:28,740
‫há nada a ver com os usuários, e então criar um novo, tudo bem.

438
00:24:33,080 --> 00:24:37,473
‫Então, olá @ jonas e pass1234.

439
00:24:38,710 --> 00:24:42,373
‫Vamos copiar, vou mandar agora.

440
00:24:46,800 --> 00:24:50,070
‫E então essas credenciais agora estão corretas com certeza.

441
00:24:50,070 --> 00:24:52,760
‫Então, se não funcionar agora, há algum tipo de bug.

442
00:24:52,760 --> 00:24:55,870
‫Mas agora funcionou, ótimo.

443
00:24:55,870 --> 00:25:00,090
‫Então, aqui está nosso token, e ele se parece exatamente com antes, então

444
00:25:00,090 --> 00:25:02,483
‫podemos assumir que ele está correto.

445
00:25:03,570 --> 00:25:06,333
‫Agora vamos tentar novamente, deletando isso, ok.

446
00:25:07,810 --> 00:25:10,753
‫E assim com a senha errada não funciona.

447
00:25:11,890 --> 00:25:15,423
‫Agora vamos colocar a senha certa e o e-mail errado, e então

448
00:25:18,230 --> 00:25:19,730
‫obteremos o mesmo erro.

449
00:25:19,730 --> 00:25:21,883
‫E-mail ou senha tão incorretos.

450
00:25:22,930 --> 00:25:25,560
‫E, novamente, se colocarmos tudo de volta,

451
00:25:25,560 --> 00:25:27,560
‫obteremos um novo token.

452
00:25:27,560 --> 00:25:30,810
‫E agora estamos realmente logados no aplicativo.

453
00:25:30,810 --> 00:25:33,580
‫E eu sei que isso pode parecer meio

454
00:25:33,580 --> 00:25:37,340
‫abstrato, então tudo o que realmente obtemos é um token, e isso

455
00:25:37,340 --> 00:25:40,020
‫significa que estamos logados no aplicativo, certo?

456
00:25:40,020 --> 00:25:44,720
‫Mas, bem, é assim que funciona na autenticação sem estado.

457
00:25:44,720 --> 00:25:47,810
‫Mais tarde, quando realmente construirmos o site dinâmico,

458
00:25:47,810 --> 00:25:50,190
‫é claro que ele ficará muito

459
00:25:50,190 --> 00:25:53,900
‫mais visível se o usuário estiver conectado ou desconectado, certo?

460
00:25:53,900 --> 00:25:55,920
‫Mas ainda funcionará nos bastidores

461
00:25:55,920 --> 00:25:57,670
‫usando esse mesmo token.

462
00:25:57,670 --> 00:26:01,560
‫Então, se não houver um token, o site terá uma aparência,

463
00:26:01,560 --> 00:26:03,800
‫e se houver um token, o

464
00:26:03,800 --> 00:26:06,630
‫site terá uma aparência diferente, com a imagem

465
00:26:06,630 --> 00:26:11,150
‫do usuário e o nome de usuário ali mesmo no site, por exemplo.

466
00:26:11,150 --> 00:26:13,373
‫De qualquer forma, esta foi uma palestra bastante longa.

467
00:26:14,370 --> 00:26:17,100
‫Certifique-se de voltar aqui e realmente tentar

468
00:26:17,100 --> 00:26:20,210
‫entender todo esse código que temos aqui, certo?

469
00:26:20,210 --> 00:26:21,870
‫Porque eu sei que algumas

470
00:26:21,870 --> 00:26:23,660
‫dessas coisas podem ser um pouco confusas.

471
00:26:23,660 --> 00:26:26,963
‫Por exemplo, esta função correctPassword aqui.

472
00:26:27,850 --> 00:26:30,933
‫E então tenho certeza que tudo fará sentido para você.