﻿1
00:00:00,960 --> 00:00:03,130
‫-: Entonces, en los últimos videos,

2
00:00:03,130 --> 00:00:06,220
‫permitimos a un usuario restablecer su contraseña y

3
00:00:06,220 --> 00:00:08,070
‫luego crear una nueva, pero

4
00:00:08,070 --> 00:00:09,910
‫ahora también queremos

5
00:00:09,910 --> 00:00:13,383
‫permitir que un usuario que inició sesión simplemente actualice

6
00:00:13,383 --> 00:00:15,740
‫su contraseña sin tener que olvidarla,

7
00:00:15,740 --> 00:00:18,880
‫y así sin todo ese proceso de reinicio.

8
00:00:18,880 --> 00:00:20,833
‫Entonces, construyamos eso ahora.

9
00:00:22,620 --> 00:00:23,810
‫Y, como

10
00:00:23,810 --> 00:00:26,413
‫antes, hagámoslo en nuestro controlador de autenticación.

11
00:00:28,420 --> 00:00:30,523
‫Entonces, exportar. Actualiza contraseña.

12
00:00:35,142 --> 00:00:38,940
‫Está bien, y así, como siempre,

13
00:00:38,940 --> 00:00:43,940
‫aquí nuestros tres parámetros de Middleware, y está bien.

14
00:00:44,380 --> 00:00:48,250
‫Ahora recuerde que esta funcionalidad de actualización de contraseña

15
00:00:48,250 --> 00:00:50,260
‫es solo para usuarios registrados,

16
00:00:50,260 --> 00:00:54,290
‫pero aún necesitamos que el usuario ingrese su contraseña actual,

17
00:00:54,290 --> 00:00:55,920
‫para confirmar que

18
00:00:55,920 --> 00:00:58,990
‫el usuario realmente es quien dice ser.

19
00:00:58,990 --> 00:01:01,260
‫Por lo tanto, solo como medida

20
00:01:01,260 --> 00:01:04,950
‫de seguridad, imagine que alguien encontraría su computadora abierta y

21
00:01:04,950 --> 00:01:08,150
‫luego podría cambiar las contraseñas en los sitios que

22
00:01:08,150 --> 00:01:09,530
‫tiene abiertos actualmente

23
00:01:09,530 --> 00:01:12,610
‫sin que se le solicite una contraseña nuevamente.

24
00:01:12,610 --> 00:01:15,300
‫Y eso básicamente lo desconectaría

25
00:01:15,300 --> 00:01:18,260
‫de todas sus aplicaciones existentes, lo que,

26
00:01:18,260 --> 00:01:21,000
‫por supuesto, sería una experiencia terrible.

27
00:01:21,000 --> 00:01:23,800
‫Entonces, como medida de seguridad, siempre

28
00:01:23,800 --> 00:01:27,800
‫debemos pedir la contraseña actual antes de actualizarla, de acuerdo.

29
00:01:27,800 --> 00:01:30,530
‫Y, con eso en mente, expongamos

30
00:01:30,530 --> 00:01:32,760
‫todos los pasos que

31
00:01:32,760 --> 00:01:36,030
‫debemos seguir para implementar esta funcionalidad como antes.

32
00:01:36,030 --> 00:01:39,530
‫Entonces, primero, necesitamos obtener el usuario

33
00:01:39,530 --> 00:01:41,903
‫de la colección, básicamente.

34
00:01:44,840 --> 00:01:47,480
‫Luego, en segundo lugar, debemos

35
00:01:47,480 --> 00:01:50,263
‫verificar si la contraseña publicada es correcta.

36
00:01:56,430 --> 00:01:57,880
‫Derecha.

37
00:01:57,880 --> 00:02:01,800
‫Luego, tercero, si la contraseña es

38
00:02:01,800 --> 00:02:04,623
‫correcta, actualice la contraseña.

39
00:02:07,170 --> 00:02:11,013
‫Y finalmente, tenemos que volver a iniciar la sesión

40
00:02:12,180 --> 00:02:16,610
‫del usuario, así que básicamente para enviar el jsonwebtoken al usuario, que

41
00:02:16,610 --> 00:02:20,860
‫ahora inició sesión con la nueva contraseña que se acaba de actualizar.

42
00:02:20,860 --> 00:02:23,860
‫De acuerdo, y en realidad todo esto es muy

43
00:02:23,860 --> 00:02:25,510
‫similar a lo que

44
00:02:25,510 --> 00:02:27,370
‫hicimos antes, así que te dejo

45
00:02:27,370 --> 00:02:29,430
‫este como un desafío, ¿de acuerdo?

46
00:02:29,430 --> 00:02:32,660
‫Entonces, intente seguir adelante e implementar esto por su cuenta, y

47
00:02:32,660 --> 00:02:35,313
‫si lo necesita, por supuesto, puede echar un vistazo

48
00:02:35,313 --> 00:02:36,800
‫al código que escribimos

49
00:02:36,800 --> 00:02:39,440
‫antes, pero realmente intente escribir el código por su

50
00:02:39,440 --> 00:02:41,720
‫cuenta sin copiar demasiado, de acuerdo. ?

51
00:02:41,720 --> 00:02:44,140
‫Entonces, puede echar un vistazo al resto del

52
00:02:44,140 --> 00:02:47,680
‫código para ver cómo funciona, pero luego no lo copie, ¿de acuerdo?

53
00:02:47,680 --> 00:02:50,610
‫Porque entonces no vas a aprender realmente, de acuerdo.

54
00:02:50,610 --> 00:02:52,900
‫Entonces, pausa el video aquí, y te veré en un

55
00:02:52,900 --> 00:02:54,083
‫segundo con mi solución.

56
00:02:57,510 --> 00:03:00,450
‫Bien, entonces esperaba que lograras implementar esto

57
00:03:00,450 --> 00:03:03,533
‫y hacerlo funcionar, así es como lo hice.

58
00:03:04,960 --> 00:03:08,963
‫Entonces, como siempre, creamos una nueva variable de usuario, y allí

59
00:03:09,970 --> 00:03:14,353
‫esperamos el resultado de hacer User. findById, y ahora,

60
00:03:17,930 --> 00:03:20,940
‫¿de dónde proviene realmente esta identificación?

61
00:03:20,940 --> 00:03:24,590
‫Bueno, recuerde nuevamente que esta contraseña de actualización es solo para

62
00:03:24,590 --> 00:03:27,710
‫usuarios autenticados, por lo tanto, para usuarios registrados y, por

63
00:03:27,710 --> 00:03:30,830
‫lo tanto, en este punto, ya tendremos el usuario

64
00:03:30,830 --> 00:03:33,123
‫actual en nuestro objeto de solicitud.

65
00:03:34,380 --> 00:03:37,273
‫Bien, eso viene de la protección Middleware.

66
00:03:38,640 --> 00:03:42,670
‫Entonces, req. usuario. id, y

67
00:03:42,670 --> 00:03:46,933
‫luego recuerde que debemos pedir explícitamente la contraseña, ¿de acuerdo?

68
00:03:48,830 --> 00:03:53,260
‫Porque, de forma predeterminada, no se incluye en la salida.

69
00:03:53,260 --> 00:03:55,883
‫Entonces, lo definimos en el esquema, ¿recuerdas?

70
00:03:56,860 --> 00:03:58,730
‫Y, de hecho, necesitamos esa

71
00:03:58,730 --> 00:04:01,860
‫contraseña porque ahora queremos compararla con la que está

72
00:04:01,860 --> 00:04:03,690
‫almacenada en la base de

73
00:04:03,690 --> 00:04:05,300
‫datos, y para eso,

74
00:04:05,300 --> 00:04:08,850
‫al igual que antes, usaremos este objeto de instancia que

75
00:04:08,850 --> 00:04:10,720
‫tenemos en algún lugar aquí.

76
00:04:10,720 --> 00:04:13,360
‫Sí, tan correctPassword, que está disponible en todos

77
00:04:13,360 --> 00:04:15,250
‫los documentos del usuario,

78
00:04:15,250 --> 00:04:17,680
‫por lo que primero se incluye la

79
00:04:17,680 --> 00:04:21,850
‫contraseña del candidato y luego la contraseña del usuario real, de acuerdo.

80
00:04:21,850 --> 00:04:23,370
‫Ah, y ahora me

81
00:04:23,370 --> 00:04:26,120
‫está dando este error porque, por supuesto, todavía no

82
00:04:26,120 --> 00:04:28,203
‫lo he declarado como una función asíncrona.

83
00:04:29,610 --> 00:04:32,534
‫Entonces, async, y antes de que

84
00:04:32,534 --> 00:04:36,577
‫lo olvidemos, envuémoslo aquí también en la función catchAsync.

85
00:04:38,589 --> 00:04:40,513
‫De todos modos, al

86
00:04:40,513 --> 00:04:43,157
‫igual que antes, básicamente queremos crear un

87
00:04:43,157 --> 00:04:46,402
‫error aquí si la contraseña actual no es correcta,

88
00:04:46,402 --> 00:04:48,572
‫así que escribamos eso en código.

89
00:04:48,572 --> 00:04:51,239
‫Entonces, si no usuario. correctPassword, y

90
00:04:53,870 --> 00:04:56,283
‫luego la contraseña del candidato,

91
00:04:56,283 --> 00:04:58,808
‫recuerde, por lo que uno

92
00:04:58,808 --> 00:05:03,808
‫estará en un cuerpo, en una propiedad que llamaremos passwordConfirm.

93
00:05:03,980 --> 00:05:07,941
‫De acuerdo, y luego, como segundo argumento, la contraseña real, es

94
00:05:07,941 --> 00:05:10,108
‫un usuario. contraseña.

95
00:05:11,036 --> 00:05:13,820
‫Y luego, recuerde que esta es una función asincrónica,

96
00:05:13,820 --> 00:05:16,323
‫por lo que también debemos esperarla aquí.

97
00:05:18,400 --> 00:05:22,173
‫Bien, así que en caso de que la contraseña no

98
00:05:24,020 --> 00:05:27,500
‫sea correcta, como siempre, creamos un nuevo error aquí.

99
00:05:27,500 --> 00:05:32,000
‫Entonces, nuevo AppError, y esta vez decimos

100
00:05:32,930 --> 00:05:37,930
‫que su contraseña actual es incorrecta, y luego

101
00:05:38,720 --> 00:05:43,660
‫el código de estado 401 para no autorizado.

102
00:05:43,660 --> 00:05:45,650
‫Está bien, genial.

103
00:05:45,650 --> 00:05:48,240
‫Ahora, si llegamos a este punto

104
00:05:48,240 --> 00:05:51,750
‫en el código, entonces básicamente si la contraseña también

105
00:05:51,750 --> 00:05:54,460
‫es correcta, entonces podemos actualizar la contraseña,

106
00:05:54,460 --> 00:05:56,400
‫y ¿cómo lo hacemos?

107
00:05:56,400 --> 00:05:58,763
‫Bueno, muy simple, lo hicimos antes.

108
00:05:59,630 --> 00:06:04,630
‫Todo lo que decimos es usuario. contraseña es igual a req. cuerpo. contraseña, y

109
00:06:08,200 --> 00:06:11,793
‫luego lo mismo, por supuesto, para confirmar la contraseña.

110
00:06:14,010 --> 00:06:17,560
‫De acuerdo, y la validación la realizará automáticamente el

111
00:06:17,560 --> 00:06:21,300
‫validador que especificamos en el esquema, y eso se hará

112
00:06:21,300 --> 00:06:23,823
‫una vez que lo guardemos.

113
00:06:24,690 --> 00:06:29,280
‫Entonces, esperamos user. save, por lo

114
00:06:29,280 --> 00:06:32,400
‫que esta vez no desactivamos la

115
00:06:32,400 --> 00:06:35,920
‫validación porque, por supuesto, queremos que suceda, así

116
00:06:35,920 --> 00:06:39,120
‫que como dije antes, queremos verificar que

117
00:06:39,120 --> 00:06:42,010
‫la contraseña de confirmación sea la

118
00:06:42,010 --> 00:06:44,560
‫misma que la contraseña, ¿verdad?

119
00:06:44,560 --> 00:06:45,570
‫Bueno.

120
00:06:45,570 --> 00:06:49,460
‫Y, ahora solo para asegurarnos de que comprende por qué

121
00:06:49,460 --> 00:06:53,533
‫no hicimos algo como usuario. findByIdAndUpdate.

122
00:06:56,530 --> 00:06:59,260
‫Entonces, ¿por qué no lo hicimos así?

123
00:06:59,260 --> 00:07:02,450
‫Y sé que hablé de esto muchas veces antes,

124
00:07:02,450 --> 00:07:05,330
‫pero quiero que comprendan al cien por cien por

125
00:07:05,330 --> 00:07:07,990
‫qué no podemos usar esta actualización, y es

126
00:07:07,990 --> 00:07:09,540
‫por dos razones,

127
00:07:09,540 --> 00:07:12,143
‫así que permítanme volver a nuestro modelo.

128
00:07:13,090 --> 00:07:14,650
‫Entonces, el primero

129
00:07:14,650 --> 00:07:18,920
‫es que esta validación aquí no va a funcionar, ¿de acuerdo?

130
00:07:18,920 --> 00:07:22,670
‫Y eso es básicamente porque esto. La contraseña no está

131
00:07:22,670 --> 00:07:27,420
‫definida cuando actualizamos, por lo tanto, cuando usamos buscar por ID y actualizar,

132
00:07:27,420 --> 00:07:29,440
‫porque internamente, detrás de escena, Mongoose

133
00:07:29,440 --> 00:07:33,200
‫realmente no mantiene el objeto actual en la memoria y, por

134
00:07:33,200 --> 00:07:36,230
‫lo tanto, esto aquí no va a funcionar.

135
00:07:36,230 --> 00:07:39,130
‫Y, como dije, ya hablé de eso antes,

136
00:07:39,130 --> 00:07:42,650
‫así que en realidad también está escrito aquí, ¿de acuerdo?

137
00:07:42,650 --> 00:07:45,600
‫Pero, es muy importante tener en cuenta que

138
00:07:45,600 --> 00:07:49,340
‫no usar la actualización para nada relacionado con las contraseñas, ¿de acuerdo?

139
00:07:49,340 --> 00:07:51,160
‫Entonces, este no

140
00:07:51,160 --> 00:07:53,640
‫va a funcionar, y además, estos

141
00:07:53,640 --> 00:07:56,510
‫dos Middlewares pre-guardados tampoco van a funcionar.

142
00:07:56,510 --> 00:07:59,820
‫Entonces, si usamos simplemente actualizar para actualizar la

143
00:07:59,820 --> 00:08:03,000
‫contraseña, entonces esa contraseña no estaría encriptada, cuál

144
00:08:03,000 --> 00:08:04,750
‫es este primer

145
00:08:04,750 --> 00:08:07,530
‫Middleware, y luego también, la marca

146
00:08:07,530 --> 00:08:11,030
‫de tiempo passwordChangedAt tampoco se establecería, ¿de acuerdo?

147
00:08:11,030 --> 00:08:12,830
‫Entonces, nada de esto

148
00:08:12,830 --> 00:08:15,943
‫funcionaría, y nuevamente, realmente necesitamos hacerlo así.

149
00:08:17,470 --> 00:08:19,020
‫Pongamos eso aquí de nuevo.

150
00:08:21,330 --> 00:08:24,430
‫Y ahora, (murmura), iniciamos la sesión del

151
00:08:24,430 --> 00:08:27,840
‫usuario y le enviamos el token al cliente.

152
00:08:27,840 --> 00:08:30,210
‫Ahora, esa sería la cuarta vez que

153
00:08:30,210 --> 00:08:32,320
‫hicimos el mismo código, así que

154
00:08:32,320 --> 00:08:34,190
‫básicamente este fragmento de código,

155
00:08:34,190 --> 00:08:36,710
‫y eso es ahora muy rápidamente refactorizar esto

156
00:08:36,710 --> 00:08:38,410
‫en su propia función.

157
00:08:38,410 --> 00:08:42,410
‫Ahora bien, este código en realidad no es el mismo en todas partes.

158
00:08:42,410 --> 00:08:45,090
‫Entonces, aquí enviamos el código de estado

159
00:08:45,090 --> 00:08:47,250
‫400 y no enviamos

160
00:08:47,250 --> 00:08:51,280
‫al usuario, pero aquí en el controlador de registro, en realidad

161
00:08:51,280 --> 00:08:53,680
‫tenemos un código de estado diferente

162
00:08:53,680 --> 00:08:56,900
‫y también enviamos el usuario al cliente, ¿de acuerdo?

163
00:08:56,900 --> 00:08:59,873
‫Entonces, hagamos que nuestra función tenga eso en cuenta.

164
00:09:00,890 --> 00:09:05,890
‫Entonces, creemos una función aquí, creemos y enviemos un token,

165
00:09:06,140 --> 00:09:09,293
‫y luego los argumentos que necesitamos

166
00:09:11,100 --> 00:09:14,350
‫aquí son el usuario porque ahí es

167
00:09:14,350 --> 00:09:17,070
‫donde se almacena la ID.

168
00:09:17,070 --> 00:09:18,893
‫Entonces, también queremos el

169
00:09:20,220 --> 00:09:24,060
‫código de estado y, por supuesto, necesitamos tener acceso

170
00:09:24,060 --> 00:09:26,940
‫al objeto de respuesta para poder enviar

171
00:09:26,940 --> 00:09:29,510
‫una respuesta al cliente, ¿de acuerdo?

172
00:09:29,510 --> 00:09:32,473
‫Entonces, básicamente ahora lo que necesitamos es este código.

173
00:09:33,775 --> 00:09:35,930
‫Entonces, copiemos, pongámoslo aquí

174
00:09:35,930 --> 00:09:38,700
‫y luego reemplacemos las variables irrelevantes.

175
00:09:38,700 --> 00:09:42,480
‫Entonces, el usuario simplemente se llama usuario, así que

176
00:09:42,480 --> 00:09:44,963
‫así, y aquí, lo mismo.

177
00:09:46,470 --> 00:09:47,510
‫Entonces, no

178
00:09:47,510 --> 00:09:51,150
‫es un usuario nuevo, y luego lo reemplazamos con el código

179
00:09:51,150 --> 00:09:54,440
‫de estado, por lo que el que está entrando en

180
00:09:54,440 --> 00:09:57,053
‫nuestra función, y supongo que eso es todo.

181
00:09:58,330 --> 00:10:01,070
‫Entonces, sigamos adelante y reemplácelo, así que

182
00:10:01,070 --> 00:10:06,070
‫createSendToken, y aquí el usuario se llama newUser, el código de estado

183
00:10:09,040 --> 00:10:10,763
‫es 201, y

184
00:10:12,260 --> 00:10:15,093
‫luego, por supuesto, el objeto de respuesta.

185
00:10:16,730 --> 00:10:19,223
‫Bien, ahora podemos deshacernos de este código

186
00:10:20,680 --> 00:10:21,863
‫y simplemente copiemos.

187
00:10:23,200 --> 00:10:26,903
‫Muy bien, en el inicio de sesión, por supuesto, también enviamos un

188
00:10:28,860 --> 00:10:32,630
‫token, pero esta vez el usuario se llama realmente usuario y el código

189
00:10:32,630 --> 00:10:34,243
‫de estado es 200.

190
00:10:38,470 --> 00:10:39,920
‫Y ahora, copiemos este.

191
00:10:42,210 --> 00:10:45,853
‫Entonces, el siguiente debería estar aquí y restablecer la contraseña, y

192
00:10:46,930 --> 00:10:48,400
‫aquí es realmente el

193
00:10:48,400 --> 00:10:51,323
‫mismo, por lo que el nombre es usuario

194
00:10:53,740 --> 00:10:57,550
‫y código 200, y ahora, finalmente, aquí también es el mismo.

195
00:10:57,550 --> 00:11:02,360
‫Y así, termina nuestra función de actualización de contraseña.

196
00:11:02,360 --> 00:11:03,740
‫Ahora, para que esto funcione,

197
00:11:03,740 --> 00:11:06,830
‫por supuesto, necesitamos implementar la ruta aquí también en nuestro

198
00:11:06,830 --> 00:11:08,033
‫enrutador de usuario.

199
00:11:09,900 --> 00:11:14,400
‫Entonces, enrutador. parche, y haremos un parche

200
00:11:14,400 --> 00:11:17,610
‫porque en realidad estamos cambiando, por lo que estamos

201
00:11:17,610 --> 00:11:21,460
‫manipulando el documento del usuario, y para eso es el parche.

202
00:11:21,460 --> 00:11:24,590
‫Y la ruta se llama updateMyPassword.

203
00:11:29,060 --> 00:11:30,630
‫Entonces, mi contraseña

204
00:11:30,630 --> 00:11:34,420
‫es para el usuario que ha iniciado sesión actualmente, y luego

205
00:11:34,420 --> 00:11:36,810
‫recuerde, nuevamente, esto solo funciona para usuarios

206
00:11:36,810 --> 00:11:41,770
‫registrados, por lo que debemos usar authController. proteger, que luego también colocará

207
00:11:41,770 --> 00:11:44,240
‫el objeto de usuario

208
00:11:44,240 --> 00:11:47,270
‫en un objeto de solicitud, ¿de acuerdo?

209
00:11:47,270 --> 00:11:51,593
‫Entonces, proteja, y luego authController actualice la contraseña

210
00:11:51,593 --> 00:11:55,640
‫que acabamos de crear, de acuerdo.

211
00:11:55,640 --> 00:11:59,593
‫Y entonces, vayamos ahora y probemos esto, ¿de acuerdo?

212
00:12:02,720 --> 00:12:05,763
‫Entonces, copiemos esta ruta aquí, entonces UpdateMyPassword,

213
00:12:08,080 --> 00:12:09,790
‫y ahora lo que

214
00:12:14,300 --> 00:12:18,190
‫necesitamos enviar en el cuerpo son estas tres contraseñas en

215
00:12:18,190 --> 00:12:20,103
‫realidad, así que es

216
00:12:21,290 --> 00:12:24,817
‫básicamente la contraseña actual, y por ahora las dejo

217
00:12:30,350 --> 00:12:32,050
‫vacías, simplemente quiero

218
00:12:32,050 --> 00:12:35,000
‫poner el campo nombres aquí por ahora.

219
00:12:35,000 --> 00:12:38,750
‫Entonces, passwordCurrent luego solo password, que es básicamente

220
00:12:38,750 --> 00:12:40,503
‫la nueva,

221
00:12:41,690 --> 00:12:44,110
‫y luego, por supuesto, passwordConfirm.

222
00:12:46,930 --> 00:12:50,320
‫De acuerdo, y ahora necesitamos iniciar sesión como usuario

223
00:12:50,320 --> 00:12:53,140
‫porque recuerde, esto solo funciona si

224
00:12:53,140 --> 00:12:56,250
‫el usuario ya ha iniciado sesión, de acuerdo.

225
00:12:56,250 --> 00:12:59,333
‫Entonces, hagámoslo con el administrador aquí.

226
00:13:00,633 --> 00:13:04,620
‫Y esta debe ser la contraseña actual y,

227
00:13:04,620 --> 00:13:07,610
‫de hecho, ya estamos conectados.

228
00:13:07,610 --> 00:13:10,520
‫Y recuerde que este token ahora se

229
00:13:10,520 --> 00:13:13,313
‫almacena en la variable de

230
00:13:14,240 --> 00:13:17,080
‫entorno JWT, por lo que aquí,

231
00:13:17,080 --> 00:13:20,400
‫para autenticarnos, usemos eso como lo hicimos antes.

232
00:13:20,400 --> 00:13:24,710
‫Entonces, en esta pestaña de autorización, seleccionamos Bearer Token,

233
00:13:24,710 --> 00:13:27,480
‫y luego automáticamente completará automáticamente

234
00:13:27,480 --> 00:13:29,293
‫esta variable JWT.

235
00:13:30,140 --> 00:13:32,830
‫Muy bien, y de ahí es de

236
00:13:32,830 --> 00:13:35,873
‫donde vendrá realmente la ID de usuario, ¿recuerdas?

237
00:13:37,830 --> 00:13:42,830
‫De todos modos, ahora especifiquemos la contraseña actual, entonces pass1234, y luego

238
00:13:42,999 --> 00:13:45,613
‫digamos nueva contraseña, ¿de acuerdo?

239
00:13:49,040 --> 00:13:50,713
‫Cópielo y péguelo

240
00:13:51,560 --> 00:13:54,170
‫aquí, pero en realidad, nuevamente, quiero

241
00:13:54,170 --> 00:13:56,960
‫comenzar probándolo con una confirmación de contraseña

242
00:13:56,960 --> 00:13:59,810
‫incorrecta, solo para ver si nuestra validación

243
00:13:59,810 --> 00:14:02,720
‫sigue funcionando, y ahora la ruta no está

244
00:14:02,720 --> 00:14:07,300
‫definida, pero eso es simplemente porque estamos usando el verbo equivocado aquí.

245
00:14:07,300 --> 00:14:09,610
‫Por supuesto, debe ser parcheado.

246
00:14:09,610 --> 00:14:11,430
‫Intentémoslo de nuevo, pero ahora

247
00:14:11,430 --> 00:14:15,040
‫sabemos que su contraseña actual es incorrecta, pero en realidad no

248
00:14:15,040 --> 00:14:18,270
‫lo es, por lo que en realidad es correcta.

249
00:14:18,270 --> 00:14:21,163
‫Entonces, algo debe estar mal con nuestro código, así que

250
00:14:22,260 --> 00:14:24,143
‫intentemos echarle un vistazo aquí.

251
00:14:26,440 --> 00:14:28,440
‫Y sí, aquí está

252
00:14:28,440 --> 00:14:32,240
‫el problema porque no queremos comparar o confirmar la contraseña,

253
00:14:32,240 --> 00:14:34,763
‫por supuesto, sino con la contraseña actual.

254
00:14:35,750 --> 00:14:39,780
‫De acuerdo, eso es solo un error estúpido, de acuerdo, y

255
00:14:39,780 --> 00:14:41,620
‫ahora debería estar funcionando.

256
00:14:41,620 --> 00:14:45,000
‫Entonces, por supuesto, queremos comparar la contraseña actual con

257
00:14:45,000 --> 00:14:47,050
‫la que está almacenada

258
00:14:47,050 --> 00:14:50,220
‫actualmente en la base de datos, de acuerdo.

259
00:14:50,220 --> 00:14:51,503
‫Entonces, intentémoslo de

260
00:14:52,670 --> 00:14:55,460
‫nuevo, y ese es el error de validación que

261
00:14:55,460 --> 00:14:57,080
‫estábamos buscando, entonces las contraseñas no

262
00:14:57,080 --> 00:14:59,840
‫son las mismas porque, de hecho, no lo son.

263
00:14:59,840 --> 00:15:02,610
‫Y ahora, antes de actualizar la contraseña, echemos

264
00:15:02,610 --> 00:15:04,560
‫un vistazo a Compass aquí.

265
00:15:06,070 --> 00:15:08,550
‫Actualicémoslo aquí rápidamente, así que,

266
00:15:08,550 --> 00:15:11,160
‫ahora mismo, esta es la contraseña.

267
00:15:11,160 --> 00:15:15,080
‫Entonces, terminar aquí es pW1i, ¿de acuerdo?

268
00:15:15,080 --> 00:15:17,410
‫Entonces, actualice la contraseña

269
00:15:17,410 --> 00:15:21,333
‫ahora y veamos cómo se verá después, ¿de acuerdo?

270
00:15:23,400 --> 00:15:25,633
‫Entonces, ahora todo debería estar correcto.

271
00:15:26,720 --> 00:15:31,720
‫Y, de hecho, obtenemos nuestro éxito y nuestro token, de acuerdo.

272
00:15:33,500 --> 00:15:36,000
‫Entonces, confirmemos eso aquí rápidamente, y, de hecho,

273
00:15:36,000 --> 00:15:38,570
‫ves que la contraseña cambió y también la

274
00:15:38,570 --> 00:15:40,830
‫marca de tiempo actual, por lo

275
00:15:40,830 --> 00:15:44,403
‫que básicamente es el momento en el que estoy grabando este video.

276
00:15:45,370 --> 00:15:48,670
‫Muy bien, y ahora, como antes,

277
00:15:48,670 --> 00:15:51,960
‫hagamos esta prueba aquí.

278
00:15:51,960 --> 00:15:55,433
‫Entonces, básicamente, almacenar el token como una variable de entorno.

279
00:15:59,150 --> 00:16:03,910
‫Entonces, para que todo funcione realmente aquí en Postman.

280
00:16:03,910 --> 00:16:06,453
‫Bien, guardemos eso en realidad,

281
00:16:07,590 --> 00:16:12,590
‫actualice la contraseña del usuario actual para que sea realmente explícita,

282
00:16:14,560 --> 00:16:17,780
‫y sí, creo que eso es todo.

283
00:16:17,780 --> 00:16:21,090
‫Creo que esto es todo lo que necesitamos hacer

284
00:16:21,090 --> 00:16:24,090
‫para actualizar la contraseña de un usuario.

285
00:16:24,090 --> 00:16:27,890
‫A continuación, implementaremos la actualización de otros datos de usuario,

286
00:16:27,890 --> 00:16:30,713
‫por ejemplo, correo electrónico o contraseñas.

