1
00:00:03,890 --> 00:00:11,670
Ahora que hemos entendido la autenticación basada en token usando los tokens web JSON,

2
00:00:11,670 --> 00:00:16,035
y también hemos entendido las ventajas de usar este enfoque.

3
00:00:16,035 --> 00:00:22,185
El hecho de que ahora estamos construyendo un servidor basado en Rest API,

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

5
00:00:24,420 --> 00:00:27,585
la autenticación basada en JSON Web Token

6
00:00:27,585 --> 00:00:31,410
es la más adecuada para este servidor que estamos construyendo.

7
00:00:31,410 --> 00:00:40,585
Por lo tanto, vamos a actualizar nuestro servidor Rest API para hacer uso de JSON Web Tokens en este ejercicio.

8
00:00:40,585 --> 00:00:45,755
Para comenzar a actualizar el servidor en su terminal,

9
00:00:45,755 --> 00:00:51,935
primero instalemos el JSON Web Token y el módulo Passport JWT Node.

10
00:00:51,935 --> 00:00:56,445
Entonces, en el símbolo del sistema, escriba npm, instale,

11
00:00:56,445 --> 00:01:05,640
pasaporte JWT JSON Web Token y menos guardar.

12
00:01:05,640 --> 00:01:15,435
Como puede ver, estoy usando JSON Web Token 8.3.0 y pasaporte JWT 4.0.0 en este curso.

13
00:01:15,435 --> 00:01:23,180
Ahora que hemos completado la instalación, sigamos adelante y actualicemos nuestro servidor express.

14
00:01:23,180 --> 00:01:25,700
Pasando ahora a nuestro código,

15
00:01:25,700 --> 00:01:30,289
agreguemos un archivo llamado

16
00:01:30,289 --> 00:01:36,335
conflict.js en la carpeta raíz de nuestro proyecto.

17
00:01:36,335 --> 00:01:39,455
Ahora, este archivo conflict.js voy a usarlo

18
00:01:39,455 --> 00:01:43,220
para almacenar cierta información de configuración para nuestro servidor.

19
00:01:43,220 --> 00:01:49,790
Ahora bien, esta es una forma de centralizar toda la configuración de nuestro servidor.

20
00:01:49,790 --> 00:01:53,600
En este archivo conflict.js,

21
00:01:53,600 --> 00:01:59,825
permítanme exportar un objeto JSON aquí.

22
00:01:59,825 --> 00:02:02,490
Así que diremos, SecretKey,

23
00:02:08,510 --> 00:02:11,550
y aquí es donde

24
00:02:19,450 --> 00:02:28,705
especificaré la clave secreta que voy a usar para firmar mi JSON Web Token,

25
00:02:28,705 --> 00:02:36,700
y también déjame especificar una URL Mongo aquí,

26
00:02:36,700 --> 00:02:41,275
que será la URL de

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

28
00:02:52,200 --> 00:02:55,060
Una vez que hayamos completado eso,

29
00:02:55,060 --> 00:02:59,260
entonces iremos al archivo authenticate.js,

30
00:02:59,260 --> 00:03:01,780
y en el archivo authenticate.js

31
00:03:01,780 --> 00:03:10,700
ahora crearemos la estrategia JWT.

32
00:03:11,250 --> 00:03:16,175
Esta es la estrategia de token web JSON que es proporcionada por

33
00:03:16,175 --> 00:03:25,830
nuestro módulo de nodo JWT pasaporte que acabamos de incluir y por lo que diremos,

34
00:03:26,300 --> 00:03:32,895
estrategia de generatividad pasaporte generativity.strategy.

35
00:03:32,895 --> 00:03:35,370
Esto nos proporcionará

36
00:03:35,370 --> 00:03:40,550
una estrategia basada en JSON Web Token para configurar nuestro módulo de pasaporte,

37
00:03:40,550 --> 00:03:46,820
luego extraiga JWT, que

38
00:03:46,820 --> 00:03:53,745
también obtendré del pasaporte JWT.

39
00:03:53,745 --> 00:03:55,935
Vamos a requerir pasaporte JWT,

40
00:03:55,935 --> 00:03:59,565
luego diremos «Extraer JWT».

41
00:03:59,565 --> 00:04:02,655
Luego vamos a importar

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

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

44
00:04:12,265 --> 00:04:15,340
Una vez que hayamos importado estos

45
00:04:15,340 --> 00:04:18,370
, vamos a empezar a configurar algunas cosas.

46
00:04:18,370 --> 00:04:26,205
Junto con estos, permítanme importar la configuración que he

47
00:04:26,205 --> 00:04:35,840
creado el archivo config.js que acabo de agregar a mi proyecto.

48
00:04:35,840 --> 00:04:40,100
Una vez que complete esto, permítanme seguir adelante e

49
00:04:40,100 --> 00:04:45,650
introducir algunas funciones adicionales que exportaré desde aquí.

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

51
00:04:55,160 --> 00:05:02,840
esta función cuando suministre un parámetro allí que simplemente llamaré usuario,

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

53
00:05:06,335 --> 00:05:10,145
esto creará el token y lo dará para nosotros.

54
00:05:10,145 --> 00:05:16,685
Para crear el token, usaremos el módulo jsonwebtoken que acabamos de importar.

55
00:05:16,685 --> 00:05:22,140
Entonces, aquí diremos return jwt.sign,

56
00:05:23,750 --> 00:05:31,355
esto nos ayuda a crear el token web JSON y así dentro de eso

57
00:05:31,355 --> 00:05:34,430
me permitirá suministrar la carga útil y

58
00:05:34,430 --> 00:05:38,825
la carga útil aquí entra como el parámetro aquí llamado usuario,

59
00:05:38,825 --> 00:05:42,620
y luego el segundo parámetro es

60
00:05:42,620 --> 00:05:51,050
la clave secreta o privada que obtengo de config. clave secreta,

61
00:05:51,050 --> 00:05:55,260
que acabo de configurar un poco antes.

62
00:05:55,630 --> 00:06:02,835
Podemos suministrar opciones adicionales aquí.

63
00:06:02,835 --> 00:06:07,055
Una opción que voy a suministrar a esto es...

64
00:06:07,055 --> 00:06:09,410
Vale, déjame ir a la siguiente línea aquí,

65
00:06:09,410 --> 00:06:14,160
la opción que voy a suministrar es Expiresina.

66
00:06:14,530 --> 00:06:20,945
El Expiresina le dirá cuánto tiempo será

67
00:06:20,945 --> 00:06:27,185
válido el jsonwebtoken, así que en este caso digo 3,600 lo que significa 3,600 segundos o aproximadamente una hora.

68
00:06:27,185 --> 00:06:32,825
Una hora más tarde tendrá que renovar el jsonwebtoken.

69
00:06:32,825 --> 00:06:36,790
Una hora es lo suficientemente larga para que podamos probar nuestra aplicación.

70
00:06:36,790 --> 00:06:40,370
Puede configurar esto para que sea mucho más largo si lo decide.

71
00:06:40,370 --> 00:06:45,110
En una aplicación real, puede establecer que esto sea un valor mucho más largo tal vez

72
00:06:45,110 --> 00:06:50,075
unos días y esperar que el usuario vuelva a autenticarse cada pocos días.

73
00:06:50,075 --> 00:06:52,670
Ahora, también vamos a configurar

74
00:06:52,670 --> 00:06:58,025
la estrategia basada en jsonwebtoken para nuestra aplicación de pasaporte.

75
00:06:58,025 --> 00:07:02,900
Entonces, déjenme declarar una variable llamada opts,

76
00:07:02,900 --> 00:07:12,140
que no son más que las opciones que voy a especificar para mi estrategia basada en JWT.

77
00:07:12,140 --> 00:07:18,905
Así que diremos opta por JWTFromRequest.

78
00:07:18,905 --> 00:07:22,925
Ahora esta opción especifica

79
00:07:22,925 --> 00:07:28,580
cómo se debe extraer el jsonwebtoken del mensaje de solicitud entrante.

80
00:07:28,580 --> 00:07:33,755
Aquí es donde vamos a utilizar el extracto JWT.

81
00:07:33,755 --> 00:07:39,290
Este extracto JWT admite varios métodos

82
00:07:39,290 --> 00:07:44,970
para extraer información de la cabecera.

83
00:07:44,970 --> 00:07:49,580
Dirá de AuthHeader de AuthHeader como token portador,

84
00:07:49,580 --> 00:07:51,510
de encabezado qué esquema y así sucesivamente.

85
00:07:51,510 --> 00:07:54,380
Si lee la documentación,

86
00:07:54,380 --> 00:07:58,040
le dirá varias formas de extraer el jsonwebtoken.

87
00:07:58,040 --> 00:08:00,770
Puede pasar el token en el cuerpo

88
00:08:00,770 --> 00:08:04,970
del mensaje de solicitud entrante y luego puede extraerlo de allí,

89
00:08:04,970 --> 00:08:08,255
también puede usar extractores personalizados, etc.

90
00:08:08,255 --> 00:08:14,180
En este curso, voy a usar el método más simple llamado

91
00:08:14,180 --> 00:08:20,745
desde el encabezado de autenticación como un token portador.

92
00:08:20,745 --> 00:08:22,220
Ya estamos familiarizados con

93
00:08:22,220 --> 00:08:25,055
el encabezado de autenticación porque ya hemos estado usando eso con

94
00:08:25,055 --> 00:08:30,440
la autenticación básica y la autenticación basada en cookies anteriormente.

95
00:08:30,440 --> 00:08:32,180
Por lo tanto, solo voy a usar

96
00:08:32,180 --> 00:08:38,350
ese mismo campo de encabezado en el mensaje de solicitud para llevar el jsonwebtoken.

97
00:08:38,350 --> 00:08:45,270
Así que diré opta como token portador jsonwebtoken.

98
00:08:45,270 --> 00:08:51,160
El siguiente diremos opts.secretorkey,

99
00:08:56,980 --> 00:09:02,795
este es el segundo parámetro que me ayuda a

100
00:09:02,795 --> 00:09:11,670
proporcionar la clave secreta que voy a usar dentro de mi estrategia para el inicio de sesión.

101
00:09:11,670 --> 00:09:15,875
Así que esa es la otra opción que voy a especificar aquí.

102
00:09:15,875 --> 00:09:18,065
Una vez que esté especificando estos dos,

103
00:09:18,065 --> 00:09:26,390
permítanme exportar la estrategia de Passport

104
00:09:26,390 --> 00:09:30,680
que voy a configurar aquí, así que diremos ExportJWTPassport,

105
00:09:30,680 --> 00:09:34,355
luego diríamos passport.use.

106
00:09:34,355 --> 00:09:37,940
Recuerde la forma en que especificó la estrategia local anteriormente.

107
00:09:37,940 --> 00:09:42,035
Aquí estamos especificando la estrategia basada en JWT,

108
00:09:42,035 --> 00:09:47,895
luego vamos a crear una nueva estrategia JWT,

109
00:09:47,895 --> 00:09:51,320
recordar que acabamos de importar la estrategia JWT

110
00:09:51,320 --> 00:09:56,615
aquí que es lo que vamos a utilizar para crear una nueva estrategia.

111
00:09:56,615 --> 00:10:01,235
Esta estrategia JWT toma

112
00:10:01,235 --> 00:10:07,675
el objeto de opciones que acabo de crear como el primer parámetro.

113
00:10:07,675 --> 00:10:14,210
Las opciones de estrategia y la segunda es la función de verificación que necesito suministrar,

114
00:10:14,210 --> 00:10:18,050
y por lo tanto, la función de verificación la voy a suministrar en la siguiente línea aquí,

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

116
00:10:28,545 --> 00:10:33,900
Hecho. Por lo tanto, cuando se llama a esta función,

117
00:10:33,900 --> 00:10:39,270
el hecho es la devolución de llamada que proporciona el pasaporte.

118
00:10:39,270 --> 00:10:44,270
Por lo tanto, cada vez que tenga pasaporte que está configurando con una nueva estrategia,

119
00:10:44,270 --> 00:10:46,750
debe proporcionar el segundo parámetro hecho.

120
00:10:46,750 --> 00:10:48,460
A través de este parámetro hecho,

121
00:10:48,460 --> 00:10:52,235
pasará información al pasaporte que luego

122
00:10:52,235 --> 00:10:57,780
usará para cargar cosas en el mensaje de solicitud.

123
00:10:57,780 --> 00:11:00,710
Por lo tanto, cuando el pasaporte analiza el mensaje de solicitud,

124
00:11:00,710 --> 00:11:04,110
utilizará la estrategia y luego extraerá información,

125
00:11:04,110 --> 00:11:09,540
y luego la cargará en nuestro mensaje de solicitud.

126
00:11:09,540 --> 00:11:13,905
Entonces, dado que esto es una función,

127
00:11:13,905 --> 00:11:19,795
solo voy a usar una función de flecha aquí,

128
00:11:19,795 --> 00:11:22,160
me han encantado las funciones de flecha.

129
00:11:22,160 --> 00:11:25,650
Entonces, déjame crear eso como una función de flecha aquí,

130
00:11:25,650 --> 00:11:28,345
y dentro de esta función,

131
00:11:28,345 --> 00:11:30,465
vamos a definir la función.

132
00:11:30,465 --> 00:11:32,970
Entonces, ¿qué hacemos dentro de la función?

133
00:11:32,970 --> 00:11:37,420
Déjame hacer un console.log de

134
00:11:38,370 --> 00:11:44,020
carga útil de JWT y luego

135
00:11:44,660 --> 00:11:49,995
déjame cerrar la sesión de la opción que viene aquí,

136
00:11:49,995 --> 00:11:51,770
la opción de carga útil JWT que viene aquí,

137
00:11:51,770 --> 00:11:55,420
para que puedas ver lo que hay dentro de la carga útil de JWT.

138
00:11:55,420 --> 00:12:04,250
Luego, buscaremos un usuario diciendo user.findone,

139
00:12:04,250 --> 00:12:14,020
y luego sé que en jwt.payload,

140
00:12:14,020 --> 00:12:17,210
hay un campo de ID que entra.

141
00:12:17,210 --> 00:12:21,360
Entonces, eso es lo que voy a asignar como el campo ID aquí.

142
00:12:21,360 --> 00:12:26,040
Entonces, diré, user.findone y el segundo

143
00:12:26,040 --> 00:12:36,190
es una función de devolución de llamada.

144
00:12:36,870 --> 00:12:45,295
Como te das cuenta, este método de mangosta usuario y tratas de encontrar.

145
00:12:45,295 --> 00:12:54,665
Entonces, diremos si erran entonces, regresa hecho.

146
00:12:54,665 --> 00:12:57,945
¿ Qué hace esto? Esto hecho es la devolución de llamada que el

147
00:12:57,945 --> 00:13:02,155
pasaporte pasará a su estrategia aquí.

148
00:13:02,155 --> 00:13:04,965
Por lo tanto, vamos a llamar a esta función hecha.

149
00:13:04,965 --> 00:13:11,200
Esto hecho en pasaporte toma tres parámetros.

150
00:13:12,890 --> 00:13:20,400
Por lo tanto, puede ver las tres piezas de información que este hecho espera que diga, error: cualquiera.

151
00:13:20,400 --> 00:13:24,525
Por lo tanto, si tiene un error, lo pasará como el primer parámetro. ¿

152
00:13:24,525 --> 00:13:26,495
El segundo parámetro, usuario? ,

153
00:13:26,495 --> 00:13:28,245
Si existe un usuario,

154
00:13:28,245 --> 00:13:33,770
entonces el valor del usuario se pasará y luego si hay alguna información? :, cualquiera.

155
00:13:33,770 --> 00:13:37,100
Por lo tanto, estos dos son parámetros opcionales y, por lo tanto,

156
00:13:37,100 --> 00:13:38,690
si pasa alguna información,

157
00:13:38,690 --> 00:13:42,145
entonces se usará dentro de la aplicación.

158
00:13:42,145 --> 00:13:44,650
Si paso falso como el segundo parámetro,

159
00:13:44,650 --> 00:13:47,515
entonces eso significa que el usuario no existe o eso.

160
00:13:47,515 --> 00:13:50,810
Por lo tanto, interpretará que el usuario no existe.

161
00:13:50,810 --> 00:13:52,335
Así que, podría decir, errr,

162
00:13:52,335 --> 00:13:54,900
falso, porque esto es un error.

163
00:13:54,900 --> 00:13:58,080
Por lo tanto, no voy a pasar un valor de usuario allí,

164
00:13:58,080 --> 00:14:00,660
solo voy a pasar en falso.

165
00:14:00,660 --> 00:14:06,040
Allí, el siguiente,

166
00:14:06,040 --> 00:14:11,510
podemos decir, si (usuario).

167
00:14:11,510 --> 00:14:15,860
Entonces, si el usuario no es nulo,

168
00:14:15,860 --> 00:14:18,960
diremos retorno hecho (nulo).

169
00:14:19,230 --> 00:14:22,210
No hay error, por lo que el primer parámetro será

170
00:14:22,210 --> 00:14:25,080
nulo y el segundo parámetro es el usuario,

171
00:14:25,080 --> 00:14:29,895
pero acabamos de llegar del MongoDB.

172
00:14:29,895 --> 00:14:35,445
De lo contrario, volveremos

173
00:14:35,445 --> 00:14:41,395
hecho con nulo, falso.

174
00:14:41,395 --> 00:14:43,650
Entonces, en el último caso,

175
00:14:43,650 --> 00:14:45,100
no pudimos encontrar al usuario,

176
00:14:45,100 --> 00:14:47,120
así que vamos a pasar en falso.

177
00:14:47,120 --> 00:14:50,200
Así que vamos a manejarlo así.

178
00:14:50,200 --> 00:14:53,345
Si lo desea, puede crear una nueva cuenta de usuario en este punto,

179
00:14:53,345 --> 00:14:58,365
pero voy a mantener esto simple sólo para que sea fácil de entender para nosotros.

180
00:14:58,365 --> 00:15:00,810
Así que, simplemente diremos, nulo, falso. Eso es seis.

181
00:15:00,810 --> 00:15:07,475
Entonces, esta es la estrategia de pasaporte JSONWebToken que acabo de configurar aquí.

182
00:15:07,475 --> 00:15:11,420
Además, permítanme exportar

183
00:15:11,420 --> 00:15:19,450
una función más desde aquí llamada VerifyUser.

184
00:15:19,450 --> 00:15:21,110
Ahora, esta función

185
00:15:21,110 --> 00:15:24,935
verifyUser, voy a usarlo para verificar un usuario entrante.

186
00:15:24,935 --> 00:15:28,810
Entonces, aquí es donde usaré passport.authenticate.

187
00:15:28,890 --> 00:15:36,440
Entonces, el passport.authenticate, la estrategia es la estrategia jwt que acabo de configurar,

188
00:15:36,440 --> 00:15:39,490
la estrategia JSONWebToken que acabo de configurar.

189
00:15:39,490 --> 00:15:41,625
Entonces, la segunda parte,

190
00:15:41,625 --> 00:15:46,305
diría yo, sesión: falsa.

191
00:15:46,305 --> 00:15:47,740
Por lo tanto, eso significa que

192
00:15:47,740 --> 00:15:51,305
no vamos a crear sesiones en este caso.

193
00:15:51,305 --> 00:15:58,215
Como usted recuerda, una aplicación inversa,

194
00:15:58,215 --> 00:16:00,530
estamos utilizando la autenticación basada en tokens.

195
00:16:00,530 --> 00:16:02,435
Así que no vamos a crear sesiones.

196
00:16:02,435 --> 00:16:07,690
Entonces, es por eso que configuré esta sesión de opciones en falsa aquí

197
00:16:07,690 --> 00:16:11,795
, y por supuesto, la primera especificó la estrategia que voy a usar.

198
00:16:11,795 --> 00:16:14,050
Entonces, para verificar a un usuario,

199
00:16:14,050 --> 00:16:15,930
usaré la estrategia JWT.

200
00:16:15,930 --> 00:16:18,110
¿ Cómo funciona la estrategia JWT?

201
00:16:18,110 --> 00:16:20,540
En la solicitud entrante,

202
00:16:21,040 --> 00:16:26,845
el token se incluirá en el encabezado de autenticación como vimos aquí.

203
00:16:26,845 --> 00:16:29,950
Dijimos encabezado de autenticación como token portador.

204
00:16:29,950 --> 00:16:33,530
Si eso está incluido, entonces eso se extraerá y se

205
00:16:33,530 --> 00:16:38,210
usará para autenticar al usuario basado en el token.

206
00:16:38,210 --> 00:16:47,770
Corrección menor aquí, esto debería ser user.findone_id es igual a jwt_payload. _id,

207
00:16:47,770 --> 00:16:56,475
porque ese es el valor de id que está dentro de la carga útil de mi JSONWebToken.

208
00:16:56,475 --> 00:17:01,615
Por lo tanto, estamos buscando al usuario con ese ID dado.

209
00:17:01,615 --> 00:17:06,170
Entonces, una vez que hayamos completado esto, entonces ahora,

210
00:17:06,170 --> 00:17:11,790
la segunda parte que tenemos que hacer es que necesitamos crear el token en algún lugar.

211
00:17:11,790 --> 00:17:14,005
Ahora, ¿dónde creamos el token?

212
00:17:14,005 --> 00:17:20,290
Entonces, aquí es donde algo que estamos haciendo en el archivo users.js es muy útil para nosotros.

213
00:17:20,290 --> 00:17:22,270
En el archivo users.js,

214
00:17:22,270 --> 00:17:27,180
recuerde que ya tiene este extremo llamado inicio de sesión.

215
00:17:27,180 --> 00:17:28,700
En el extremo de inicio de sesión,

216
00:17:28,700 --> 00:17:33,410
estaba usando el nombre de usuario y la contraseña para autenticar al usuario.

217
00:17:33,410 --> 00:17:38,030
Por lo tanto, incluso con el JSONWebToken para emitir el JSONWebToken,

218
00:17:38,030 --> 00:17:41,959
primero necesita autenticar al usuario usando una de las otras estrategias,

219
00:17:41,959 --> 00:17:44,630
y si va a usar la estrategia local primero,

220
00:17:44,630 --> 00:17:49,715
autenticaremos al usuario usando el nombre de usuario y la contraseña.

221
00:17:49,715 --> 00:17:53,415
Una vez que el usuario se autentica con el nombre de usuario y

222
00:17:53,415 --> 00:17:55,885
la contraseña, entonces emitiremos el token al usuario diciendo:

223
00:17:55,885 --> 00:17:57,330
«Vale, eres un usuario válido,

224
00:17:57,330 --> 00:17:58,630
te voy a dar el token».

225
00:17:58,630 --> 00:18:02,390
Todas las solicitudes posteriores simplemente llevarán el token

226
00:18:02,390 --> 00:18:06,860
en el encabezado del mensaje de solicitud entrante.

227
00:18:06,860 --> 00:18:10,415
Entonces, antes, solíamos crear sesiones.

228
00:18:10,415 --> 00:18:11,840
Cuando el usuario se autentica,

229
00:18:11,840 --> 00:18:13,935
ya no vamos a usar sesiones.

230
00:18:13,935 --> 00:18:17,640
En su lugar, cuando el usuario se autentica usando la estrategia local,

231
00:18:17,640 --> 00:18:20,110
emitiremos un token al usuario.

232
00:18:20,110 --> 00:18:25,955
Entonces, dentro de este método router.post que hemos hecho en ese endpoint /login,

233
00:18:25,955 --> 00:18:31,730
voy a crear un token y pasar este token de vuelta al usuario.

234
00:18:31,730 --> 00:18:36,980
Por lo tanto, aquí, vamos a decir un router.post.

235
00:18:38,550 --> 00:18:40,785
Déjame crear un token.

236
00:18:40,785 --> 00:18:42,630
Para crear un token,

237
00:18:42,630 --> 00:18:50,150
tenemos esta función en el módulo de autenticación llamado Authenticate.getToken.

238
00:18:51,250 --> 00:18:54,325
Así que, recordemos, que ya tenemos,

239
00:18:54,325 --> 00:18:57,050
para hacer uso de eso, por supuesto,

240
00:18:57,050 --> 00:18:59,210
incluso antes de empezar allí,

241
00:18:59,210 --> 00:19:02,750
necesito importar la autenticación.

242
00:19:05,940 --> 00:19:17,720
Módulo aquí. Por lo tanto, diremos que autenticar requiere. /authenticate.

243
00:19:18,000 --> 00:19:26,740
Entonces, cuando en su código aquí,

244
00:19:26,740 --> 00:19:29,270
ahora podemos decir Authenticate.getToken,

245
00:19:31,530 --> 00:19:37,585
y el getToken toma el parámetro aquí.

246
00:19:37,585 --> 00:19:41,875
Ahora, recuerde, retrocediendo el archivo authenticate.js.

247
00:19:41,875 --> 00:19:46,665
El archivo authenticate.js toma un parámetro aquí

248
00:19:46,665 --> 00:19:53,105
que se utilizará como carga útil cuando esté creando el JSONWebToken.

249
00:19:53,105 --> 00:19:55,785
Entonces, en el archivo users.js,

250
00:19:55,785 --> 00:19:59,230
voy a crear un token dando una carga útil,

251
00:19:59,230 --> 00:20:02,890
que solo contiene el ID del usuario.

252
00:20:02,890 --> 00:20:06,070
Entonces, diremos id: req.user. _id.

253
00:20:06,740 --> 00:20:11,940
Eso es suficiente para crear el JSONWebToken.

254
00:20:11,940 --> 00:20:15,315
No queremos incluir ninguna otra información del usuario.

255
00:20:15,315 --> 00:20:18,690
Si lo decide, puede incluir otras partes de la información del usuario,

256
00:20:18,690 --> 00:20:21,715
pero sugiero que mantenga el JSONWebToken pequeño.

257
00:20:21,715 --> 00:20:25,700
El ID de usuario es suficiente porque si necesita buscar al usuario,

258
00:20:25,700 --> 00:20:32,840
el ID de usuario es suficiente para buscar en MongoDB para el usuario.

259
00:20:32,840 --> 00:20:39,230
Por lo tanto, solo voy a codificar solo el ID del usuario aquí.

260
00:20:39,230 --> 00:20:44,930
Ahora, usted sabe que el req.user ya estaría presente,

261
00:20:44,930 --> 00:20:50,530
porque cuando passport.authenticate ('local') autentica correctamente al usuario,

262
00:20:50,530 --> 00:20:54,650
esto va a cargar la propiedad del usuario en el mensaje de solicitud.

263
00:20:54,650 --> 00:20:57,300
Así que, por eso soy capaz de hacer esto aquí.

264
00:20:57,300 --> 00:21:01,830
Entonces, esto es lo que usaré para crear el token.

265
00:21:01,900 --> 00:21:05,120
Ahora, una vez que se crea el token,

266
00:21:05,120 --> 00:21:09,720
quiero pasar este token de nuevo al usuario.

267
00:21:09,720 --> 00:21:15,715
Entonces, en el objeto rest.json que estoy suministrando aquí,

268
00:21:15,715 --> 00:21:21,755
ya estoy llevando el indicador verdadero de éxito y también,

269
00:21:21,755 --> 00:21:23,855
un mensaje de estado aquí.

270
00:21:23,855 --> 00:21:28,270
Permítanme agregar el token

271
00:21:28,270 --> 00:21:34,880
como una de las propiedades en el mensaje de respuesta aquí.

272
00:21:36,480 --> 00:21:39,475
Entonces, el token que acabo de crear,

273
00:21:39,475 --> 00:21:47,595
pasaré esto como la segunda propiedad dentro de esta cadena Json aquí.

274
00:21:47,595 --> 00:21:55,370
Así que ahora, cuando mi cliente recibe esta cadena Json en el cuerpo del mensaje de respuesta,

275
00:21:55,370 --> 00:21:59,870
puede entrar y extraer el token desde allí.

276
00:22:00,140 --> 00:22:05,500
Eso es todo. Por lo tanto, ahora hemos actualizado el archivo users.js,

277
00:22:05,500 --> 00:22:08,630
y ahora puede ver cómo se

278
00:22:08,630 --> 00:22:12,690
creará el token y se enviará de vuelta al usuario cuando el usuario se autentique correctamente.

279
00:22:12,690 --> 00:22:16,330
Ahora, este esquema también se

280
00:22:16,330 --> 00:22:21,250
puede utilizar cuando se utiliza la autenticación de terceros como la basada en OAuth 2.0,

281
00:22:21,250 --> 00:22:23,525
que vamos a examinar en el siguiente módulo.

282
00:22:23,525 --> 00:22:25,695
Ahora, el procedimiento será similar.

283
00:22:25,695 --> 00:22:28,880
Estará creando un token cuando el usuario sea autenticado por

284
00:22:28,880 --> 00:22:32,560
el proveedor de autenticación de terceros u OAuth,

285
00:22:32,560 --> 00:22:35,640
y luego pasará el token de nuevo al usuario,

286
00:22:35,640 --> 00:22:39,010
en un enfoque similar al que ve aquí.

287
00:22:39,010 --> 00:22:41,285
Ahora, una vez que hayamos hecho esto,

288
00:22:41,285 --> 00:22:44,255
entonces vamos al archivo app.js.

289
00:22:44,255 --> 00:22:53,660
En el archivo app.js, porque hemos incluido un archivo de configuración aquí.

290
00:22:53,660 --> 00:22:59,005
Entonces, permítanme requerir el archivo de configuración aquí,

291
00:22:59,005 --> 00:23:06,465
y luego la URL que estoy usando aquí en lugar de codificar esta URL,

292
00:23:06,465 --> 00:23:11,345
diré config.mongoURL.

293
00:23:11,345 --> 00:23:16,680
Entonces, ahora, ve cómo mi archivo config.js se puede usar como

294
00:23:16,680 --> 00:23:23,520
un lugar centralizado donde puedo preparar la configuración para mi aplicación.

295
00:23:23,520 --> 00:23:29,200
Eso es todo. Entonces, lo que sucede ahora es que cuando el usuario se

296
00:23:29,200 --> 00:23:35,010
autentica en el endpoint /login y el usuario se autentica correctamente,

297
00:23:35,010 --> 00:23:40,840
entonces el token será creado por el servidor y enviado de vuelta al cliente o al usuario.

298
00:23:40,840 --> 00:23:43,765
Por lo tanto, el cliente incluirá el token en

299
00:23:43,765 --> 00:23:47,765
cada solicitud entrante posterior en el encabezado de autorización.

300
00:23:47,765 --> 00:23:50,590
Ahora, ¿cómo incluye el encabezado de autorización?

301
00:23:50,590 --> 00:23:54,220
Volvamos a authentic.js y aquí,

302
00:23:54,220 --> 00:24:01,625
ves que dijimos ExtractJWT.FromAuthHeaderasBearerToken aquí.

303
00:24:01,625 --> 00:24:06,290
Por lo tanto, esto se incluirá en el encabezado de autenticación como un token portador.

304
00:24:06,290 --> 00:24:08,385
Te mostraré cómo se hace esto,

305
00:24:08,385 --> 00:24:15,535
luego usamos cartero para incluir el token del portador en el encabezado de autenticación.

306
00:24:15,535 --> 00:24:17,690
Ahora, cuando esto llegue

307
00:24:17,690 --> 00:24:21,060
, recuerde que justo aquí abajo,

308
00:24:21,060 --> 00:24:25,095
ha configurado este método aquí llamado VerifyUser,

309
00:24:25,095 --> 00:24:30,635
que llama al pasaporte autenticarse con JWT.

310
00:24:30,635 --> 00:24:34,460
Por lo tanto, este usa el token que

311
00:24:34,460 --> 00:24:38,620
viene en el encabezado de autenticación y luego verifica al usuario.

312
00:24:38,620 --> 00:24:41,980
Por lo tanto, cada vez que quiero verificar la autenticidad del usuario,

313
00:24:41,980 --> 00:24:43,855
simplemente puedo llamar a verificar usuario,

314
00:24:43,855 --> 00:24:49,115
y eso iniciará la llamada al passport.authenticate y verificará el sser.

315
00:24:49,115 --> 00:24:50,315
Si esto tiene éxito

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

317
00:24:51,800 --> 00:24:55,620
Este procedimiento es muy similar a lo que ha hecho en el

318
00:24:55,620 --> 00:25:01,610
archivo users.js donde llama al mismo passport.authenticate ('local').

319
00:25:01,720 --> 00:25:04,320
Entonces, si esto es exitoso,

320
00:25:04,320 --> 00:25:05,885
entonces avanza.

321
00:25:05,885 --> 00:25:10,930
Si falla, la función de autenticación devolverá el mensaje de error

322
00:25:10,930 --> 00:25:16,050
al cliente diciendo que el usuario no está autorizado.

323
00:25:16,050 --> 00:25:18,345
Por lo tanto, eso ya está atendido.

324
00:25:18,345 --> 00:25:23,020
Así que ahora, que hemos incluido esto en mi archivo authenticate.js, en

325
00:25:23,020 --> 00:25:26,050
cualquier lugar donde quiero verificar al usuario,

326
00:25:26,050 --> 00:25:27,480
simplemente puedo llamar a

327
00:25:27,480 --> 00:25:31,210
esta función verifyUser que

328
00:25:31,210 --> 00:25:34,320
he especificado aquí o a la exportación que he especificado aquí, a la

329
00:25:34,320 --> 00:25:37,220
que llamaremos al passport.authenticate usando

330
00:25:37,220 --> 00:25:40,540
la estrategia JWT para autenticar al usuario.

331
00:25:40,540 --> 00:25:42,440
Ahora, ¿cómo hacemos uso de esto?

332
00:25:42,440 --> 00:25:47,785
Ahora, lo que vamos a hacer es entrar en todos y cada uno de nuestros routers,

333
00:25:47,785 --> 00:25:56,945
y controlar las opciones en todas las rutas que queremos controlar.

334
00:25:56,945 --> 00:26:00,300
Entonces, volviendo al archivo app.js, ahora,

335
00:26:00,300 --> 00:26:07,925
que no estamos usando sesiones, voy a eliminar esta sesión de aquí,

336
00:26:07,925 --> 00:26:10,150
porque ya no estamos usando sesiones.

337
00:26:10,150 --> 00:26:14,990
Del mismo modo, voy a eliminar este passport.session de aquí también.

338
00:26:14,990 --> 00:26:17,580
Eso tampoco es necesario.

339
00:26:17,580 --> 00:26:20,430
Además, esta autenticación, vea anteriormente,

340
00:26:20,430 --> 00:26:21,940
cuando configuré esta autenticación,

341
00:26:21,940 --> 00:26:25,490
esta autenticación se aplicó a cada solicitud entrante individual.

342
00:26:25,490 --> 00:26:28,705
Ahora, voy a cambiar mi aplicación,

343
00:26:28,705 --> 00:26:35,055
por lo que requeriré autenticación solo en ciertas rutas y no en todas las rutas.

344
00:26:35,055 --> 00:26:39,665
Por lo tanto, permítanme eliminar esta autenticación por completo de app.js.

345
00:26:39,665 --> 00:26:41,995
Entonces, ahora, cuando llegue la solicitud,

346
00:26:41,995 --> 00:26:45,850
si está en/endpoint,

347
00:26:45,850 --> 00:26:47,080
se servirá el índice.

348
00:26:47,080 --> 00:26:52,040
Si está en el endpoint /users, le permitirá navegar a

349
00:26:52,040 --> 00:26:57,815
las distintas rutas que están montadas en el /users en users.js

350
00:26:57,815 --> 00:27:00,900
y, posteriormente, el resto de las.

351
00:27:00,900 --> 00:27:03,420
Lo que voy a hacer ahora es dejar

352
00:27:03,420 --> 00:27:07,250
la carpeta pública abierta para que cualquiera pueda acceder.

353
00:27:07,250 --> 00:27:09,145
Ahora, en muchas aplicaciones,

354
00:27:09,145 --> 00:27:10,665
esto puede estar bien.

355
00:27:10,665 --> 00:27:13,045
Así que, voy a dejar eso abierto.

356
00:27:13,045 --> 00:27:14,825
Ahora, en los platos,

357
00:27:14,825 --> 00:27:17,920
promociones, y el punto final de los líderes,

358
00:27:17,920 --> 00:27:20,875
todas las solicitudes de conseguir.

359
00:27:20,875 --> 00:27:28,205
Dejaré que se respondan sin necesidad de autenticación.

360
00:27:28,205 --> 00:27:30,200
Ahora, ¿por qué querría hacer eso?

361
00:27:30,200 --> 00:27:33,190
Si un usuario está haciendo una solicitud get,

362
00:27:33,190 --> 00:27:35,455
el usuario solo quiere recuperar información.

363
00:27:35,455 --> 00:27:40,490
Entonces, por ejemplo, en el lado del cliente, si estoy implementando una aplicación web usando Angular

364
00:27:40,490 --> 00:27:49,920
o una aplicación cliente usando

365
00:27:49,920 --> 00:27:54,310
un script iónico o nativo, entonces tal vez quiera implementar mi aplicación de tal manera que la página principal ya muestre información,

366
00:27:54,310 --> 00:27:57,715
la información genética que desea poner a disposición de cualquier persona que

367
00:27:57,715 --> 00:28:01,590
visite su sitio web o que abra su aplicación.

368
00:28:01,590 --> 00:28:04,360
Por lo tanto, la información básica se puede mostrar allí.

369
00:28:04,360 --> 00:28:08,060
Pero si desea cambiar algo,

370
00:28:08,060 --> 00:28:12,110
entonces espera que el usuario sea autenticado.

371
00:28:12,110 --> 00:28:16,255
Por lo tanto, permitirá que las operaciones POST, las operaciones de poner

372
00:28:16,255 --> 00:28:21,110
y las operaciones de eliminación sean realizadas solo por usuarios autenticados.

373
00:28:21,110 --> 00:28:23,605
Del mismo modo, para comentarios, por ejemplo,

374
00:28:23,605 --> 00:28:30,280
puede decir que los comentarios solo pueden ser publicados o modificados por usuarios autenticados.

375
00:28:30,280 --> 00:28:34,570
Por lo tanto, puede restringir solo algunas rutas para usuarios autenticados,

376
00:28:34,570 --> 00:28:37,940
la otra ruta puede dejarlos abiertos. ¿Cómo hacemos eso?

377
00:28:37,940 --> 00:28:41,180
Ahora es aquí donde el usuario de verificación que

378
00:28:41,180 --> 00:28:45,055
hemos exportado desde el archivo authenticate.js es útil.

379
00:28:45,055 --> 00:28:49,460
Ahora en lugar de controlar todos los puntos finales,

380
00:28:49,460 --> 00:28:53,190
todas las diversas operaciones en los platos, promociones

381
00:28:53,190 --> 00:28:54,740
y líderes en puntos,

382
00:28:54,740 --> 00:28:58,240
abriremos solo las operaciones get para cualquiera,

383
00:28:58,240 --> 00:29:00,830
pero las

384
00:29:00,830 --> 00:29:04,995
operaciones de publicación, puesta y eliminación estarán restringidas solo a usuarios autenticados.

385
00:29:04,995 --> 00:29:10,350
En la asignación, agregará una categoría más de usuarios llamada usuarios admin.

386
00:29:10,350 --> 00:29:15,320
Ahora restringiría ciertas operaciones para que solo los usuarios administradores realicen.

387
00:29:15,320 --> 00:29:18,460
Entonces, por ejemplo, modificar los platos

388
00:29:18,460 --> 00:29:22,530
o eliminar la información de los platos de la base de datos,

389
00:29:22,530 --> 00:29:24,600
se restringirá solo a los usuarios administradores.

390
00:29:24,600 --> 00:29:30,000
Pero los usuarios básicos pueden publicar comentarios,

391
00:29:30,000 --> 00:29:32,470
modificar los comentarios que han publicado

392
00:29:32,470 --> 00:29:35,450
y tal vez incluso guardar algunos platos favoritos.

393
00:29:35,450 --> 00:29:38,520
Haremos esa parte en el cuarto módulo.

394
00:29:38,520 --> 00:29:42,735
Ahora, ¿cómo controlamos rutas específicas?

395
00:29:42,735 --> 00:29:46,210
Así que aquí es donde tenemos que entrar en cada uno de los routers

396
00:29:46,210 --> 00:29:50,365
y luego importar controles en rutas específicas.

397
00:29:50,365 --> 00:29:53,945
Entonces, comencemos con la ruta de los platos.

398
00:29:53,945 --> 00:29:55,770
Entonces, para la ruta de platos,

399
00:29:55,770 --> 00:29:59,950
recordará que esto está controlado en el archivo dishRouter.js.

400
00:29:59,950 --> 00:30:02,515
Entonces, yendo a dishRouter.js,

401
00:30:02,515 --> 00:30:07,450
primero importemos la autenticación aquí.

402
00:30:07,450 --> 00:30:13,400
Así que diremos, const authenticate

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

404
00:30:24,700 --> 00:30:29,110
archivo authenticator.js está en la carpeta de nivel superior.

405
00:30:29,110 --> 00:30:32,105
Por lo tanto, recuerda../autenticar aquí.

406
00:30:32,105 --> 00:30:34,505
Por lo tanto, una vez que importe la autenticación,

407
00:30:34,505 --> 00:30:37,965
para la ruta del enrutador de plato para esta ruta

408
00:30:37,965 --> 00:30:42,560
, la operación get, voy a permitir sin ningún problema.

409
00:30:42,560 --> 00:30:44,820
Así que, eso está abierto.

410
00:30:44,820 --> 00:30:47,025
Así que no voy a imponer ninguna restricción.

411
00:30:47,025 --> 00:30:51,750
Desde la publicación, si queremos aplicar varios middleware,

412
00:30:51,750 --> 00:30:56,035
simplemente podemos agregar el principal dentro de este uno detrás del otro.

413
00:30:56,035 --> 00:30:58,050
Ahora, cuando se llama a la publicación, en este

414
00:30:58,050 --> 00:31:02,295
momento simplemente está ejecutando esta función aquí.

415
00:31:02,295 --> 00:31:04,150
Ahora, justo antes de eso,

416
00:31:04,150 --> 00:31:12,400
puedo entrar y decir, autenticate.verifyUser, allí.

417
00:31:12,400 --> 00:31:13,805
Entonces, ¿qué hace esto?

418
00:31:13,805 --> 00:31:17,210
Esto dice que si entra una solicitud de publicación,

419
00:31:17,210 --> 00:31:20,940
primero ejecutaría este middleware,

420
00:31:20,940 --> 00:31:24,805
que he exportado desde el archivo authentic.js,

421
00:31:24,805 --> 00:31:26,100
primero lo aplico,

422
00:31:26,100 --> 00:31:32,075
lo que es equivalente a decir que el pasaporte autentica JWT y está verificando el usuario.

423
00:31:32,075 --> 00:31:34,655
Entonces, si esto es exitoso,

424
00:31:34,655 --> 00:31:38,890
entonces pasaré a hacer el resto.

425
00:31:38,890 --> 00:31:42,955
Si la autenticación falla en este punto,

426
00:31:42,955 --> 00:31:46,290
entonces la autenticación de pasaporte

427
00:31:46,290 --> 00:31:49,395
responderá al cliente con el mensaje de error correspondiente.

428
00:31:49,395 --> 00:31:51,640
Así que eso ya está manejado por autenticación de pasaporte,

429
00:31:51,640 --> 00:31:54,350
así que no tengo que preocuparme nada más allá de ese punto.

430
00:31:54,350 --> 00:31:58,300
Si he cruzado este middleware y luego puedo

431
00:31:58,300 --> 00:32:02,990
ejecutar la siguiente función que significa que mi autenticación fue exitosa,

432
00:32:02,990 --> 00:32:05,560
así que puedo continuar desde este punto.

433
00:32:05,560 --> 00:32:11,760
Por lo tanto, esto está actuando como la barrera para este método post.

434
00:32:11,760 --> 00:32:14,860
Ahora usando el mismo argumento,

435
00:32:14,860 --> 00:32:21,435
simplemente puedo aplicar este middleware particular a todos los otros métodos.

436
00:32:21,435 --> 00:32:23,845
Puedo hacerle eso al puesto.

437
00:32:23,845 --> 00:32:26,030
Aunque en este caso,

438
00:32:26,030 --> 00:32:28,640
poner no va a hacer nada.

439
00:32:28,640 --> 00:32:30,110
Pero en cualquier caso,

440
00:32:30,110 --> 00:32:33,980
lo haré simplemente por el bien de la uniformidad,

441
00:32:33,980 --> 00:32:38,490
aplicaré el usuario de verificación para poner también y, por supuesto,

442
00:32:38,490 --> 00:32:41,315
para eliminar también, voy a aplicar put.

443
00:32:41,315 --> 00:32:44,805
Del mismo modo, bajando al /DISHID,

444
00:32:44,805 --> 00:32:48,915
obtengo permitiré que funcione sin ningún problema.

445
00:32:48,915 --> 00:32:52,470
Publicar, aplicaré el usuario de verificación.

446
00:32:52,470 --> 00:32:59,600
Ponga también aplicaré el usuario de verificación y para eliminar también lo mismo.

447
00:32:59,600 --> 00:33:09,105
Para el /dishid/comments, voy a dejar el get open,

448
00:33:09,105 --> 00:33:14,030
está bien que alguien recupere comentarios sobre un plato específico.

449
00:33:14,030 --> 00:33:17,140
Publicar, voy a cerrar esto,

450
00:33:17,140 --> 00:33:21,995
por lo que solo los usuarios verificados pueden publicar comentarios.

451
00:33:21,995 --> 00:33:27,710
Ponga también cerraré esto y eliminaré también.

452
00:33:29,280 --> 00:33:33,035
Tienes que ir un paso más allá y decir:

453
00:33:33,035 --> 00:33:38,230
«Solo los usuarios que han publicado el comentario pueden eliminar sus propias publicaciones».

454
00:33:38,230 --> 00:33:40,310
Pero lo haremos en el siguiente módulo.

455
00:33:40,310 --> 00:33:41,840
Por el momento, voy a decir,

456
00:33:41,840 --> 00:33:44,415
«Vale, un usuario verificado puede eliminar cualquier comentario».

457
00:33:44,415 --> 00:33:46,715
Esto, por supuesto, no es cierto,

458
00:33:46,715 --> 00:33:48,850
podemos poner un control adicional,

459
00:33:48,850 --> 00:33:52,145
pero vamos a hacer eso en el siguiente módulo de este curso.

460
00:33:52,145 --> 00:33:54,405
Entonces, para eliminar también aplico lo mismo.

461
00:33:54,405 --> 00:33:58,060
Una vez más, para los comentarios/comentarios del enrutador de platos Id,

462
00:33:58,060 --> 00:34:00,300
obtenga lo dejaré abierto.

463
00:34:00,300 --> 00:34:04,485
Post, lo dejaré cerrado.

464
00:34:04,485 --> 00:34:12,640
Ponga también ciérrelo y luego para eliminar también cerraré esto.

465
00:34:12,640 --> 00:34:14,970
Eliminar, por supuesto, como dije,

466
00:34:14,970 --> 00:34:19,180
la operación de eliminación debe permitirse solo

467
00:34:19,180 --> 00:34:24,150
a un usuario que haya creado el comentario se

468
00:34:24,150 --> 00:34:27,960
le debe pedir que elimine eso, pero necesita configurar algunas cosas adicionales para que funcione correctamente, lo

469
00:34:27,960 --> 00:34:30,825
cual haremos en el siguiente módulo.

470
00:34:30,825 --> 00:34:36,455
Por el momento, estamos diciendo que un usuario verificado puede eliminar un comentario específico, eso es todo.

471
00:34:36,455 --> 00:34:42,820
Ahora aplicaremos el mismo principio al enrutador promocional y también al enrutador líder.

472
00:34:42,820 --> 00:34:44,950
Entonces, al entrar en el enrutador promocional,

473
00:34:44,950 --> 00:34:53,100
déjame importar autenticar

474
00:34:57,320 --> 00:35:00,870
y luego obtener está abierto,

475
00:35:00,870 --> 00:35:03,540
así que este es el enrutador líder.

476
00:35:03,540 --> 00:35:05,380
Por lo tanto, conseguir está abierto.

477
00:35:05,380 --> 00:35:08,365
Publicar, voy a controlar eso,

478
00:35:08,365 --> 00:35:12,865
poner, controlar, eliminar, controlar,

479
00:35:12,865 --> 00:35:14,790
enrutador líder, ID de líder,

480
00:35:14,790 --> 00:35:17,255
obtener está bien, publicar,

481
00:35:17,255 --> 00:35:22,330
controlar, poner es controlado y eliminar está controlado.

482
00:35:22,330 --> 00:35:24,795
Lo mismo con el router promocional.

483
00:35:24,795 --> 00:35:38,652
Permítanme, requiera la autenticación

484
00:35:38,652 --> 00:35:43,570
y luego para la ruta get está abierta,

485
00:35:43,570 --> 00:35:47,109
POST está controlado, put está controlado,

486
00:35:47,109 --> 00:35:50,790
delete está controlado, lo mismo para el Promorouter/promoid.

487
00:35:50,790 --> 00:35:54,460
Get está abierto, POST está controlado,

488
00:35:54,460 --> 00:35:58,395
poner y eliminar también están controlados, eso es todo.

489
00:35:58,395 --> 00:36:00,225
Vamos a guardar todos los cambios.

490
00:36:00,225 --> 00:36:02,660
Por lo tanto, una vez que

491
00:36:02,660 --> 00:36:04,185
completemos todos los cambios, guardemos los cambios.

492
00:36:04,185 --> 00:36:08,270
Ahora, nuestra aplicación está lista para ser probada.

493
00:36:08,270 --> 00:36:11,485
Por lo tanto, vamos a reiniciar nuestro servidor,

494
00:36:11,485 --> 00:36:14,885
o si el servidor no se está ejecutando,

495
00:36:14,885 --> 00:36:16,590
simplemente iniciaremos el servidor.

496
00:36:16,590 --> 00:36:18,770
Al ir al terminal,

497
00:36:18,770 --> 00:36:20,040
mi servidor no se está ejecutando.

498
00:36:20,040 --> 00:36:23,930
Por lo tanto, permítanme iniciar el servidor escribiendo npm start.

499
00:36:24,620 --> 00:36:28,935
Curiosamente, solo arrojó un error aquí,

500
00:36:28,935 --> 00:36:32,330
solo quería ilustrarte que incluso yo puedo cometer errores,

501
00:36:32,330 --> 00:36:34,840
por lo que verá que hay un error aquí que dice:

502
00:36:34,840 --> 00:36:40,275
«No se puede encontrar module.authenticate», y luego si miro a través del código,

503
00:36:40,275 --> 00:36:45,255
descubro que este problema ocurrió en el,

504
00:36:45,255 --> 00:36:46,850
¿Dónde ocurrió?

505
00:36:46,850 --> 00:36:48,350
Entonces, solo busco aquí,

506
00:36:48,350 --> 00:36:50,020
y luego en algún lugar aquí abajo,

507
00:36:50,020 --> 00:36:56,130
noté que este problema ocurrió dentro de mi archivo users.js.

508
00:36:56,130 --> 00:36:57,870
Entonces, justo ahí, dice,

509
00:36:57,870 --> 00:37:00,355
esto está en el archivo users.js.

510
00:37:00,355 --> 00:37:05,655
Entonces, yendo al archivo users.js, arreglemos eso.

511
00:37:05,655 --> 00:37:09,015
Ir al archivo users.js,

512
00:37:09,015 --> 00:37:14,285
justo en la parte superior cuando requería autenticarse, dije,

513
00:37:14,285 --> 00:37:17,555
«.authenticate», y como te estaba diciendo,

514
00:37:17,555 --> 00:37:21,200
eso debería ser un punto punto porque está en la carpeta superior.

515
00:37:21,200 --> 00:37:25,905
Este archivo users.js en la carpeta Rutas,

516
00:37:25,905 --> 00:37:31,985
y autenticar está en la carpeta Ruta de proyectos, por lo que debe ser punto de autenticación.

517
00:37:31,985 --> 00:37:34,660
Por lo tanto, si cometes errores,

518
00:37:34,660 --> 00:37:40,450
ahí tienes, así es como te recordarán el error que has introducido.

519
00:37:40,450 --> 00:37:44,540
Por lo tanto, guardemos los cambios y luego reiniciemos nuestro servidor.

520
00:37:44,540 --> 00:37:47,795
Una vez más, volviendo a ese terminal,

521
00:37:47,795 --> 00:37:54,735
permítanme iniciar mi servidor y mi servidor ahora está en funcionamiento,

522
00:37:54,735 --> 00:38:00,235
vayamos a Postman y luego probemos nuestra aplicación.

523
00:38:00,235 --> 00:38:04,695
Ahora, en Postman, primero intentaré hacer

524
00:38:04,695 --> 00:38:11,170
un GET en localhost: 3000/platos y luego cuando hago un GET,

525
00:38:11,170 --> 00:38:15,620
es exitoso porque el punto final GET no está controlado.

526
00:38:15,620 --> 00:38:18,595
Así que puedo hacer un GET en los platos,

527
00:38:18,595 --> 00:38:23,545
puedo hacer un GET en las promociones,

528
00:38:23,545 --> 00:38:25,420
y todo funciona muy bien.

529
00:38:25,420 --> 00:38:28,300
Pero si trato de hacer un POST en los platos,

530
00:38:28,300 --> 00:38:32,435
así que déjame encontrar donde he hecho un POST en los platos.

531
00:38:32,435 --> 00:38:35,245
Aquí he hecho una POST en los platos.

532
00:38:35,245 --> 00:38:38,030
Entonces, cuando traté de hacer una POST en los platos,

533
00:38:38,030 --> 00:38:40,540
inmediatamente dice no autorizado.

534
00:38:40,540 --> 00:38:47,410
Así que mi módulo de Passport se ha dado cuenta de que no estoy autorizado, así que no se me permite hacer esto,

535
00:38:47,410 --> 00:38:49,825
así que eso es lo que me está recordando.

536
00:38:49,825 --> 00:38:52,750
Permítanme limpiar las cookies de,

537
00:38:52,750 --> 00:38:57,980
en caso de que encuentre una cookie en su Cartero simplemente elimine la cookie

538
00:38:57,980 --> 00:39:00,410
correspondiente al localhost porque

539
00:39:00,410 --> 00:39:03,815
esa cookie ya no es necesaria y no será necesaria.

540
00:39:03,815 --> 00:39:06,100
Por lo tanto, incluso si elimino la cookie y luego POST,

541
00:39:06,100 --> 00:39:07,990
seguirá diciendo no autorizado.

542
00:39:07,990 --> 00:39:11,715
Por lo tanto, no estoy autorizado para hacer estas operaciones.

543
00:39:11,715 --> 00:39:13,305
Por lo tanto, tengo que iniciar sesión.

544
00:39:13,305 --> 00:39:15,430
Ahora, si ha realizado el ejercicio anterior,

545
00:39:15,430 --> 00:39:19,390
habría dejado el usuario al que se registró anteriormente.

546
00:39:19,390 --> 00:39:25,865
Entonces, por ejemplo, habrías registrado a este usuario en particular en el ejercicio anterior,

547
00:39:25,865 --> 00:39:29,530
permítanme intentar registrar el mismo usuario nuevamente y

548
00:39:29,530 --> 00:39:36,090
mi servidor debería quejarse diciendo UserExistsError para que eso significa que el usuario existe,

549
00:39:36,090 --> 00:39:38,455
por lo que no necesito registrarme de nuevo.

550
00:39:38,455 --> 00:39:42,290
Si ha eliminado al usuario de su MongoDB,

551
00:39:42,290 --> 00:39:47,275
simplemente regístrese a ese usuario una vez más y luego vamos a iniciar sesión.

552
00:39:47,275 --> 00:39:55,830
Por lo tanto, enviaremos una solicitud de inicio de sesión a ese punto final.

553
00:39:55,830 --> 00:40:00,640
Por lo tanto, cuando envío la solicitud de inicio de sesión haciendo una POST al usuario final,

554
00:40:00,640 --> 00:40:03,365
observe lo que devuelve mi servidor.

555
00:40:03,365 --> 00:40:06,965
Inmediatamente nota que en el mensaje de respuesta

556
00:40:06,965 --> 00:40:10,830
junto con el indicador de éxito y el mensaje de estado,

557
00:40:10,830 --> 00:40:13,740
también obtiene un token aquí.

558
00:40:13,740 --> 00:40:16,365
Ahora, este token en particular,

559
00:40:16,365 --> 00:40:17,960
necesito copiar este token,

560
00:40:17,960 --> 00:40:21,045
porque en mis solicitudes posteriores,

561
00:40:21,045 --> 00:40:23,535
necesitaré incluir este token.

562
00:40:23,535 --> 00:40:31,610
Entonces, déjame ir a la versión cruda de esto y que voy a copiar este token.

563
00:40:31,610 --> 00:40:33,875
Este token no es más que una cadena larga allí,

564
00:40:33,875 --> 00:40:36,260
así que permítanme copiar este token.

565
00:40:36,260 --> 00:40:41,765
Entonces ahora, si tiene curiosidad sobre lo que está contenido en este token,

566
00:40:41,765 --> 00:40:44,800
se puede examinar el token web JSON.

567
00:40:44,800 --> 00:40:48,140
Hay un sitio en particular donde puede entrar y escribir

568
00:40:48,140 --> 00:40:52,235
su JSON Web Token y luego realmente verificar lo que está dentro del JSON Web Token.

569
00:40:52,235 --> 00:40:54,980
Hagámoslo como el siguiente paso.

570
00:40:54,980 --> 00:40:56,685
En una ventana del navegador,

571
00:40:56,685 --> 00:41:05,565
simplemente escriba jwt.io y esto lo llevará a este sitio llamado JSON Web Token jwt.io.

572
00:41:05,565 --> 00:41:07,590
Si recuerdas, en la conferencia,

573
00:41:07,590 --> 00:41:10,685
te había mostrado la estructura del token web JSON

574
00:41:10,685 --> 00:41:14,290
y te había mostrado que el token web JSON contiene tres partes: el encabezado,

575
00:41:14,290 --> 00:41:18,040
la carga útil y la información allí.

576
00:41:18,040 --> 00:41:19,730
Ahora, en este caso,

577
00:41:19,730 --> 00:41:25,880
la información está aquí, así que voy

578
00:41:25,880 --> 00:41:33,285
a pegar mi JSON Web Token en este lado izquierdo,

579
00:41:33,285 --> 00:41:37,270
así que déjame seleccionar eso y luego pegar mi JSON Web Token en

580
00:41:37,270 --> 00:41:41,920
el lado izquierdo en la parte codificada y luego en el lado derecho,

581
00:41:41,920 --> 00:41:46,030
te muestra exactamente lo que es dentro del token web JSON que acabo de crear.

582
00:41:46,030 --> 00:41:49,580
Por lo tanto, dice que el encabezado contiene estas dos piezas de información.

583
00:41:49,580 --> 00:41:54,090
El aviso de carga útil que contiene el ID

584
00:41:54,090 --> 00:41:59,245
del usuario y luego la firma en la parte inferior aquí.

585
00:41:59,245 --> 00:42:03,995
Entonces, esto es lo que está contenido dentro de mi JSON Web Token.

586
00:42:03,995 --> 00:42:07,005
Volviendo a Cartero,

587
00:42:07,005 --> 00:42:12,110
déjame ahora tratar de conseguir los platos.

588
00:42:12,110 --> 00:42:15,940
Entonces, cuando digo GET localhost: 3000/platos,

589
00:42:15,940 --> 00:42:18,650
todavía devolverá una cadena vacía,

590
00:42:18,650 --> 00:42:23,385
matriz vacía aquí porque mi base de datos no la contiene.

591
00:42:23,385 --> 00:42:29,635
Entonces, déjame POST un plato en mi base de datos.

592
00:42:29,635 --> 00:42:33,290
Entonces, voy a elegir la operación POST y en el cuerpo,

593
00:42:33,290 --> 00:42:36,095
ves que tengo mi plato aquí.

594
00:42:36,095 --> 00:42:41,215
En el encabezado, voy a agregar el nuevo encabezado llamado

595
00:42:41,215 --> 00:42:47,240
autorización y recuerdas que antes para la autorización básica,

596
00:42:47,240 --> 00:42:53,425
dijiste básico y luego tenías la cadena codificada Base 64 allí.

597
00:42:53,425 --> 00:42:58,970
Si desea incluir su JSON Web Token en el encabezado de autorización,

598
00:42:58,970 --> 00:43:01,150
porque en nuestro código,

599
00:43:01,150 --> 00:43:04,550
dijimos autorización como token portador.

600
00:43:04,550 --> 00:43:08,040
Por lo tanto, si desea incluir el token en el encabezado de autorización,

601
00:43:08,040 --> 00:43:13,275
en la autorización diremos portador y luego pegaremos

602
00:43:13,275 --> 00:43:19,080
esa cadena de token que acabamos de copiar de nuestra solicitud entrante.

603
00:43:19,080 --> 00:43:21,935
Por lo tanto, pegaremos la cadena de token allí.

604
00:43:21,935 --> 00:43:24,360
Entonces, esto es lo que estará contenido en

605
00:43:24,360 --> 00:43:29,795
el encabezado de autorización de mi solicitud saliente aquí,

606
00:43:29,795 --> 00:43:33,845
solicitud POST saliente aquí.

607
00:43:33,845 --> 00:43:39,970
Así que note, el lado izquierdo dice portador y el lado derecho es la cadena,

608
00:43:39,970 --> 00:43:43,230
el token que acabo de copiar desde

609
00:43:43,230 --> 00:43:48,460
el punto en el que inicié sesión y luego déjame enviar el mensaje POST

610
00:43:48,460 --> 00:43:57,590
ahora y mi POST ahora es exitoso y esto se publica en mi base de datos.

611
00:43:57,590 --> 00:44:01,115
Ahora, si quieres estar seguro de que se ha publicado,

612
00:44:01,115 --> 00:44:04,555
vamos a hacer un GET y cuando hagas un GET,

613
00:44:04,555 --> 00:44:12,935
puedes ver que de hecho ese plato se ha insertado en mi base de datos como se muestra aquí.

614
00:44:12,935 --> 00:44:19,260
Entonces, así es como va a hacer uso de JSON Web Tokens en su aplicación.

615
00:44:19,260 --> 00:44:22,230
Por lo tanto, siempre que necesite hacer una

616
00:44:22,230 --> 00:44:25,505
operación POST, PUT o DELETE en cualquiera de los puntos finales,

617
00:44:25,505 --> 00:44:27,010
estaría adjuntando.

618
00:44:27,010 --> 00:44:33,895
Por lo tanto, permítanme volver a esta solicitud POST aquí.

619
00:44:33,895 --> 00:44:35,890
En el encabezado, colocará

620
00:44:35,890 --> 00:44:41,540
este campo de autorización y luego esto se incluiría en la autorización,

621
00:44:41,540 --> 00:44:47,540
lo iniciará con portador y luego la cadena token,

622
00:44:47,540 --> 00:44:50,200
después de ese espacio del portador,

623
00:44:50,200 --> 00:44:54,215
un solo espacio y luego la cadena token después de eso.

624
00:44:54,215 --> 00:44:58,310
Entonces, así es como sus mensajes de solicitud

625
00:44:58,310 --> 00:45:03,140
llevarían el token web JSON en el encabezado del mensaje de solicitud saliente.

626
00:45:03,140 --> 00:45:08,220
También puede incluir el token en el cuerpo del mensaje de solicitud saliente.

627
00:45:08,220 --> 00:45:10,310
Ahora, para eso, tendrá que configurar

628
00:45:10,310 --> 00:45:18,210
su servidor express especialmente el JWT extra en el

629
00:45:18,210 --> 00:45:21,120
archivo authenticate.js para aceptarlo

630
00:45:21,120 --> 00:45:24,455
del cuerpo para que recuerde que allí hemos visto que

631
00:45:24,455 --> 00:45:28,890
el JWT extra admite muchas formas diferentes de extraer

632
00:45:28,890 --> 00:45:33,695
el token web JSON de la entrada solicitud.

633
00:45:33,695 --> 00:45:35,090
Por lo tanto, allí debe especificar,

634
00:45:35,090 --> 00:45:36,670
si va a incluirlo en el cuerpo,

635
00:45:36,670 --> 00:45:39,115
debe especificar esa información allí.

636
00:45:39,115 --> 00:45:42,395
Ahora, los detalles de cómo hacerlo se puede consultar

637
00:45:42,395 --> 00:45:49,885
la documentación del módulo Passport JWT para entender cómo se hace esto.

638
00:45:49,885 --> 00:45:54,610
En este curso, simplemente lo usaré en el encabezado de autorización

639
00:45:54,610 --> 00:45:59,835
como he mostrado aquí y esto funciona bien para la mayoría de los casos.

640
00:45:59,835 --> 00:46:02,620
Ahora, si está desarrollando una aplicación web,

641
00:46:02,620 --> 00:46:06,635
una aplicación angular o una aplicación Ionic o NativeScript,

642
00:46:06,635 --> 00:46:09,800
debe poder configurar

643
00:46:09,800 --> 00:46:16,615
esa aplicación mediante la cual el token web JSON se incluirá en el encabezado de autorización.

644
00:46:16,615 --> 00:46:22,215
En la última lección de este curso,

645
00:46:22,215 --> 00:46:26,255
te mostraré cómo integrar el cliente y el servidor,

646
00:46:26,255 --> 00:46:29,310
el cliente que has desarrollado en los cursos anteriores con

647
00:46:29,310 --> 00:46:32,495
el servidor que desarrollamos en este curso.

648
00:46:32,495 --> 00:46:35,120
Con esto, completamos este ejercicio.

649
00:46:35,120 --> 00:46:37,940
En este ejercicio, hemos visto cómo

650
00:46:37,940 --> 00:46:42,200
podemos configurar nuestra aplicación para usar JSON Web Tokens,

651
00:46:42,200 --> 00:46:50,555
y hemos visto cómo manejamos la autenticación del usuario usando el token web JSON,

652
00:46:50,555 --> 00:46:55,555
usando el soporte del módulo Passport y el módulo Passport JWT,

653
00:46:55,555 --> 00:46:58,605
y los módulos JSON Web Token Node.

654
00:46:58,605 --> 00:47:01,090
Con esto, completamos este ejercicio.

655
00:47:01,090 --> 00:47:09,110
Este es un buen momento para que hagas un Git Commit con el mensaje Passport JWT.