1
00:00:03,710 --> 00:00:10,135
Esta es la segunda parte del Ejercicio de Sesiones Expresas.

2
00:00:10,135 --> 00:00:12,320
Hemos completado la primera parte anteriormente,

3
00:00:12,320 --> 00:00:15,310
donde agregamos soporte para Express Sessions,

4
00:00:15,310 --> 00:00:20,340
y usamos Express Sessions como una forma de rastrear a los usuarios en el lado del servidor,

5
00:00:20,340 --> 00:00:24,160
y reconocer las solicitudes entrantes de los usuarios.

6
00:00:24,160 --> 00:00:30,930
En este ejercicio, no nos concentramos tanto en las propias Sesiones Express,

7
00:00:30,930 --> 00:00:36,605
pero veremos una forma de ampliar nuestro servidor de API REST express

8
00:00:36,605 --> 00:00:42,435
para admitir un nuevo modelo de registro y autenticación de usuarios.

9
00:00:42,435 --> 00:00:48,635
Por lo tanto, vamos a introducir un nuevo modelo de usuario y esquema en nuestra aplicación.

10
00:00:48,635 --> 00:00:52,295
Ya tenemos la ruta de los usuarios de barra diagonal que

11
00:00:52,295 --> 00:00:57,290
el generador express ya ha montado el router de un usuario.

12
00:00:57,290 --> 00:01:00,035
Por lo tanto, vamos a aprovechar eso y luego

13
00:01:00,035 --> 00:01:03,205
actualizarlo para admitir el registro de nuevos usuarios,

14
00:01:03,205 --> 00:01:05,390
autenticar a un usuario existente

15
00:01:05,390 --> 00:01:11,695
y también cerrar sesión a un usuario de nuestro sitio de servidor.

16
00:01:11,695 --> 00:01:17,915
Por lo tanto, veremos las Sesiones Express como una forma de rastrear a los usuarios una vez que el usuario inicie sesión,

17
00:01:17,915 --> 00:01:19,820
y luego cuando el usuario cierre

18
00:01:19,820 --> 00:01:22,680
la sesión, la sesión se eliminará del sistema.

19
00:01:22,680 --> 00:01:27,480
Entonces, ¿cómo vamos a hacer esta extensión en este ejercicio?

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

21
00:01:29,800 --> 00:01:35,485
Continuando con nuestro servidor de API REST express,

22
00:01:35,485 --> 00:01:41,835
vamos ahora a ir a los modelos y agregar un nuevo archivo llamado user.js.

23
00:01:41,835 --> 00:01:46,440
Este es el archivo donde vamos a crear el esquema de usuario y el modelo.

24
00:01:46,440 --> 00:01:51,405
Vamos a crear un esquema de usuario simple que rastrea el nombre de usuario

25
00:01:51,405 --> 00:01:55,520
y la contraseña, y también un indicador que se establece para indicar

26
00:01:55,520 --> 00:01:59,540
si el usuario es un administrador o un usuario normal.

27
00:01:59,540 --> 00:02:03,660
Por lo tanto, esta es una forma de distinguir entre diferentes tipos de usuarios.

28
00:02:03,660 --> 00:02:07,210
Por lo tanto, en este archivo,

29
00:02:07,210 --> 00:02:16,510
primero vamos a requerir mangosta porque estamos creando un esquema de mangosta,

30
00:02:16,510 --> 00:02:26,710
y luego vamos a crear un esquema llamado esquema mangosta,

31
00:02:26,710 --> 00:02:29,720
y luego vamos a decir var usuario.

32
00:02:29,720 --> 00:02:32,870
Así que este es el esquema de usuario que vamos a crear,

33
00:02:32,870 --> 00:02:38,150
y vamos a decir nuevo esquema de usuario.

34
00:02:38,150 --> 00:02:42,740
El esquema de usuario se definirá como acabo de mencionar,

35
00:02:42,740 --> 00:02:47,705
con tres campos aquí llamados nombre de usuario

36
00:02:47,705 --> 00:02:55,755
que obviamente serían de la cadena de tipo,

37
00:02:55,755 --> 00:02:59,290
y este es un campo obligatorio,

38
00:02:59,290 --> 00:03:03,975
y este es un campo único.

39
00:03:03,975 --> 00:03:07,580
Usted no quiere que dos usuarios con el mismo nombre de usuario en su sistema,

40
00:03:07,580 --> 00:03:12,810
por lo que creamos el nombre de usuario y luego el segundo campo es el campo de contraseña.

41
00:03:12,810 --> 00:03:15,259
Ahora, por supuesto, puede ampliar

42
00:03:15,259 --> 00:03:19,820
este esquema de usuario para permitir al usuario realizar un seguimiento de todo su perfil,

43
00:03:19,820 --> 00:03:23,985
pero lo haremos en uno de los ejercicios posteriores, por el momento,

44
00:03:23,985 --> 00:03:30,604
un usuario es reconocido dentro del sistema simplemente por el nombre de usuario y la contraseña.

45
00:03:30,604 --> 00:03:36,290
Por lo tanto, la contraseña es de la cadena de tipo y luego es necesaria.

46
00:03:37,300 --> 00:03:44,320
El tercer campo que voy a usar se llama admin.

47
00:03:44,320 --> 00:03:48,025
Entonces, el administrador es del tipo booleano,

48
00:03:48,025 --> 00:03:58,270
y diremos por defecto false.

49
00:03:58,270 --> 00:04:02,905
Por lo tanto, de forma predeterminada cuando se crea

50
00:04:02,905 --> 00:04:04,830
un usuario, se crea un nuevo usuario,

51
00:04:04,830 --> 00:04:06,855
el indicador de administrador se establecerá en false.

52
00:04:06,855 --> 00:04:09,925
Puede establecerlo explícitamente

53
00:04:09,925 --> 00:04:14,605
en true desde su código para marcar a un usuario como usuario administrativo.

54
00:04:14,605 --> 00:04:18,460
Tal vez usted podría proporcionar privilegios adicionales a un usuario administrativo,

55
00:04:18,460 --> 00:04:21,230
o tal vez permitir que el usuario administrador realice

56
00:04:21,230 --> 00:04:24,810
ciertas operaciones que los usuarios normales no lo harían.

57
00:04:24,810 --> 00:04:27,760
Vamos a ver que en uno de los ejercicios posteriores,

58
00:04:27,760 --> 00:04:31,500
por el momento, este es el esquema de usuario que hemos creado,

59
00:04:31,500 --> 00:04:38,150
vamos a crear un módulo de este y exportar desde

60
00:04:38,150 --> 00:04:47,075
este módulo un modelo de mangosta del nombre usuario.

61
00:04:47,075 --> 00:04:51,115
Por lo tanto, este es el modelo de Mangosta y el esquema es

62
00:04:51,115 --> 00:04:55,840
el esquema de usuario que acabamos de definir un poco antes.

63
00:04:55,840 --> 00:05:00,615
Por lo tanto, así es como definimos nuestro esquema de usuario.

64
00:05:00,615 --> 00:05:03,770
Por lo tanto, ahora que hemos definido nuestro esquema de usuario,

65
00:05:03,770 --> 00:05:08,660
vamos a entrar en el router que ya ha sido configurado

66
00:05:08,660 --> 00:05:15,610
por el generador express cuando genera esta aplicación express.

67
00:05:15,610 --> 00:05:17,775
Por lo tanto, si va a la carpeta de rutas,

68
00:05:17,775 --> 00:05:20,890
verá este archivo llamado users.js.

69
00:05:20,890 --> 00:05:26,780
Por lo tanto, este archivo users.js se extenderá para crear el enrutador.

70
00:05:26,780 --> 00:05:36,720
Entonces, justo ahí lo que voy a hacer es importar el analizador corporal,

71
00:05:41,510 --> 00:05:46,395
y luego declararán el enrutador express,

72
00:05:46,395 --> 00:05:50,145
y luego diremos también importar

73
00:05:50,145 --> 00:05:57,100
el esquema de usuario y el

74
00:05:57,100 --> 00:06:03,420
modelo del usuario de modelos,

75
00:06:03,950 --> 00:06:09,220
y luego para el enrutador express diremos,

76
00:06:09,220 --> 00:06:13,380
enrutador use analizador corporal.

77
00:06:16,190 --> 00:06:20,690
Así que, ahora que hemos declarado el analizador corporal allí,

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

79
00:06:23,650 --> 00:06:30,470
más adelante lo modificaremos para permitir

80
00:06:30,470 --> 00:06:33,750
que el administrador pueda recuperar a todos los usuarios registrados en el sistema pero por el momento,

81
00:06:33,750 --> 00:06:37,705
saldremos de esa ruta como tal.

82
00:06:37,705 --> 00:06:40,500
Agregaremos algunas rutas más aquí,

83
00:06:40,500 --> 00:06:42,965
así que diremos, «Publicación del enrutador».

84
00:06:42,965 --> 00:06:49,970
Así que vamos a apoyar la operación de publicación en una ruta llamada registro y, como es de esperar,

85
00:06:49,970 --> 00:06:55,790
esta ruta de registro permitirá a un usuario

86
00:06:55,790 --> 00:07:04,920
registrarse en el sistema, por lo que esto apoyará el registro del usuario.

87
00:07:04,920 --> 00:07:08,355
Entonces, diremos, «Rec, res, siguiente».

88
00:07:08,355 --> 00:07:16,090
Y por lo que este sería el registro posterior al enrutador,

89
00:07:16,590 --> 00:07:23,410
los métodos restantes no se permitirán en la parte final de registro.

90
00:07:23,410 --> 00:07:25,865
Por lo tanto, para acceder a

91
00:07:25,865 --> 00:07:31,420
esto, ya que este enrutador de usuarios está montado en usuarios de barra

92
00:07:31,420 --> 00:07:35,645
diagonal, especificaríamos este punto final como usuarios de barra barra barra barra barra de registro,

93
00:07:35,645 --> 00:07:41,765
y este es el punto final que se utilizará para registrar nuevos usuarios dentro del sistema. Por lo

94
00:07:41,765 --> 00:07:45,080
tanto, lo primero que haremos es usar

95
00:07:45,080 --> 00:07:53,300
el método de usuario y la expectativa es que para que un usuario se registre,

96
00:07:53,300 --> 00:07:58,145
el nombre de usuario y la contraseña se proporcionarán como una cadena JSON

97
00:07:58,145 --> 00:08:03,185
dentro del cuerpo de la solicitud de correo entrante.

98
00:08:03,185 --> 00:08:05,160
Por lo tanto,

99
00:08:05,160 --> 00:08:09,200
desde el cuerpo, ya que el cuerpo ya habría sido analizado por el analizador del cuerpo, por

100
00:08:09,200 --> 00:08:10,370
lo que desde el cuerpo,

101
00:08:10,370 --> 00:08:13,920
primero verificará para asegurarse de que

102
00:08:13,920 --> 00:08:22,130
el usuario con ese nombre de usuario no existe dentro del sistema.

103
00:08:22,130 --> 00:08:24,380
Si el usuario con ese nombre de usuario existe,

104
00:08:24,380 --> 00:08:26,900
entonces usted está tratando de registrar un usuario duplicado

105
00:08:26,900 --> 00:08:29,715
y eso no debería estar permitido en el sistema.

106
00:08:29,715 --> 00:08:37,340
Por lo tanto, diremos, «Los usuarios encuentran uno», y luego intentaremos encontrar si

107
00:08:37,340 --> 00:08:41,090
hay un usuario con el nombre de usuario que ha sido

108
00:08:41,090 --> 00:08:45,405
seleccionado por el cliente que está tratando de registrar a un nuevo usuario.

109
00:08:45,405 --> 00:08:47,020
Si el usuario ya existe,

110
00:08:47,020 --> 00:08:51,850
entonces obviamente no permitirá que el nuevo usuario se registre con el mismo nombre de usuario.

111
00:08:51,850 --> 00:08:55,665
Entonces, diremos: «Entonces usuario».

112
00:08:55,665 --> 00:09:03,295
Por lo tanto, esto devolverá al usuario aquí y dentro de este campo de usuario,

113
00:09:03,295 --> 00:09:09,080
luego verificaremos el hecho de si el usuario ya existe,

114
00:09:09,080 --> 00:09:12,350
y luego déjame atrapar el error aquí.

115
00:09:12,350 --> 00:09:19,140
Así que diremos, «Error de captura», y luego, «siguiente error».

116
00:09:19,140 --> 00:09:26,160
Entonces, solo pasaremos eso al manejador de errores allí.

117
00:09:26,160 --> 00:09:33,345
Por lo tanto, si esta búsqueda para el usuario devuelve el campo de usuario,

118
00:09:33,345 --> 00:09:40,460
si el usuario no es igual a nulo.

119
00:09:40,460 --> 00:09:45,170
Por lo tanto, si el usuario que es devuelto por esta búsqueda

120
00:09:45,170 --> 00:09:50,510
no es nulo entonces eso significa que el usuario con ese nombre de usuario dado ya existe,

121
00:09:50,510 --> 00:09:53,420
por lo que no debe permitir un registro duplicado.

122
00:09:53,420 --> 00:09:58,765
Así que diremos, «Var errr nuevo error.»

123
00:09:58,765 --> 00:10:09,075
Y diremos, «Usuario req. nombre de usuario cuerpo».

124
00:10:09,075 --> 00:10:15,410
Ya existe. Entonces, básicamente,

125
00:10:15,410 --> 00:10:20,565
está evitando que un usuario duplicado se registre y luego diremos

126
00:10:20,565 --> 00:10:29,280
err.status 403 versus el prohibido y luego salga,

127
00:10:29,280 --> 00:10:33,735
llamando al controlador de errores, siguiente error.

128
00:10:33,735 --> 00:10:36,880
De lo contrario, esto significa que el usuario no existe,

129
00:10:36,880 --> 00:10:39,670
por lo que debe permitir que el usuario se cierre de sesión.

130
00:10:39,670 --> 00:10:41,950
Entonces, en la otra parte,

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

132
00:10:47,200 --> 00:10:56,165
Crearemos un nuevo usuario con el nombre de usuario establecido en req.body.username,

133
00:10:56,165 --> 00:11:02,555
y luego déjame poner esto en la siguiente línea para que quede más claro para usted,

134
00:11:02,555 --> 00:11:09,620
y diremos contraseña: req.body.password.

135
00:11:09,620 --> 00:11:14,550
Ahora, ya sabemos que el indicador admin por defecto se establecerá en false,

136
00:11:14,550 --> 00:11:17,700
así que vamos a dejarlo como tal,

137
00:11:17,730 --> 00:11:28,175
y esto permitirá que nuestro nuevo usuario se registre y cuando el nuevo usuario esté registrado,

138
00:11:28,175 --> 00:11:37,880
esto devolverá una promesa y dentro del «entonces» manejaremos esta promesa aquí.

139
00:11:37,880 --> 00:11:41,460
Entonces, esto devolverá la promesa de

140
00:11:41,460 --> 00:11:45,625
este «entonces» y luego lo manejaremos en el siguiente «entonces» aquí.

141
00:11:45,625 --> 00:12:02,120
Dirá entonces, Res.StatusCode es 200,

142
00:12:02,120 --> 00:12:10,640
Res.setHeader y diremos Content-type application/json

143
00:12:19,830 --> 00:12:38,000
y diremos, res.json (estado: Registro exitoso),

144
00:12:42,960 --> 00:12:45,760
y si lo desea,

145
00:12:45,760 --> 00:12:49,659
podemos cargar al usuario en

146
00:12:49,659 --> 00:12:58,270
este mensaje de respuesta aquí como una propiedad en el json.

147
00:13:02,790 --> 00:13:06,890
Dirá Registro exitoso.

148
00:13:07,830 --> 00:13:14,950
Entonces, si hay un error en

149
00:13:14,950 --> 00:13:22,790
esta operación, dirá «siguiente error».

150
00:13:22,790 --> 00:13:25,200
Así que eso manejará el error.

151
00:13:25,440 --> 00:13:29,220
Si la promesa no se resuelve correctamente,

152
00:13:29,220 --> 00:13:32,020
entonces será manejada por eso. Así que eso es todo.

153
00:13:32,020 --> 00:13:36,150
Así que aquí, tenemos una forma de que el usuario se registre.

154
00:13:36,150 --> 00:13:38,280
Por lo tanto, para que el usuario se registre,

155
00:13:38,280 --> 00:13:46,570
el usuario hará una publicación en /users/signup y en el cuerpo del mensaje,

156
00:13:46,570 --> 00:13:51,810
el cliente incluirá una cadena json

157
00:13:51,810 --> 00:13:57,760
con propiedades de nombre de usuario y contraseña en esa cadena json.

158
00:13:57,760 --> 00:14:01,200
Así es como te registras para un nuevo usuario.

159
00:14:01,200 --> 00:14:06,135
Ahora, veamos cómo iniciaremos sesión en el usuario.

160
00:14:06,135 --> 00:14:14,605
Ahora, seguiremos utilizando las sesiones Express que hemos hecho antes para rastrear al usuario.

161
00:14:14,605 --> 00:14:24,270
Por lo tanto, para registrar un usuario dirá «router.post» en el punto final/inicio de sesión.

162
00:14:24,820 --> 00:14:29,370
Entonces, en el endpoint /login,

163
00:14:32,280 --> 00:14:35,800
haremos un router.post.

164
00:14:35,800 --> 00:14:42,460
Obviamente, en lugar de decir función,

165
00:14:42,460 --> 00:14:48,575
puede usar la función de flecha aquí para el router.post,

166
00:14:48,575 --> 00:14:50,780
voy a hacer lo mismo aquí.

167
00:14:50,780 --> 00:14:53,930
Me han encariñado las funciones de flecha.

168
00:14:53,930 --> 00:14:57,125
Por lo tanto, vamos a hacer una función de flecha aquí.

169
00:14:57,125 --> 00:15:00,080
Entonces, para el inicio de sesión, ¿cómo continúa el inicio de sesión?

170
00:15:00,080 --> 00:15:01,880
Así que para el inicio de sesión,

171
00:15:01,880 --> 00:15:10,850
lo que haremos es que iremos al archivo app.js y luego dentro de esta autenticación,

172
00:15:11,760 --> 00:15:17,050
estábamos haciendo ese registro para el usuario allí.

173
00:15:17,050 --> 00:15:20,315
Así que, lo que voy a hacer es copiar

174
00:15:20,315 --> 00:15:25,730
todo esto porque no estaría haciendo todo esto de todos modos.

175
00:15:25,730 --> 00:15:32,970
Por lo tanto, más bien permítanme copiar todo el camino desde este punto en adelante hasta el req.session.user.

176
00:15:32,970 --> 00:15:36,925
Por lo tanto, la si parte de req.session.user voy a copiar,

177
00:15:36,925 --> 00:15:44,120
y luego venir al users.js y para el inicio de sesión.

178
00:15:44,120 --> 00:15:47,305
Es exactamente como voy a hacer la autenticación.

179
00:15:47,305 --> 00:15:51,025
Así que diremos si no req.session.user.

180
00:15:51,025 --> 00:15:55,965
Así que eso significa que el usuario aún no se ha autenticado a sí mismo.

181
00:15:55,965 --> 00:15:59,420
A continuación, espera que la autenticación básica sea

182
00:15:59,420 --> 00:16:02,780
un mecanismo para que el usuario utilice para la autenticación.

183
00:16:02,780 --> 00:16:07,890
Así que vamos a decir var AuthHeader if! AuthHeader entonces levantaremos el error, de

184
00:16:07,890 --> 00:16:17,760
lo contrario recuperaremos el nombre de usuario y la contraseña del encabezado.

185
00:16:17,760 --> 00:16:25,235
Ahora, aquí estábamos haciendo si el nombre de usuario es igual a admin y la contraseña es igual a contraseña.

186
00:16:25,235 --> 00:16:30,535
Pero ahora, lo que vamos a hacer es buscar en

187
00:16:30,535 --> 00:16:36,695
la base de datos para ver si ese usuario en particular existe.

188
00:16:36,695 --> 00:16:39,595
Entonces, en lugar de hacer esto aquí,

189
00:16:39,595 --> 00:16:42,995
en lugar de hacer esto si nombre de usuario y contraseña,

190
00:16:42,995 --> 00:16:48,380
diremos, User.Findone

191
00:16:49,650 --> 00:16:56,020
y diremos que nombre de usuario es nombre de usuario.

192
00:16:56,020 --> 00:17:00,730
Así que esta propiedad es igual a este nombre de usuario que acabamos de recuperar

193
00:17:00,730 --> 00:17:06,820
y luego diremos entonces usuario.

194
00:17:09,770 --> 00:17:18,600
Así que dentro de este «entonces».

195
00:17:18,600 --> 00:17:23,110
Así que voy a mover este código dentro de este «entonces» porque

196
00:17:23,110 --> 00:17:28,395
ahora lo que voy a verificar es ahora que he recuperado al usuario,

197
00:17:28,395 --> 00:17:35,625
necesito verificar para asegurarme de que este usuario sea exactamente lo que estoy buscando.

198
00:17:35,625 --> 00:17:37,405
Así que en este punto,

199
00:17:37,405 --> 00:17:42,485
primero vamos a verificar para asegurarnos de que el usuario no es nulo.

200
00:17:42,485 --> 00:17:49,915
Entonces diremos si el usuario es nulo.

201
00:17:49,915 --> 00:17:51,390
Por lo tanto, si el usuario es nulo,

202
00:17:51,390 --> 00:17:55,930
lo que significa que no pudimos encontrar un usuario con ese nombre de usuario en particular.

203
00:17:55,930 --> 00:17:59,860
Por lo tanto, tendrá que devolver un error aquí.

204
00:17:59,860 --> 00:18:04,540
Así que déjame copiar esta parte y luego pegarla

205
00:18:04,540 --> 00:18:09,840
aquí y luego volveremos diciendo var nuevo Error

206
00:18:09,840 --> 00:18:14,575
y diremos que el nombre de

207
00:18:14,575 --> 00:18:23,120
usuario del espacio de usuario

208
00:18:23,580 --> 00:18:28,750
no existe.

209
00:18:28,750 --> 00:18:30,600
Entonces, en este caso,

210
00:18:30,600 --> 00:18:35,230
este usuario no existe, así que solo voy a eliminar esta parte y

211
00:18:35,230 --> 00:18:41,840
luego el estado de error correspondiente sería 403 aquí.

212
00:18:42,450 --> 00:18:44,960
Así que esta es la primera parte.

213
00:18:44,960 --> 00:18:55,000
Si el usuario es nulo, obviamente vamos a decir que el usuario no existe.

214
00:18:55,000 --> 00:19:03,780
La segunda parte que vamos a comprobar es Else if user password.

215
00:19:03,780 --> 00:19:06,800
Entonces, lo que significa que el usuario existe en este punto.

216
00:19:06,800 --> 00:19:12,420
Por lo tanto, la segunda comprobación que haremos es que la contraseña del usuario no es

217
00:19:12,420 --> 00:19:22,330
igual a la contraseña entonces.

218
00:19:22,330 --> 00:19:25,090
Una vez más necesitamos indicar el error allí.

219
00:19:25,090 --> 00:19:28,820
Entonces, el error sería decir,

220
00:19:29,790 --> 00:19:34,570
en este caso, diremos

221
00:19:34,570 --> 00:19:41,390
«su contraseña es incorrecta».

222
00:19:41,390 --> 00:19:44,085
Así que esa es la segunda parte aquí.

223
00:19:44,085 --> 00:19:49,650
Entonces su contraseña es incorrecta y luego la última parte.

224
00:19:49,650 --> 00:19:52,515
Vamos a decir «otra cosa».

225
00:19:52,515 --> 00:19:59,755
Así que déjame sangrar este código.

226
00:19:59,755 --> 00:20:05,775
De lo contrario, si

227
00:20:05,775 --> 00:20:15,815
user.username es nombre de usuario que obviamente debería ser cierto en este caso.

228
00:20:15,815 --> 00:20:17,990
Luego, la segunda parte,

229
00:20:17,990 --> 00:20:27,620
user.password es igual a contraseña que también obviamente debería ser correcta en este punto.

230
00:20:27,620 --> 00:20:29,720
Pero en cualquier caso,

231
00:20:29,720 --> 00:20:38,885
voy a verificar ese problema aquí y esto no ocurrirá en absoluto en este caso.

232
00:20:38,885 --> 00:20:41,695
Por lo tanto, en el momento en que llegue a este punto,

233
00:20:41,695 --> 00:20:45,410
el nombre de

234
00:20:45,410 --> 00:20:48,980
usuario debe ser el mismo que el nombre de usuario y la contraseña debe ser el mismo que una contraseña,

235
00:20:48,980 --> 00:20:55,240
pero en cualquier caso pongo una doble comprobación en ese punto solo para estar doblemente seguro.

236
00:20:55,240 --> 00:20:56,590
Luego, en este caso,

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

238
00:21:02,765 --> 00:21:05,440
Por lo tanto, estableceremos esto en autenticado

239
00:21:05,440 --> 00:21:16,480
y también este, diremos

240
00:21:16,480 --> 00:21:18,660
Res.statusCode es 200.

241
00:21:18,660 --> 00:21:21,870
Así que pudimos autenticar con éxito al usuario.

242
00:21:21,870 --> 00:21:29,030
Por lo tanto, diremos Res.statusCode es 200 y luego diremos Res.setHeader

243
00:21:30,540 --> 00:21:43,690
Content-Type text plain y

244
00:21:43,690 --> 00:21:51,500
res.end simplemente enviaremos un mensaje diciendo «Estás autenticado».

245
00:21:53,700 --> 00:22:00,825
Eso es todo. Por lo tanto, esto cubre la parte entonces del usuario Findone.

246
00:22:00,825 --> 00:22:05,360
Así que primero, comprobamos que si el usuario es nulo,

247
00:22:05,360 --> 00:22:07,410
eso significa que no pudimos encontrar al usuario,

248
00:22:07,410 --> 00:22:12,025
por lo que obviamente estamos devolviendo un error diciendo que el nombre de usuario no existe.

249
00:22:12,025 --> 00:22:15,195
Si la contraseña del usuario no coincide con la contraseña,

250
00:22:15,195 --> 00:22:16,450
por lo que en este punto,

251
00:22:16,450 --> 00:22:19,150
el usuario existe pero la contraseña no coincide, por lo que diremos,

252
00:22:19,150 --> 00:22:22,640
«Su contraseña es incorrecta», y luego, finalmente,

253
00:22:22,640 --> 00:22:29,050
llegamos a este punto, entonces el nombre de usuario y la contraseña deben identificarse correctamente.

254
00:22:29,330 --> 00:22:35,780
Aunque no necesito esta comprobación, pero simplemente la puse allí y luego en este punto,

255
00:22:35,780 --> 00:22:38,680
estableceré el req.session.user para

256
00:22:38,680 --> 00:22:41,830
autenticarlo y luego estableceré el código de estado en 200, lo que significa que

257
00:22:41,830 --> 00:22:48,880
pudo autenticar con éxito al usuario y luego puede terminar en ese punto.

258
00:22:48,880 --> 00:22:51,490
Debido a que este es un entonces,

259
00:22:51,490 --> 00:22:54,685
pondré una captura en este punto,

260
00:22:54,685 --> 00:23:03,845
así que diremos error catch y si se produce el error,

261
00:23:03,845 --> 00:23:09,130
entonces simplemente pasaré

262
00:23:09,130 --> 00:23:14,560
el error al siguiente para

263
00:23:14,560 --> 00:23:20,090
que el controlador de errores pueda lidiar con el error apropiadamente.

264
00:23:20,090 --> 00:23:24,415
Así que eso termina este usuario Findone.

265
00:23:24,415 --> 00:23:31,020
Ahora, este es el caso cuando el req.session.user no está configurado.

266
00:23:31,020 --> 00:23:32,905
Si eso ya está configurado

267
00:23:32,905 --> 00:23:38,095
, significa que el usuario ya ha iniciado sesión.

268
00:23:38,095 --> 00:23:40,630
Entonces, en este caso,

269
00:23:40,630 --> 00:23:50,650
la parte más aquí trata de la situación diciendo que estableceremos

270
00:23:50,650 --> 00:23:52,660
el StatusCode en 200

271
00:23:52,660 --> 00:24:12,205
y el Content-Type en texto/plain y luego diremos:

272
00:24:12,205 --> 00:24:17,680
«Ya está autenticado».

273
00:24:17,680 --> 00:24:21,910
Por lo tanto, si llega a esta parte,

274
00:24:22,690 --> 00:24:29,060
vendría aquí porque el req.session.user ya no es

275
00:24:29,060 --> 00:24:32,150
nulo, lo que significa que el usuario ya ha sido autenticado,

276
00:24:32,150 --> 00:24:34,995
lo que significa que cuando llegue a este punto,

277
00:24:34,995 --> 00:24:38,200
el usuario ya ha iniciado sesión antes,

278
00:24:38,200 --> 00:24:41,100
por lo que no necesita verificarlo.

279
00:24:41,100 --> 00:24:42,220
Así que simplemente dirás,

280
00:24:42,220 --> 00:24:46,270
«Ya estás autenticado», y luego terminarás en este punto.

281
00:24:46,270 --> 00:24:54,975
Está bien. Así que ahora, el último método que vamos a implementar es para cerrar la sesión del usuario.

282
00:24:54,975 --> 00:24:59,180
Por lo tanto, vamos a hacer un router.get on /logout.

283
00:24:59,180 --> 00:25:02,170
Usted debe estar preguntando por qué hacemos un conseguir en

284
00:25:02,170 --> 00:25:07,000
el cierre de sesión en lugar de una publicación que hicimos en el inicio de sesión? Al

285
00:25:07,000 --> 00:25:11,090
iniciar sesión, debe enviar el nombre de usuario y la contraseña.

286
00:25:11,090 --> 00:25:14,900
Para cerrar la sesión, simplemente está cerrando sesión usted mismo del sistema,

287
00:25:14,900 --> 00:25:17,590
por lo que no necesita proporcionar más información porque

288
00:25:17,590 --> 00:25:20,910
el servidor ya le está rastreando basándose en

289
00:25:20,910 --> 00:25:30,665
su ID de sesión y dentro de esa cookie de sesión aquí.

290
00:25:30,665 --> 00:25:32,620
Por lo tanto, es por eso que no

291
00:25:32,620 --> 00:25:38,890
necesitamos explícitamente enviar ninguna información adicional en el cuerpo del mensaje.

292
00:25:38,890 --> 00:25:46,120
Así que diremos si req.session lo que significa que la sesión debe existir, de

293
00:25:46,120 --> 00:25:50,070
lo contrario, está tratando de cerrar la sesión de un usuario que no ha iniciado sesión.

294
00:25:50,070 --> 00:25:52,280
Así que no tiene sentido.

295
00:25:52,280 --> 00:25:57,490
Ahora, la sesión en sí proporciona este método

296
00:25:57,490 --> 00:26:03,415
llamado destroy y cuando se llama al método destroy,

297
00:26:03,415 --> 00:26:07,520
la sesión se destruye y la información se elimina

298
00:26:07,520 --> 00:26:12,945
del lado del servidor perteneciente a esta sesión.

299
00:26:12,945 --> 00:26:16,970
Entonces, lo que significa que si el cliente intenta volver a enviar

300
00:26:16,970 --> 00:26:19,190
la información de la sesión que se almacena en forma

301
00:26:19,190 --> 00:26:21,430
de una cookie firmada en el lado del cliente,

302
00:26:21,430 --> 00:26:22,640
eso no será válido.

303
00:26:22,640 --> 00:26:27,870
Por lo tanto, necesitamos un método para eliminar la cookie que se almacena en el lado del cliente.

304
00:26:27,870 --> 00:26:31,110
Ahora, esta operación eliminará

305
00:26:31,110 --> 00:26:36,805
la información de sesión del lado del servidor para que la sesión ya no sea válida.

306
00:26:36,805 --> 00:26:38,060
Entonces, en este punto,

307
00:26:38,060 --> 00:26:45,115
diremos req.session.destroy y luego diremos, Res.ClearCookie.

308
00:26:45,115 --> 00:26:49,640
Por lo tanto, ClearCookie es una forma de pedirle al cliente que

309
00:26:49,640 --> 00:26:54,875
elimine la cookie y el nombre de la cookie es el ID de sesión.

310
00:26:54,875 --> 00:26:56,630
Entonces, en el ejercicio anterior,

311
00:26:56,630 --> 00:27:00,910
vimos que la cookie se almacenaba con el nombre del ID de sesión en el lado del cliente.

312
00:27:00,910 --> 00:27:05,430
Así que le pedimos al cliente que elimine esta cookie desde

313
00:27:05,430 --> 00:27:10,935
el lado del cliente en el mensaje de respuesta y luego diremos,

314
00:27:10,935 --> 00:27:16,835
res.redirect y la redireccionaremos a la página de inicio aquí.

315
00:27:16,835 --> 00:27:21,540
Por lo tanto, esta es una forma de redirigir al usuario para que ingrese a su página estándar,

316
00:27:21,540 --> 00:27:24,790
por ejemplo, la página de inicio de su aplicación.

317
00:27:24,790 --> 00:27:31,090
Por lo tanto, esta es la forma en que manejaría el cierre de sesión del sistema.

318
00:27:31,090 --> 00:27:33,200
Si el req.session no existe,

319
00:27:33,200 --> 00:27:35,380
entonces eso significa que no has iniciado sesión,

320
00:27:35,380 --> 00:27:37,310
por lo que tendremos que generar un error.

321
00:27:37,310 --> 00:27:38,945
Entonces diremos var err,

322
00:27:38,945 --> 00:27:46,370
nuevo Error, «No está conectado»,

323
00:27:47,100 --> 00:27:52,615
y estableceremos el estado del error en 403,

324
00:27:52,615 --> 00:27:54,760
esta es una operación prohibida y

325
00:27:54,760 --> 00:28:01,060
luego generaremos el error al controlador de errores, eso es todo.

326
00:28:01,060 --> 00:28:08,830
Así que ahora, vemos que hemos ampliado el router del usuario para admitir tres nuevos endpoints,

327
00:28:08,830 --> 00:28:13,330
el endpoint de suscripción que permite a un usuario registrarse,

328
00:28:13,330 --> 00:28:17,785
el endpoint de inicio de sesión que permite a un usuario registrado iniciar sesión,

329
00:28:17,785 --> 00:28:24,730
y luego el extremo de cierre de sesión que permite a un usuario conectado cerrar sesión del sistema.

330
00:28:24,730 --> 00:28:26,970
En el proceso de cierre de sesión,

331
00:28:26,970 --> 00:28:29,340
está destruyendo la sesión en el lado del servidor,

332
00:28:29,340 --> 00:28:31,890
también está borrando la cookie en el lado del cliente, de

333
00:28:31,890 --> 00:28:40,350
modo que el cliente no se puede usar en la sesión caducada para intentar ponerse en contacto con ese servidor.

334
00:28:40,350 --> 00:28:43,480
Una corrección menor en users.js,

335
00:28:43,480 --> 00:28:49,225
esto debería ser var Usuario requiere.. /models/user,

336
00:28:49,225 --> 00:28:58,095
recuerde que el archivo users.js está en la carpeta de rutas y luego

337
00:28:58,095 --> 00:29:01,130
el archivo user.js está en

338
00:29:01,130 --> 00:29:07,440
la carpeta de modelos que está arriba un nivel y luego en la carpeta de modelos.

339
00:29:07,440 --> 00:29:11,620
Por lo tanto, esto debería ser... /models/user,

340
00:29:11,620 --> 00:29:15,655
así que haz esa corrección menor, eso es todo.

341
00:29:15,655 --> 00:29:19,040
Hemos modificado el archivo users.js,

342
00:29:19,040 --> 00:29:23,690
ahora lo último que tenemos que hacer es ir y arreglar el archivo app.js.

343
00:29:23,690 --> 00:29:25,965
En el archivo app.js de la aplicación,

344
00:29:25,965 --> 00:29:29,520
si navega en el archivo app.js,

345
00:29:29,520 --> 00:29:31,160
verá que tenemos

346
00:29:31,160 --> 00:29:37,240
este índice de barra diagonal aquí y los usuarios slash aquí después de la autenticación.

347
00:29:37,240 --> 00:29:43,360
Ahora, esto no funcionará para nosotros porque si necesita registrarse,

348
00:29:43,360 --> 00:29:49,140
entonces el usuario se registrará e iniciará sesión antes de que se confirme la autorización, de

349
00:29:49,140 --> 00:29:54,910
todos modos si el registro e inicio de sesión es para el proceso de registro,

350
00:29:54,910 --> 00:30:04,295
así que voy a mover estos a arriba antes del paso de autenticación aquí.

351
00:30:04,295 --> 00:30:09,280
Por lo tanto, vamos a mover esto a este lugar.

352
00:30:09,280 --> 00:30:15,430
Por lo tanto, un usuario entrante puede acceder al archivo de índice

353
00:30:15,430 --> 00:30:21,589
en la barra diagonal y también acceder al extremo de los usuarios sin ser autenticado,

354
00:30:21,589 --> 00:30:23,205
pero cualquier otro extremo,

355
00:30:23,205 --> 00:30:25,400
el usuario tiene que ser autenticado,

356
00:30:25,400 --> 00:30:28,665
por lo que es la forma en que configuramos esto.

357
00:30:28,665 --> 00:30:32,375
Dentro de la autenticación de la función, diremos,

358
00:30:32,375 --> 00:30:40,695
«Si no req.session.user», entonces

359
00:30:40,695 --> 00:30:47,980
notamos que este lugar, no estaríamos permitiendo que el usuario entre aquí sin que el usuario haya iniciado sesión.

360
00:30:47,980 --> 00:30:50,450
Por lo tanto, si no req.session.user,

361
00:30:50,450 --> 00:30:55,170
simplemente diríamos que no está autenticado.

362
00:31:03,600 --> 00:31:09,330
Esta autenticación tiene que hacerse utilizando el método de inicio de sesión aquí.

363
00:31:09,330 --> 00:31:13,510
Por lo tanto, voy a quitar toda esta parte aquí.

364
00:31:17,340 --> 00:31:22,285
Por lo tanto, diremos, si no req.session.user,

365
00:31:22,285 --> 00:31:28,670
diremos que no está autenticado y por lo tanto tendremos que enviar una foto tres aquí,

366
00:31:28,670 --> 00:31:31,560
lo que significa que nunca debe bajar a este punto

367
00:31:31,560 --> 00:31:34,785
sin que el usuario inicie sesión.

368
00:31:34,785 --> 00:31:37,575
Por lo tanto, diremos que no está autenticado.

369
00:31:37,575 --> 00:31:41,990
Recuerde que necesita autenticarse haciendo una POST en

370
00:31:41,990 --> 00:31:47,120
el punto final de inicio de sesión de los usuarios de barra diagonal.

371
00:31:47,120 --> 00:31:50,930
Entonces diremos que no está autenticado, de lo contrario,

372
00:31:50,930 --> 00:31:56,175
si req.session.user es igual a,

373
00:31:56,175 --> 00:32:01,720
recuerde que en la función de inicio de sesión en el

374
00:32:01,720 --> 00:32:07,780
users.js hemos establecido el siguiente usuario de sesión a la cadena autenticada.

375
00:32:07,780 --> 00:32:10,055
Por lo tanto, eso es lo que vamos a estar buscando.

376
00:32:10,055 --> 00:32:14,355
Diremos que si req.session.user está autenticado,

377
00:32:14,355 --> 00:32:21,955
diremos a continuación, de lo contrario no se autentica de nuevo.

378
00:32:21,955 --> 00:32:31,990
Entonces enviaremos un mensaje prohibido. Eso es todo.

379
00:32:31,990 --> 00:32:33,995
Entonces, con esta actualización,

380
00:32:33,995 --> 00:32:36,375
mi archivo app.js también está listo.

381
00:32:36,375 --> 00:32:38,590
Ahora, después de haber hecho estas actualizaciones,

382
00:32:38,590 --> 00:32:42,470
vamos a comprobar cómo funciona nuestra aplicación ahora.

383
00:32:42,470 --> 00:32:44,350
Ir al terminal,

384
00:32:44,350 --> 00:32:49,655
si el servidor se está ejecutando, deténgalo y luego reinicie el servidor.

385
00:32:49,655 --> 00:32:51,600
Mi servidor no se está ejecutando en este momento,

386
00:32:51,600 --> 00:32:53,405
así que diré npm start,

387
00:32:53,405 --> 00:32:56,440
y mi servidor debería estar en funcionamiento.

388
00:32:56,440 --> 00:33:00,540
Veamos ahora cómo vamos a acceder al servidor.

389
00:33:00,540 --> 00:33:04,150
Ir a Cartero, déjame hacer un GET en

390
00:33:04,150 --> 00:33:07,290
localhost: 3000/platos y luego verá inmediatamente

391
00:33:07,290 --> 00:33:10,375
que se queja diciendo que no está autenticado.

392
00:33:10,375 --> 00:33:13,095
Obviamente, no estoy autenticado aquí.

393
00:33:13,095 --> 00:33:19,560
Déjame intentar acceder solo al localhost: 3000 y verás que,

394
00:33:19,560 --> 00:33:22,625
esa raíz está disponible para nosotros.

395
00:33:22,625 --> 00:33:29,850
Ahora, por supuesto, queremos registrar primero un usuario y luego iniciar sesión

396
00:33:29,850 --> 00:33:37,745
como el usuario y luego obtener acceso al resto de los extremos de la API REST.

397
00:33:37,745 --> 00:33:40,480
Entonces, primero, déjame registrar a un usuario.

398
00:33:40,480 --> 00:33:41,925
Para registrar al usuario,

399
00:33:41,925 --> 00:33:51,410
necesito hacer una POST al localhost: 3000/usuarios/registro.

400
00:33:53,700 --> 00:33:57,710
Para este mensaje POST,

401
00:33:57,930 --> 00:34:01,635
en el cuerpo del mensaje,

402
00:34:01,635 --> 00:34:07,860
necesito incluir en el cuerpo

403
00:34:07,860 --> 00:34:15,080
del mensaje una cadena JSON con el nombre de usuario.

404
00:34:15,080 --> 00:34:19,390
Por lo tanto, déjame iniciar sesión y

405
00:34:19,390 --> 00:34:27,770
luego usaré la contraseña como contraseña.

406
00:34:28,810 --> 00:34:31,835
Este es un registro válido.

407
00:34:31,835 --> 00:34:35,505
Por lo tanto, cuando me registro como usuario con

408
00:34:35,505 --> 00:34:42,150
esta información en forma de una cadena JSON incluida en el cuerpo del mensaje,

409
00:34:42,150 --> 00:34:47,590
déjame ver que el encabezado ahora contiene aplicación de tipo de contenido,

410
00:34:47,590 --> 00:34:50,440
JSON porque he configurado el JSON en

411
00:34:50,440 --> 00:34:54,660
el cuerpo del mensaje y luego enviar el POST al registro.

412
00:34:54,660 --> 00:34:57,175
Luego, cuando envío el POST al registro,

413
00:34:57,175 --> 00:35:02,460
inmediatamente verá lo que devuelve el servidor aquí.

414
00:35:02,460 --> 00:35:05,630
Entonces, ves que el servidor ha regresado diciendo,

415
00:35:05,630 --> 00:35:10,205
«Registro exitoso» y en sí mismo,

416
00:35:10,205 --> 00:35:13,485
me da los detalles del usuario aquí.

417
00:35:13,485 --> 00:35:19,340
Entonces, este es un registro que existe en mi MongoDB y

418
00:35:19,340 --> 00:35:25,090
tenga en cuenta que el tipo de modelo es el tipo de modelo de usuario que teníamos configurado.

419
00:35:25,090 --> 00:35:28,300
Por lo tanto, tenemos el nombre de usuario y

420
00:35:28,300 --> 00:35:33,535
la contraseña y el indicador de administrador como puede ver está establecido en falso por defecto.

421
00:35:33,535 --> 00:35:37,285
Una vez que registramos al usuario,

422
00:35:37,285 --> 00:35:40,370
este usuario es ahora un usuario válido.

423
00:35:40,370 --> 00:35:45,640
Por lo tanto, permítanme intentar volver a POST al mismo usuario y ver qué sucede.

424
00:35:45,640 --> 00:35:48,935
Entonces, cuando POSTO al mismo usuario obviamente,

425
00:35:48,935 --> 00:35:50,385
desde el lado del servidor,

426
00:35:50,385 --> 00:35:52,840
responde diciendo que este usuario ya existe.

427
00:35:52,840 --> 00:35:58,480
Por lo tanto, puede ver que hemos configurado nuestro procedimiento de registro para no permitir al

428
00:35:58,480 --> 00:36:04,580
usuario duplicar el registro con el mismo ID de usuario.

429
00:36:04,580 --> 00:36:07,135
Está bien. Así que, esa es la segunda parte.

430
00:36:07,135 --> 00:36:13,570
Ahora, vamos a hacer un inicio de sesión del usuario.

431
00:36:13,570 --> 00:36:15,770
Para hacer un inicio de sesión del usuario,

432
00:36:15,770 --> 00:36:20,400
permítanme eliminar el tipo de contenido y luego también

433
00:36:20,400 --> 00:36:25,440
eliminaré el cuerpo porque para el inicio de sesión, eso no es necesario.

434
00:36:25,440 --> 00:36:28,200
Por lo tanto, no relleno nada en

435
00:36:28,200 --> 00:36:31,790
el encabezado y luego trato de iniciar sesión y cuando intenté iniciar sesión,

436
00:36:31,790 --> 00:36:34,805
responde diciendo que no está autenticado.

437
00:36:34,805 --> 00:36:36,175
Usted no está autorizado.

438
00:36:36,175 --> 00:36:39,595
Ahora, necesito conectarme yo mismo.

439
00:36:39,595 --> 00:36:42,940
Entonces, aquí es donde puedo usar la autenticación básica.

440
00:36:42,940 --> 00:36:46,240
Entonces, en la autenticación básica,

441
00:36:46,240 --> 00:36:51,170
solo voy a escribir mi nombre de usuario y

442
00:36:51,170 --> 00:36:56,575
contraseña que acabo de registrar en el paso anterior y luego actualizar mi solicitud,

443
00:36:56,575 --> 00:37:00,060
y luego hacer una POST en el inicio de sesión.

444
00:37:00,060 --> 00:37:02,400
Entonces, cuando hago una POST en el inicio de sesión,

445
00:37:02,400 --> 00:37:06,935
ves que el servidor responde diciendo: «Estás autenticado».

446
00:37:06,935 --> 00:37:08,740
Entonces, en este punto,

447
00:37:08,740 --> 00:37:11,400
puedo realizar las

448
00:37:11,400 --> 00:37:16,115
solicitudes GET, PUT, POST y DELETE en todos los otros puntos finales.

449
00:37:16,115 --> 00:37:26,370
Entonces, en este punto, si hago un GET en el extremo de los platos,

450
00:37:28,760 --> 00:37:32,675
verías que esto devuelve

451
00:37:32,675 --> 00:37:39,160
el campo vacío porque mi base de datos está vacía actualmente en este momento.

452
00:37:39,160 --> 00:37:44,370
Permítanme borrar la autorización y también del encabezado eliminar

453
00:37:44,370 --> 00:37:49,575
la autorización y luego hacer el GET y su caja de herramientas muy bien.

454
00:37:49,575 --> 00:37:52,480
Por lo tanto, puede ver que ahora puedo

455
00:37:52,480 --> 00:37:56,065
acceder a los puntos finales porque he iniciado sesión.

456
00:37:56,065 --> 00:38:00,040
Así que ahora, déjame hacer un cierre de sesión del usuario.

457
00:38:00,040 --> 00:38:05,910
Entonces, diremos, localhost: 3000 y cierre de sesión.

458
00:38:05,910 --> 00:38:08,875
Tenga en cuenta también que, en las cookies,

459
00:38:08,875 --> 00:38:12,290
se ha configurado una cookie en el ID de sesión justo allí.

460
00:38:12,290 --> 00:38:17,080
Por lo tanto, esa cookie existe en mi sitio cliente.

461
00:38:17,080 --> 00:38:22,715
Así que ahora, permítanme cerrar la sesión diciendo GET localhost: 3000/usuarios/cierre de sesión.

462
00:38:22,715 --> 00:38:26,580
Por lo tanto, cuando cierre sesión del usuario,

463
00:38:26,580 --> 00:38:29,765
inmediatamente verá que soy redirigido a

464
00:38:29,765 --> 00:38:37,830
ese punto final localhost: 3000 y también notará que la cookie se ha ido.

465
00:38:37,830 --> 00:38:40,140
Entonces, cuando miro las cookies,

466
00:38:40,140 --> 00:38:42,040
ves que el localhost,

467
00:38:42,040 --> 00:38:46,470
la cookie se ha ido porque desde mi lado del servidor cuando hago el cierre de sesión,

468
00:38:46,470 --> 00:38:51,495
envía una cookie clara de descanso al lado del cliente y así la cookie se ha ido.

469
00:38:51,495 --> 00:38:54,555
Ahora, si trato de hacer un GET

470
00:38:54,555 --> 00:39:02,480
en el punto final localhost: 3000/platos,

471
00:39:02,480 --> 00:39:05,899
esto no funcionará porque no estoy autenticado.

472
00:39:05,899 --> 00:39:11,610
Por lo tanto, esto demuestra cómo puede extender su servidor Express para

473
00:39:11,610 --> 00:39:17,190
permitir que los usuarios se registren y luego permitir que el usuario inicie sesión en el sistema,

474
00:39:17,190 --> 00:39:19,860
y luego también cierre sesión del sistema.

475
00:39:19,860 --> 00:39:25,520
En el lado del servidor, está rastreando a un usuario conectado usando la sesión y usando

476
00:39:25,520 --> 00:39:28,260
la cookie en el lado del cliente y cuando el usuario cierra

477
00:39:28,260 --> 00:39:31,375
sesión, la cookie se destruye en el lado del cliente.

478
00:39:31,375 --> 00:39:34,540
Con esto, completamos este ejercicio.

479
00:39:34,540 --> 00:39:37,390
Este es un buen momento para que hagas una confirmación de Git,

480
00:39:37,390 --> 00:39:42,420
con el mensaje, Sesiones Express segunda parte.