1
00:00:03,710 --> 00:00:10,135
Esta é a segunda parte do Exercício de Sessões Expressas.

2
00:00:10,135 --> 00:00:12,320
Concluímos a primeira parte anteriormente, em

3
00:00:12,320 --> 00:00:15,310
que adicionamos suporte para Sessões Expressas

4
00:00:15,310 --> 00:00:20,340
e usamos Sessões Expressas como uma forma de rastrear os usuários no lado do servidor

5
00:00:20,340 --> 00:00:24,160
e reconhecer as solicitações recebidas dos usuários.

6
00:00:24,160 --> 00:00:30,930
Neste exercício, não estamos nos concentrando tanto em Sessões Expressas,

7
00:00:30,930 --> 00:00:36,605
mas veremos uma maneira de estender nosso servidor de API REST expresso para oferecer suporte a

8
00:00:36,605 --> 00:00:42,435
um novo modelo para registrar e autenticar usuários.

9
00:00:42,435 --> 00:00:48,635
Então, vamos introduzir um novo modelo de usuário e esquema em nossa aplicação.

10
00:00:48,635 --> 00:00:52,295
Já temos a rota de usuários de barra que

11
00:00:52,295 --> 00:00:57,290
o gerador expresso já montou o roteador de um usuário.

12
00:00:57,290 --> 00:01:00,035
Então, vamos aproveitar isso e, em seguida,

13
00:01:00,035 --> 00:01:03,205
atualizá-lo para suportar o registro de novos usuários,

14
00:01:03,205 --> 00:01:05,390
autenticar um usuário existente

15
00:01:05,390 --> 00:01:11,695
e também fazer logout de um usuário do nosso site de servidor.

16
00:01:11,695 --> 00:01:17,915
Então, vamos olhar para Express Sessions como uma maneira de rastrear os usuários uma vez que o usuário fizer login

17
00:01:17,915 --> 00:01:19,820
e, em seguida, quando

18
00:01:19,820 --> 00:01:22,680
o usuário sair, a sessão será removida do sistema.

19
00:01:22,680 --> 00:01:27,480
Então, como vamos fazer essa extensão neste exercício?

20
00:01:27,480 --> 00:01:29,700
Vamos descobrir.

21
00:01:29,800 --> 00:01:35,485
Continuando com o nosso servidor Express REST API,

22
00:01:35,485 --> 00:01:41,835
vamos agora entrar nos modelos e adicionar um novo arquivo chamado user.js.

23
00:01:41,835 --> 00:01:46,440
Este é o arquivo onde vamos criar o esquema do usuário e o modelo.

24
00:01:46,440 --> 00:01:51,405
Vamos criar um esquema de usuário simples que rastreia o nome de usuário e senha,

25
00:01:51,405 --> 00:01:55,520
e também um sinalizador que é definido para indicar

26
00:01:55,520 --> 00:01:59,540
se o usuário é um administrador ou um usuário normal.

27
00:01:59,540 --> 00:02:03,660
Então, esta é uma maneira de distinguir entre diferentes tipos de usuários.

28
00:02:03,660 --> 00:02:07,210
Então, neste arquivo,

29
00:02:07,210 --> 00:02:16,510
vamos primeiro exigir Mangusto porque estamos criando um esquema Mangusto,

30
00:02:16,510 --> 00:02:26,710
e então vamos criar um esquema chamado esquema Mangusto,

31
00:02:26,710 --> 00:02:29,720
e então vamos dizer var usuário.

32
00:02:29,720 --> 00:02:32,870
Então este é o esquema de usuário que vamos criar,

33
00:02:32,870 --> 00:02:38,150
e vamos dizer novo esquema de usuário.

34
00:02:38,150 --> 00:02:42,740
O esquema do usuário será definido como eu acabei de mencionar,

35
00:02:42,740 --> 00:02:47,705
com três campos aqui chamados nome de usuário

36
00:02:47,705 --> 00:02:55,755
que obviamente seria do tipo string,

37
00:02:55,755 --> 00:02:59,290
e este é um campo obrigatório,

38
00:02:59,290 --> 00:03:03,975
e este é um campo único.

39
00:03:03,975 --> 00:03:07,580
Você não quer dois usuários com o mesmo nome de usuário em seu sistema,

40
00:03:07,580 --> 00:03:12,810
então criamos o nome de usuário e, em seguida, o segundo campo é o campo de senha.

41
00:03:12,810 --> 00:03:15,259
Agora, é claro, você pode estender

42
00:03:15,259 --> 00:03:19,820
este esquema de usuário para permitir que o usuário rastreie todo o seu perfil,

43
00:03:19,820 --> 00:03:23,985
mas vamos fazer isso em um dos exercícios posteriores, para o momento,

44
00:03:23,985 --> 00:03:30,604
um usuário é reconhecido dentro do sistema simplesmente pelo nome de usuário e senha.

45
00:03:30,604 --> 00:03:36,290
Então, a senha é do tipo string e, em seguida, é necessária.

46
00:03:37,300 --> 00:03:44,320
O terceiro campo que vou usar é chamado de administrador.

47
00:03:44,320 --> 00:03:48,025
Então, o administrador é do tipo booleano,

48
00:03:48,025 --> 00:03:58,270
e vamos dizer default false.

49
00:03:58,270 --> 00:04:02,905
Assim, por padrão, quando um usuário é criado,

50
00:04:02,905 --> 00:04:04,830
um novo usuário é criado,

51
00:04:04,830 --> 00:04:06,855
o sinalizador admin será definido como false.

52
00:04:06,855 --> 00:04:09,925
Você pode defini-la explicitamente como true a partir de

53
00:04:09,925 --> 00:04:14,605
seu código para marcar um usuário como um usuário administrativo.

54
00:04:14,605 --> 00:04:18,460
Talvez você possa fornecer privilégios adicionais a um usuário administrativo,

55
00:04:18,460 --> 00:04:21,230
ou talvez permitir que o usuário administrador execute

56
00:04:21,230 --> 00:04:24,810
determinadas operações que os usuários normais não fariam isso.

57
00:04:24,810 --> 00:04:27,760
Vamos olhar para isso em um dos exercícios posteriores,

58
00:04:27,760 --> 00:04:31,500
para o momento, este é o esquema de usuário que criamos,

59
00:04:31,500 --> 00:04:38,150
vamos criar um módulo fora disso e exportar a partir

60
00:04:38,150 --> 00:04:47,075
deste módulo um modelo Mangusto do nome usuário.

61
00:04:47,075 --> 00:04:51,115
Então, este é o modelo Mangusto e o esquema é

62
00:04:51,115 --> 00:04:55,840
o esquema do usuário que acabamos de definir um pouco mais cedo.

63
00:04:55,840 --> 00:05:00,615
Então, é assim que definimos nosso esquema de usuário.

64
00:05:00,615 --> 00:05:03,770
Então, agora que definimos nosso esquema de usuário,

65
00:05:03,770 --> 00:05:08,660
vamos para o roteador que já foi configurado

66
00:05:08,660 --> 00:05:15,610
pelo express generator quando ele gerar esta aplicação express.

67
00:05:15,610 --> 00:05:17,775
Então, se você entrar na pasta rotas,

68
00:05:17,775 --> 00:05:20,890
você verá este arquivo chamado users.js.

69
00:05:20,890 --> 00:05:26,780
Então, este arquivo users.js será estendido para criar o roteador.

70
00:05:26,780 --> 00:05:36,720
Então, bem ali o que eu vou fazer é importar corpo-parser,

71
00:05:41,510 --> 00:05:46,395
e então eles vão declarar o roteador express,

72
00:05:46,395 --> 00:05:50,145
e então vamos dizer também importar

73
00:05:50,145 --> 00:05:57,100
o esquema de usuário e

74
00:05:57,100 --> 00:06:03,420
modelo de modelos de usuário,

75
00:06:03,950 --> 00:06:09,220
e então para o roteador expresso vamos dizer,

76
00:06:09,220 --> 00:06:13,380
roteador usar body analisador.

77
00:06:16,190 --> 00:06:20,690
Então, agora que declaramos o analisador de corpo lá,

78
00:06:20,690 --> 00:06:23,650
vamos deixar esta parte como tal,

79
00:06:23,650 --> 00:06:28,040
mais tarde vamos modificar isso para permitir que o administrador

80
00:06:28,040 --> 00:06:30,470
seja capaz de recuperar

81
00:06:30,470 --> 00:06:33,750
todos os usuários que estão registrados no sistema, mas no momento,

82
00:06:33,750 --> 00:06:37,705
vamos deixar essa rota como tal.

83
00:06:37,705 --> 00:06:40,500
Vamos adicionar mais algumas rotas aqui,

84
00:06:40,500 --> 00:06:42,965
então vamos dizer, “Postagem do roteador”.

85
00:06:42,965 --> 00:06:49,970
Então, apoiaremos a operação de postagem em uma rota chamada inscrição e, como você espera,

86
00:06:49,970 --> 00:06:55,790
essa rota de inscrição permitirá que um usuário se

87
00:06:55,790 --> 00:07:04,920
inscreva no sistema, então isso suportará a inscrição do usuário.

88
00:07:04,920 --> 00:07:08,355
Então, vamos dizer, “Rec, res, próximo.”

89
00:07:08,355 --> 00:07:16,090
Portanto, este seria o registro de postagem do roteador,

90
00:07:16,590 --> 00:07:23,410
os métodos restantes não serão permitidos na parte final do cadastro.

91
00:07:23,410 --> 00:07:25,865
Então, para acessar isso,

92
00:07:25,865 --> 00:07:31,420
uma vez que este roteador de usuários é montado em usuários de barra,

93
00:07:31,420 --> 00:07:35,645
nós especificaríamos este ponto final como usuários de barra barra inscrição,

94
00:07:35,645 --> 00:07:41,765
e este é o ponto final que será usado para registrar novos usuários dentro do sistema.

95
00:07:41,765 --> 00:07:45,080
Então, a primeira coisa que vamos fazer é usar

96
00:07:45,080 --> 00:07:53,300
o método do usuário e a expectativa é que para um usuário para se inscrever,

97
00:07:53,300 --> 00:07:58,145
o nome de usuário e senha será fornecido como uma string JSON

98
00:07:58,145 --> 00:08:03,185
dentro do corpo da solicitação de post de entrada.

99
00:08:03,185 --> 00:08:05,160
Então, a partir do corpo,

100
00:08:05,160 --> 00:08:09,200
uma vez que o corpo já teria sido analisado pelo analisador de corpo,

101
00:08:09,200 --> 00:08:10,370
então a partir do corpo,

102
00:08:10,370 --> 00:08:13,920
irá primeiro verificar para se certificar de que

103
00:08:13,920 --> 00:08:22,130
o usuário com esse nome de usuário não existe dentro do sistema.

104
00:08:22,130 --> 00:08:24,380
Se o usuário com esse nome de usuário existir,

105
00:08:24,380 --> 00:08:26,900
então você está tentando registrar um usuário duplicado

106
00:08:26,900 --> 00:08:29,715
e isso não deve ser permitido no sistema.

107
00:08:29,715 --> 00:08:37,340
Então, vamos dizer, “Usuários encontram um”, e então vamos tentar descobrir se

108
00:08:37,340 --> 00:08:41,090
há um usuário com o nome de usuário que foi

109
00:08:41,090 --> 00:08:45,405
selecionado pelo cliente que está tentando registrar um novo usuário.

110
00:08:45,405 --> 00:08:47,020
Se o usuário já existe,

111
00:08:47,020 --> 00:08:51,850
então obviamente você não permitirá que o novo usuário se inscreva com o mesmo nome de usuário.

112
00:08:51,850 --> 00:08:55,665
Então, vamos dizer, “Então usuário.”

113
00:08:55,665 --> 00:09:03,295
Então, isso retornará o usuário aqui e dentro deste campo de usuário,

114
00:09:03,295 --> 00:09:09,080
então vamos verificar se o usuário já existe,

115
00:09:09,080 --> 00:09:12,350
e então deixe-me pegar o erro aqui.

116
00:09:12,350 --> 00:09:19,140
Então vamos dizer, “Erro de captura” e, em seguida, “próximo erro”.

117
00:09:19,140 --> 00:09:26,160
Então, vamos apenas passar isso para o manipulador de erros lá.

118
00:09:26,160 --> 00:09:33,345
Então, se essa pesquisa para o usuário retorna o campo de usuário,

119
00:09:33,345 --> 00:09:40,460
se o usuário não for igual a null.

120
00:09:40,460 --> 00:09:45,170
Então, se o usuário que é retornado por esta pesquisa

121
00:09:45,170 --> 00:09:50,510
não é nulo, então isso significa que o usuário com esse nome de usuário dado já existe,

122
00:09:50,510 --> 00:09:53,420
então você não deve permitir uma inscrição duplicada.

123
00:09:53,420 --> 00:09:58,765
Então, vamos dizer, “Var err novo erro.”

124
00:09:58,765 --> 00:10:09,075
E nós diremos, “Usuário req. body username.”

125
00:10:09,075 --> 00:10:15,410
Já existe. Então, basicamente,

126
00:10:15,410 --> 00:10:20,565
você está impedindo que um usuário duplicado se inscreva e então vamos dizer

127
00:10:20,565 --> 00:10:29,280
err.status 403 versus o proibido e, em seguida, sair,

128
00:10:29,280 --> 00:10:33,735
chamando o manipulador de erros, próximo erro. Caso

129
00:10:33,735 --> 00:10:36,880
contrário, isso significa que o usuário não existe

130
00:10:36,880 --> 00:10:39,670
, portanto, você deve permitir que o usuário seja desconectado.

131
00:10:39,670 --> 00:10:41,950
Então, na outra parte,

132
00:10:41,950 --> 00:10:46,150
diremos, retorne user.create ().

133
00:10:47,200 --> 00:10:56,165
Vamos criar um novo usuário com o nome de usuário definido como req.body.username

134
00:10:56,165 --> 00:11:02,555
e, em seguida, deixe-me colocar isso na próxima linha para que fique mais claro para você,

135
00:11:02,555 --> 00:11:09,620
e vamos dizer senha: req.body.password.

136
00:11:09,620 --> 00:11:14,550
Agora, nós já sabemos que o sinalizador admin por padrão será definido como false,

137
00:11:14,550 --> 00:11:17,700
então vamos deixá-lo como tal,

138
00:11:17,730 --> 00:11:28,175
e isso permitirá que nosso novo usuário seja registrado e quando o novo usuário for registrado,

139
00:11:28,175 --> 00:11:37,880
isso retornará uma promessa e dentro do “então” vamos lidar com essa promessa aqui.

140
00:11:37,880 --> 00:11:41,460
Então, isso vai devolver a promessa

141
00:11:41,460 --> 00:11:45,625
deste “então” e então vamos lidar com isso no próximo “então” aqui.

142
00:11:45,625 --> 00:12:02,120
Dirá então, Res.statusCode é 200,

143
00:12:02,120 --> 00:12:10,640
Res.setHeader e vamos dizer Content-type application/json

144
00:12:19,830 --> 00:12:38,000
e vamos dizer, res.json (status: Registro bem-sucedido),

145
00:12:42,960 --> 00:12:45,760
e se você quiser,

146
00:12:45,760 --> 00:12:49,659
podemos carregar o usuário

147
00:12:49,659 --> 00:12:58,270
nesta mensagem de resposta aqui como uma propriedade no json.

148
00:13:02,790 --> 00:13:06,890
Vai dizer Registro bem-sucedido.

149
00:13:07,830 --> 00:13:14,950
Então, se houver um erro

150
00:13:14,950 --> 00:13:22,790
nesta operação, dirá “próximo erro”.

151
00:13:22,790 --> 00:13:25,200
Então isso vai lidar com o erro.

152
00:13:25,440 --> 00:13:29,220
Se a promessa não resolver com sucesso,

153
00:13:29,220 --> 00:13:32,020
então será tratado por isso. Então é isso.

154
00:13:32,020 --> 00:13:36,150
Então aqui, temos uma maneira de o usuário se inscrever.

155
00:13:36,150 --> 00:13:38,280
Então, para que o usuário se inscreva,

156
00:13:38,280 --> 00:13:46,570
o usuário fará uma postagem em /users/signup e no corpo da mensagem,

157
00:13:46,570 --> 00:13:51,810
o cliente incluirá uma string json

158
00:13:51,810 --> 00:13:57,760
com propriedades de nome de usuário e senha nessa string json.

159
00:13:57,760 --> 00:14:01,200
É assim que você se inscreve para um novo usuário.

160
00:14:01,200 --> 00:14:06,135
Agora, vamos ver como vamos fazer login no usuário.

161
00:14:06,135 --> 00:14:14,605
Agora, ainda usaremos as sessões Express que fizemos anteriormente para rastrear o usuário.

162
00:14:14,605 --> 00:14:24,270
Então, para registrar um usuário dirá “router.post” no ponto final/login.

163
00:14:24,820 --> 00:14:29,370
Então, no endpoint /login,

164
00:14:32,280 --> 00:14:35,800
faremos um roteador.post.

165
00:14:35,800 --> 00:14:42,460
Vamos, obviamente, em vez de dizer função,

166
00:14:42,460 --> 00:14:48,575
você pode usar a função seta aqui para o router.post,

167
00:14:48,575 --> 00:14:50,780
eu vou fazer a mesma coisa aqui.

168
00:14:50,780 --> 00:14:53,930
Apaixonei-me por funções de seta.

169
00:14:53,930 --> 00:14:57,125
Então, vamos fazer uma função de seta aqui.

170
00:14:57,125 --> 00:15:00,080
Então, para o login, como o login prossegue?

171
00:15:00,080 --> 00:15:01,880
Então, para o login,

172
00:15:01,880 --> 00:15:10,850
o que vamos fazer é que vamos para o arquivo app.js e, em seguida, dentro desta auth,

173
00:15:11,760 --> 00:15:17,050
nós estávamos fazendo esse registro para o usuário lá.

174
00:15:17,050 --> 00:15:20,315
Então, o que eu vou fazer é copiar

175
00:15:20,315 --> 00:15:25,730
tudo isso porque eu não estaria fazendo tudo isso de qualquer maneira.

176
00:15:25,730 --> 00:15:32,970
Então, em vez disso, deixe-me copiar todo o caminho a partir deste ponto para o req.session.user.

177
00:15:32,970 --> 00:15:36,925
Então, a parte if de req.session.user que vou copiar

178
00:15:36,925 --> 00:15:44,120
e, em seguida, chegar ao users.js e para o login.

179
00:15:44,120 --> 00:15:47,305
É exatamente como vou fazer a autenticação.

180
00:15:47,305 --> 00:15:51,025
Então, vamos dizer se não req.session.user.

181
00:15:51,025 --> 00:15:55,965
Então isso significa que o usuário ainda não se autenticou.

182
00:15:55,965 --> 00:15:59,420
Em seguida, você espera que a autenticação básica como

183
00:15:59,420 --> 00:16:02,780
um mecanismo para o usuário usar para autenticação.

184
00:16:02,780 --> 00:16:07,890
Então vamos dizer var AuthHeader se! AuthHeader, em seguida, vamos levantar o erro,

185
00:16:07,890 --> 00:16:17,760
caso contrário, vamos recuperar o nome de usuário e senha do cabeçalho.

186
00:16:17,760 --> 00:16:25,235
Agora, aqui estávamos fazendo se nome de usuário é igual a admin e senha é igual a senha.

187
00:16:25,235 --> 00:16:30,535
Mas agora, o que vamos fazer é procurar no

188
00:16:30,535 --> 00:16:36,695
banco de dados para ver se esse usuário em particular existe.

189
00:16:36,695 --> 00:16:39,595
Então, em vez de fazer isso aqui,

190
00:16:39,595 --> 00:16:42,995
em vez de fazer isso se nome de usuário e senha,

191
00:16:42,995 --> 00:16:48,380
vamos dizer, user.findOne

192
00:16:49,650 --> 00:16:56,020
e vamos dizer nome de usuário é nome de usuário.

193
00:16:56,020 --> 00:17:00,730
Então, esta propriedade é igual a este nome de usuário que acabamos de recuperar

194
00:17:00,730 --> 00:17:06,820
e, em seguida, vamos dizer então usuário.

195
00:17:09,770 --> 00:17:18,600
Então, dentro deste “então”.

196
00:17:18,600 --> 00:17:23,110
Então eu vou mover este código dentro deste “então” porque

197
00:17:23,110 --> 00:17:28,395
agora o que eu vou verificar é agora que eu recuperei o usuário,

198
00:17:28,395 --> 00:17:35,625
eu preciso verificar para ter certeza de que este usuário é exatamente o que eu estou procurando.

199
00:17:35,625 --> 00:17:37,405
Então, neste ponto,

200
00:17:37,405 --> 00:17:42,485
vamos primeiro verificar para garantir que o usuário não é nulo.

201
00:17:42,485 --> 00:17:49,915
Então, vamos dizer se o usuário é nulo.

202
00:17:49,915 --> 00:17:51,390
Então, se o usuário é nulo,

203
00:17:51,390 --> 00:17:55,930
então o que significa que não conseguimos encontrar um usuário com esse nome de usuário específico.

204
00:17:55,930 --> 00:17:59,860
Então, você terá que retornar um erro aqui.

205
00:17:59,860 --> 00:18:04,540
Então deixe-me apenas copiar esta parte e, em seguida, colá-lo

206
00:18:04,540 --> 00:18:09,840
aqui e, em seguida, vamos voltar dizendo var novo erro

207
00:18:09,840 --> 00:18:14,575
e vamos dizer nome de

208
00:18:14,575 --> 00:18:23,120
usuário espaço

209
00:18:23,580 --> 00:18:28,750
não existe.

210
00:18:28,750 --> 00:18:30,600
Então, neste caso,

211
00:18:30,600 --> 00:18:35,230
este usuário não existe então eu vou apenas remover esta parte e,

212
00:18:35,230 --> 00:18:41,840
em seguida, o status de erro correspondente seria 403 aqui.

213
00:18:42,450 --> 00:18:44,960
Então esta é a primeira parte.

214
00:18:44,960 --> 00:18:55,000
Se o usuário é nulo, então estamos obviamente indo para dizer que o usuário não existe.

215
00:18:55,000 --> 00:19:03,780
A segunda parte que vamos verificar é Else se senha de usuário.

216
00:19:03,780 --> 00:19:06,800
Então, o que significa que o usuário existe neste momento.

217
00:19:06,800 --> 00:19:12,420
Então, a segunda verificação que faremos é que a senha do usuário não é

218
00:19:12,420 --> 00:19:22,330
igual a senha então.

219
00:19:22,330 --> 00:19:25,090
Mais uma vez precisamos indicar o erro lá.

220
00:19:25,090 --> 00:19:28,820
Portanto, o erro seria dizer,

221
00:19:29,790 --> 00:19:34,570
neste caso, diremos

222
00:19:34,570 --> 00:19:41,390
“sua senha está incorreta”.

223
00:19:41,390 --> 00:19:44,085
Então essa é a segunda parte aqui.

224
00:19:44,085 --> 00:19:49,650
Então sua senha está incorreta e, em seguida, a última parte.

225
00:19:49,650 --> 00:19:52,515
Vamos dizer “outro”.

226
00:19:52,515 --> 00:19:59,755
Então deixe-me recuar este código.

227
00:19:59,755 --> 00:20:05,775
Então senão se

228
00:20:05,775 --> 00:20:15,815
user.username é nome de usuário que obviamente deve ser verdadeiro neste caso.

229
00:20:15,815 --> 00:20:17,990
Em seguida, a segunda parte,

230
00:20:17,990 --> 00:20:27,620
user.password é igual a senha que também obviamente deve estar correta neste ponto.

231
00:20:27,620 --> 00:20:29,720
Mas, em qualquer caso,

232
00:20:29,720 --> 00:20:38,885
vou verificar esse problema aqui e isso não ocorrerá neste caso.

233
00:20:38,885 --> 00:20:41,695
Então, no momento em que você chegar a este ponto,

234
00:20:41,695 --> 00:20:45,410
o nome de usuário deve ser

235
00:20:45,410 --> 00:20:48,980
o mesmo que o nome de usuário e senha deve ser o mesmo que uma senha,

236
00:20:48,980 --> 00:20:55,240
mas em qualquer caso eu colocar em uma verificação dupla nesse ponto apenas para ter certeza duplamente.

237
00:20:55,240 --> 00:20:56,590
Então, neste caso,

238
00:20:56,590 --> 00:21:02,765
diremos que req.session.user está autenticado.

239
00:21:02,765 --> 00:21:05,440
Então, vamos definir isso para autenticado

240
00:21:05,440 --> 00:21:16,480
e também este, vamos dizer

241
00:21:16,480 --> 00:21:18,660
Res.StatusCode é 200.

242
00:21:18,660 --> 00:21:21,870
Assim, conseguimos autenticar o usuário com sucesso.

243
00:21:21,870 --> 00:21:29,030
Então, vamos dizer Res.StatusCode é 200 e, em seguida, vamos dizer Res.SetHeader

244
00:21:30,540 --> 00:21:43,690
Content-Type texto simples e

245
00:21:43,690 --> 00:21:51,500
res.end vamos simplesmente enviar uma mensagem dizendo “Você está autenticado”.

246
00:21:53,700 --> 00:22:00,825
É isso. Então, isso cobre a parte então do usuário Findone.

247
00:22:00,825 --> 00:22:05,360
Então, primeiro, verificamos se o usuário é nulo,

248
00:22:05,360 --> 00:22:07,410
isso significa que não conseguimos encontrar o usuário,

249
00:22:07,410 --> 00:22:12,025
então estamos obviamente retornando um erro dizendo que o nome de usuário não existe.

250
00:22:12,025 --> 00:22:15,195
Se a senha do usuário não coincidir com a senha,

251
00:22:15,195 --> 00:22:16,450
então, neste momento,

252
00:22:16,450 --> 00:22:19,150
o usuário existe mas a senha não coincidiu, então diremos,

253
00:22:19,150 --> 00:22:22,640
“Sua senha está incorreta”, e então, finalmente,

254
00:22:22,640 --> 00:22:29,050
chegamos a esse ponto, então o nome de usuário e a senha devem ser identificados corretamente.

255
00:22:29,330 --> 00:22:35,780
Embora eu não precise desta verificação, mas eu apenas colocá-lo lá no lugar e, em seguida, neste ponto,

256
00:22:35,780 --> 00:22:38,680
eu vou definir o req.session.user para

257
00:22:38,680 --> 00:22:41,830
autenticá-lo e, em seguida, definir o código de status para 200, o que significa que você foi

258
00:22:41,830 --> 00:22:48,880
capaz de autenticar com sucesso o usuário e, em seguida, você pode terminar nesse ponto.

259
00:22:48,880 --> 00:22:51,490
Porque este é um então,

260
00:22:51,490 --> 00:22:54,685
eu vou colocar em uma captura neste ponto,

261
00:22:54,685 --> 00:23:03,845
então vamos dizer erro catch e se o erro ocorrer,

262
00:23:03,845 --> 00:23:09,130
então eu vou simplesmente passar o erro

263
00:23:09,130 --> 00:23:14,560
para o próximo para

264
00:23:14,560 --> 00:23:20,090
que o manipulador de erros será capaz de lidar com o erro adequadamente.

265
00:23:20,090 --> 00:23:24,415
Então que termina este usuário Findone.

266
00:23:24,415 --> 00:23:31,020
Agora, este é o caso quando o req.session.user não está definido.

267
00:23:31,020 --> 00:23:32,905
Se isso já estiver definido,

268
00:23:32,905 --> 00:23:38,095
isso significa que o usuário já está conectado.

269
00:23:38,095 --> 00:23:40,630
Então, neste caso,

270
00:23:40,630 --> 00:23:50,650
a outra parte aqui lida com a situação dizendo que vamos definir

271
00:23:50,650 --> 00:23:52,660
o StatusCode como 200

272
00:23:52,660 --> 00:24:12,205
e o Content-Type como text/plain e então vamos dizer,

273
00:24:12,205 --> 00:24:17,680
“Você já está autenticado.”

274
00:24:17,680 --> 00:24:21,910
Então, se você chegar a essa outra parte,

275
00:24:22,690 --> 00:24:29,060
você viria aqui porque o req.session.user já não é nulo,

276
00:24:29,060 --> 00:24:32,150
o que significa que o usuário já foi autenticado, o

277
00:24:32,150 --> 00:24:34,995
que significa que quando você chegar a esse ponto,

278
00:24:34,995 --> 00:24:38,200
então o usuário já fez login mais cedo,

279
00:24:38,200 --> 00:24:41,100
então você não precisa verificar.

280
00:24:41,100 --> 00:24:42,220
Então você vai simplesmente dizer,

281
00:24:42,220 --> 00:24:46,270
“Você já está autenticado”, e depois terminar neste ponto.

282
00:24:46,270 --> 00:24:54,975
Está bem. Então, agora, o último método que vamos implementar é para fazer logout do usuário.

283
00:24:54,975 --> 00:24:59,180
Então, vamos fazer um roteador.entrar em /logout.

284
00:24:59,180 --> 00:25:02,170
Você deve estar se perguntando por que fazemos um get

285
00:25:02,170 --> 00:25:07,000
no logout em vez de um post que fizemos no login?

286
00:25:07,000 --> 00:25:11,090
No login, você precisa enviar o nome de usuário e a senha.

287
00:25:11,090 --> 00:25:14,900
Para logout, você está simplesmente fazendo logout do sistema,

288
00:25:14,900 --> 00:25:17,590
então você não precisa fornecer nenhuma informação adicional porque

289
00:25:17,590 --> 00:25:20,910
o servidor já está rastreando você com base no

290
00:25:20,910 --> 00:25:30,665
seu ID de sessão e dentro desse cookie de sessão aqui.

291
00:25:30,665 --> 00:25:32,620
Então, é por isso que não estamos

292
00:25:32,620 --> 00:25:38,890
explicitamente precisando enviar qualquer informação adicional no corpo da mensagem.

293
00:25:38,890 --> 00:25:46,120
Então, vamos dizer se req.session então o que significa que a sessão deve existir,

294
00:25:46,120 --> 00:25:50,070
caso contrário, você está tentando fazer logout de um usuário que não fez login.

295
00:25:50,070 --> 00:25:52,280
Então não faz sentido.

296
00:25:52,280 --> 00:25:57,490
Agora, a sessão em si fornece este método

297
00:25:57,490 --> 00:26:03,415
chamado destruir e quando você chama o método destruir,

298
00:26:03,415 --> 00:26:07,520
a sessão é destruída e as informações são

299
00:26:07,520 --> 00:26:12,945
removidas do lado do servidor referente a esta sessão.

300
00:26:12,945 --> 00:26:16,970
Então, o que significa que se o cliente tentar enviar novamente

301
00:26:16,970 --> 00:26:19,190
as informações da sessão que são armazenadas na forma

302
00:26:19,190 --> 00:26:21,430
de um cookie assinado no lado do cliente,

303
00:26:21,430 --> 00:26:22,640
isso será inválido.

304
00:26:22,640 --> 00:26:27,870
Portanto, precisamos de um método de excluir o cookie que é armazenado no lado do cliente.

305
00:26:27,870 --> 00:26:31,110
Agora, esta operação irá remover

306
00:26:31,110 --> 00:26:36,805
as informações da sessão do lado do servidor para que a sessão não é mais válida.

307
00:26:36,805 --> 00:26:38,060
Então, neste ponto,

308
00:26:38,060 --> 00:26:45,115
vamos dizer req.session.destroy e então vamos dizer, Res.ClearCookie.

309
00:26:45,115 --> 00:26:49,640
Portanto, o ClearCookie é uma maneira de pedir ao cliente para

310
00:26:49,640 --> 00:26:54,875
remover o cookie e o nome do cookie é o ID da sessão.

311
00:26:54,875 --> 00:26:56,630
Então, no exercício anterior,

312
00:26:56,630 --> 00:27:00,910
vimos que o cookie foi armazenado com o nome do ID da sessão no lado do cliente.

313
00:27:00,910 --> 00:27:05,430
Então, estamos pedindo ao cliente para excluir este cookie do

314
00:27:05,430 --> 00:27:10,935
lado do cliente na mensagem de resposta e, em seguida, vamos dizer,

315
00:27:10,935 --> 00:27:16,835
res.redirect e vamos redirecioná-lo para a página inicial aqui.

316
00:27:16,835 --> 00:27:21,540
Então, esta é uma maneira de redirecionar o usuário para entrar em sua página padrão,

317
00:27:21,540 --> 00:27:24,790
então, por exemplo, a página inicial do seu aplicativo.

318
00:27:24,790 --> 00:27:31,090
Então, esta é a maneira que você lidaria com o logout do sistema.

319
00:27:31,090 --> 00:27:33,200
Se o req.session não existir,

320
00:27:33,200 --> 00:27:35,380
isso significa que você não está logado,

321
00:27:35,380 --> 00:27:37,310
então teremos que gerar um erro.

322
00:27:37,310 --> 00:27:38,945
Então vamos dizer var err,

323
00:27:38,945 --> 00:27:46,370
new Error, “Você não está logado”,

324
00:27:47,100 --> 00:27:52,615
e vamos definir o status do erro como 403,

325
00:27:52,615 --> 00:27:54,760
esta é uma operação proibida e,

326
00:27:54,760 --> 00:28:01,060
em seguida, gerar o erro para o manipulador de erros, é isso.

327
00:28:01,060 --> 00:28:08,830
Então agora, você vê que nós expandimos o roteador do usuário para suportar três novos endpoints,

328
00:28:08,830 --> 00:28:13,330
o endpoint de inscrição que permite que um usuário se inscreva,

329
00:28:13,330 --> 00:28:17,785
o endpoint de login que permite que um usuário inscrito faça login

330
00:28:17,785 --> 00:28:24,730
e, em seguida, o endpoint de logout que permite que um usuário conectado faça logout do sistema.

331
00:28:24,730 --> 00:28:26,970
No processo de logout,

332
00:28:26,970 --> 00:28:29,340
você está destruindo a sessão no lado do servidor,

333
00:28:29,340 --> 00:28:31,890
você também está limpando o cookie no lado do cliente, para

334
00:28:31,890 --> 00:28:40,350
que o cliente não possa ser usado na sessão expirada para tentar entrar em contato com esse servidor.

335
00:28:40,350 --> 00:28:43,480
Uma pequena correção em users.js,

336
00:28:43,480 --> 00:28:49,225
isso deve ser var User require.. /models/user,

337
00:28:49,225 --> 00:28:58,095
lembre-se de que o arquivo users.js está na pasta rotas e, em seguida,

338
00:28:58,095 --> 00:29:01,130
o arquivo user.js está

339
00:29:01,130 --> 00:29:07,440
na pasta models que está acima de um nível e, em seguida, na pasta models.

340
00:29:07,440 --> 00:29:11,620
Então, isto deve ser... /models/usuário,

341
00:29:11,620 --> 00:29:15,655
então faça essa pequena correção, é isso.

342
00:29:15,655 --> 00:29:19,040
Nós modificamos o arquivo users.js,

343
00:29:19,040 --> 00:29:23,690
agora a última coisa que precisamos fazer é ir e consertar o arquivo app.js.

344
00:29:23,690 --> 00:29:25,965
No arquivo app.js do aplicativo,

345
00:29:25,965 --> 00:29:29,520
se você navegar para o arquivo app.js,

346
00:29:29,520 --> 00:29:31,160
você veria que temos

347
00:29:31,160 --> 00:29:37,240
esse índice de barra aqui e barra os usuários aqui após a autenticação.

348
00:29:37,240 --> 00:29:43,360
Agora, isso não vai funcionar para nós porque se você precisa se inscrever,

349
00:29:43,360 --> 00:29:49,140
então o usuário iria se inscrever e fazer login antes que a autorização seja confirmada, de

350
00:29:49,140 --> 00:29:54,910
qualquer maneira se o registro e login é para o processo de inscrição,

351
00:29:54,910 --> 00:30:04,295
então eu vou movê-los para cima antes da etapa de autenticação aqui.

352
00:30:04,295 --> 00:30:09,280
Então, vamos mover isto para este local.

353
00:30:09,280 --> 00:30:15,430
Assim, um usuário de entrada pode acessar o arquivo de índice

354
00:30:15,430 --> 00:30:21,589
na barra e também acessar o endpoint de usuários sem ser autenticado,

355
00:30:21,589 --> 00:30:23,205
mas qualquer outro endpoint,

356
00:30:23,205 --> 00:30:25,400
o usuário tem que ser autenticado, de

357
00:30:25,400 --> 00:30:28,665
modo que é assim que configuramos isso.

358
00:30:28,665 --> 00:30:32,375
Dentro da autenticação da função, diremos,

359
00:30:32,375 --> 00:30:40,695
“Se não req.session.user”, então observe que este lugar,

360
00:30:40,695 --> 00:30:47,980
não estaríamos permitindo que o usuário entre aqui sem que o usuário tenha feito login.

361
00:30:47,980 --> 00:30:50,450
Então, se não req.session.user,

362
00:30:50,450 --> 00:30:55,170
então nós simplesmente diríamos que você não está autenticado.

363
00:31:03,600 --> 00:31:09,330
Esta autenticação tem de ser feita utilizando o método de início de sessão aqui.

364
00:31:09,330 --> 00:31:13,510
Então, eu vou remover esta parte inteira aqui.

365
00:31:17,340 --> 00:31:22,285
Então, vamos dizer, se não req.session.user,

366
00:31:22,285 --> 00:31:28,670
diremos que você não está autenticado e então teremos que enviar uma foto três aqui, o

367
00:31:28,670 --> 00:31:31,560
que significa que você nunca deve descer a este ponto

368
00:31:31,560 --> 00:31:34,785
sem que o usuário faça login.

369
00:31:34,785 --> 00:31:37,575
Então, diremos que você não está autenticado.

370
00:31:37,575 --> 00:31:41,990
Lembre-se de que você precisa se autenticar fazendo um POST

371
00:31:41,990 --> 00:31:47,120
na barra de usuários barra ponto final de login.

372
00:31:47,120 --> 00:31:50,930
Então vamos dizer que você não está autenticado, caso contrário,

373
00:31:50,930 --> 00:31:56,175
se req.session.user for igual a,

374
00:31:56,175 --> 00:32:01,720
lembre-se que na função de login no

375
00:32:01,720 --> 00:32:07,780
users.js definimos o próximo usuário da sessão para a string autenticada.

376
00:32:07,780 --> 00:32:10,055
Então, é isso que vamos verificar.

377
00:32:10,055 --> 00:32:14,355
Nós diremos, se req.session.user for autenticado,

378
00:32:14,355 --> 00:32:21,955
diremos a seguir, caso contrário você não será autenticado novamente.

379
00:32:21,955 --> 00:32:31,990
Então enviaremos uma mensagem proibida. É isso.

380
00:32:31,990 --> 00:32:33,995
Então, com esta atualização,

381
00:32:33,995 --> 00:32:36,375
meu arquivo app.js também está pronto.

382
00:32:36,375 --> 00:32:38,590
Agora, tendo feito essas atualizações,

383
00:32:38,590 --> 00:32:42,470
vamos verificar como nosso aplicativo funciona agora.

384
00:32:42,470 --> 00:32:44,350
Indo para o terminal,

385
00:32:44,350 --> 00:32:49,655
se o servidor estiver em execução, pare e reinicie o servidor.

386
00:32:49,655 --> 00:32:51,600
Meu servidor não está sendo executado no momento,

387
00:32:51,600 --> 00:32:53,405
então eu vou dizer npm start,

388
00:32:53,405 --> 00:32:56,440
e meu servidor deve estar ativo e funcionando.

389
00:32:56,440 --> 00:33:00,540
Vamos agora ver como vamos acessar o servidor.

390
00:33:00,540 --> 00:33:04,150
Indo para Postman, deixe-me fazer um GET no

391
00:33:04,150 --> 00:33:07,290
localhost: 3000/pratos e então você verá imediatamente

392
00:33:07,290 --> 00:33:10,375
que ele se queixa dizendo que você não está autenticado.

393
00:33:10,375 --> 00:33:13,095
Obviamente, não estou autenticado aqui.

394
00:33:13,095 --> 00:33:19,560
Deixe-me tentar acessar apenas o localhost: 3000 e você verá que,

395
00:33:19,560 --> 00:33:22,625
essa raiz está disponível para nós.

396
00:33:22,625 --> 00:33:29,850
Agora, é claro, queremos primeiro registrar um usuário e, em seguida, fazer login

397
00:33:29,850 --> 00:33:37,745
como o usuário e, em seguida, obter acesso ao resto dos pontos finais da API REST.

398
00:33:37,745 --> 00:33:40,480
Então, primeiro, deixe-me registrar um usuário.

399
00:33:40,480 --> 00:33:41,925
Para registrar o usuário,

400
00:33:41,925 --> 00:33:51,410
eu preciso fazer um POST para o localhost: 3000/users/signup.

401
00:33:53,700 --> 00:33:57,710
Para esta mensagem POST,

402
00:33:57,930 --> 00:34:01,635
no corpo da mensagem,

403
00:34:01,635 --> 00:34:07,860
eu preciso incluir no corpo da

404
00:34:07,860 --> 00:34:15,080
mensagem uma string JSON com o nome de usuário.

405
00:34:15,080 --> 00:34:19,390
Então, deixe-me fazer login e

406
00:34:19,390 --> 00:34:27,770
então eu vou usar a senha como senha.

407
00:34:28,810 --> 00:34:31,835
Este é um registro válido.

408
00:34:31,835 --> 00:34:35,505
Então, quando eu me inscrever como um usuário com

409
00:34:35,505 --> 00:34:42,150
essas informações na forma de uma string JSON incluída no corpo da mensagem,

410
00:34:42,150 --> 00:34:47,590
deixe-me ver que o cabeçalho agora contém o aplicativo tipo de conteúdo,

411
00:34:47,590 --> 00:34:50,440
JSON porque eu configurei o JSON no corpo da

412
00:34:50,440 --> 00:34:54,660
mensagem e, em seguida, enviar o POST para a inscrição.

413
00:34:54,660 --> 00:34:57,175
Então, quando eu enviar o POST para a inscrição,

414
00:34:57,175 --> 00:35:02,460
você verá imediatamente o que é retornado pelo servidor aqui.

415
00:35:02,460 --> 00:35:05,630
Então, você vê que o servidor voltou dizendo,

416
00:35:05,630 --> 00:35:10,205
“Registro bem-sucedido” e ele mesmo,

417
00:35:10,205 --> 00:35:13,485
ele me dá os detalhes do usuário aqui.

418
00:35:13,485 --> 00:35:19,340
Então, este é um registro que existe no meu MongoDB e

419
00:35:19,340 --> 00:35:25,090
note que o tipo de modelo é o tipo de modelo de usuário que tivemos configuração.

420
00:35:25,090 --> 00:35:28,300
Então, temos o nome de usuário e senha e

421
00:35:28,300 --> 00:35:33,535
o sinalizador admin como você pode ver é definido como false por padrão.

422
00:35:33,535 --> 00:35:37,285
Uma vez que registramos o usuário,

423
00:35:37,285 --> 00:35:40,370
este usuário agora é um usuário válido.

424
00:35:40,370 --> 00:35:45,640
Então, deixe-me tentar novamente POST o mesmo usuário e ver o que acontece.

425
00:35:45,640 --> 00:35:48,935
Então, quando eu POST o mesmo usuário obviamente,

426
00:35:48,935 --> 00:35:50,385
lá do lado do servidor,

427
00:35:50,385 --> 00:35:52,840
ele responde dizendo que este usuário já existe.

428
00:35:52,840 --> 00:35:58,480
Então, você pode ver que nós configuramos nosso procedimento de inscrição para não permitir que

429
00:35:58,480 --> 00:36:04,580
o usuário duplicar o registro com o mesmo ID de usuário.

430
00:36:04,580 --> 00:36:07,135
Está bem. Então, essa é a segunda parte.

431
00:36:07,135 --> 00:36:13,570
Agora, vamos fazer um login do usuário.

432
00:36:13,570 --> 00:36:15,770
Para fazer um login do usuário,

433
00:36:15,770 --> 00:36:20,400
deixe-me remover o tipo de conteúdo e, em seguida, eu também

434
00:36:20,400 --> 00:36:25,440
removerei o corpo porque para o login, isso não é necessário.

435
00:36:25,440 --> 00:36:28,200
Então, eu não preencho nada

436
00:36:28,200 --> 00:36:31,790
no cabeçalho e, em seguida, tentar fazer login e quando eu tentei entrar,

437
00:36:31,790 --> 00:36:34,805
ele responde de volta dizendo que você não está autenticado.

438
00:36:34,805 --> 00:36:36,175
Você não está autorizado.

439
00:36:36,175 --> 00:36:39,595
Agora, eu preciso me conectar.

440
00:36:39,595 --> 00:36:42,940
Então, é aqui que eu posso usar a autenticação básica.

441
00:36:42,940 --> 00:36:46,240
Então, na autenticação básica,

442
00:36:46,240 --> 00:36:51,170
vou apenas digitar meu nome de usuário e

443
00:36:51,170 --> 00:36:56,575
senha que acabei de registrar na etapa anterior e, em seguida, atualizar minha solicitação

444
00:36:56,575 --> 00:37:00,060
e, em seguida, fazer um POST no login.

445
00:37:00,060 --> 00:37:02,400
Então, quando eu faço um POST no login,

446
00:37:02,400 --> 00:37:06,935
você vê que o servidor responde dizendo: “Você está autenticado”.

447
00:37:06,935 --> 00:37:08,740
Então, neste ponto,

448
00:37:08,740 --> 00:37:11,400
eu posso executar as

449
00:37:11,400 --> 00:37:16,115
solicitações GET, PUT, POST e DELETE em todos os outros endpoints.

450
00:37:16,115 --> 00:37:26,370
Então, neste ponto, se eu fizer um GET no endpoint de pratos,

451
00:37:28,760 --> 00:37:32,675
você veria que isso retorna

452
00:37:32,675 --> 00:37:39,160
o campo vazio porque meu banco de dados está atualmente vazio no momento.

453
00:37:39,160 --> 00:37:44,370
Deixe-me limpar a autorização e também do cabeçalho remover

454
00:37:44,370 --> 00:37:49,575
a autorização e, em seguida, fazer o GET e é caixa de ferramentas muito bem.

455
00:37:49,575 --> 00:37:52,480
Então, você pode ver que agora eu sou capaz de

456
00:37:52,480 --> 00:37:56,065
acessar os endpoints porque eu mesmo fiz login.

457
00:37:56,065 --> 00:38:00,040
Então, agora, deixe-me fazer um logout do usuário.

458
00:38:00,040 --> 00:38:05,910
Então, vamos dizer, localhost: 3000 e logout.

459
00:38:05,910 --> 00:38:08,875
Observe também que, nos cookies,

460
00:38:08,875 --> 00:38:12,290
um cookie foi configurado no ID da sessão ali mesmo.

461
00:38:12,290 --> 00:38:17,080
Então, esse cookie existe no site do meu cliente.

462
00:38:17,080 --> 00:38:22,715
Então, agora, deixe-me sair dizendo GET localhost: 3000/users/logout.

463
00:38:22,715 --> 00:38:26,580
Então, quando eu fizer um log out do usuário,

464
00:38:26,580 --> 00:38:29,765
você verá imediatamente que eu sou redirecionado para

465
00:38:29,765 --> 00:38:37,830
esse endpoint localhost: 3000 e também notará que o cookie desapareceu.

466
00:38:37,830 --> 00:38:40,140
Então, quando eu olho para cookies,

467
00:38:40,140 --> 00:38:42,040
você vê que o localhost,

468
00:38:42,040 --> 00:38:46,470
o cookie se foi porque do lado do meu servidor quando eu faço o logout

469
00:38:46,470 --> 00:38:51,495
ele envia de volta um cookie claro descanso para o lado do cliente e assim o cookie se foi.

470
00:38:51,495 --> 00:38:54,555
Agora, se eu tentar fazer um GET

471
00:38:54,555 --> 00:39:02,480
no endpoint localhost: 3000/pratos,

472
00:39:02,480 --> 00:39:05,899
isso não funcionará porque eu não estou autenticado.

473
00:39:05,899 --> 00:39:11,610
Então, isso demonstra a você como você pode estender seu servidor Express para

474
00:39:11,610 --> 00:39:17,190
permitir que os usuários se registrem e, em seguida, permitir que o usuário faça login no sistema

475
00:39:17,190 --> 00:39:19,860
e, em seguida, também logout do sistema.

476
00:39:19,860 --> 00:39:25,520
No lado do servidor, você está rastreando um usuário conectado usando a sessão e usando

477
00:39:25,520 --> 00:39:28,260
o cookie no lado do cliente e quando o usuário faz

478
00:39:28,260 --> 00:39:31,375
logout o cookie é destruído no lado do cliente.

479
00:39:31,375 --> 00:39:34,540
Com isso, completamos este exercício.

480
00:39:34,540 --> 00:39:37,390
Este é um bom momento para você fazer um commit Git,

481
00:39:37,390 --> 00:39:42,420
com a mensagem, sessões Express parte dois.