﻿1
00:00:00,960 --> 00:00:03,130
‫-: Quindi, negli ultimi video, abbiamo

2
00:00:03,130 --> 00:00:06,220
‫permesso a un utente di reimpostare la sua

3
00:00:06,220 --> 00:00:08,070
‫password e quindi crearne una

4
00:00:08,070 --> 00:00:09,910
‫nuova, ma ora

5
00:00:09,910 --> 00:00:13,383
‫vogliamo anche consentire a un utente che ha effettuato l'accesso

6
00:00:13,383 --> 00:00:15,740
‫di aggiornare semplicemente la sua password senza

7
00:00:15,740 --> 00:00:18,880
‫doverla dimenticare, e così senza l'intero processo di ripristino.

8
00:00:18,880 --> 00:00:20,833
‫Quindi, costruiamolo ora.

9
00:00:22,620 --> 00:00:23,810
‫E, proprio come

10
00:00:23,810 --> 00:00:26,413
‫prima, facciamolo nel nostro controller di autenticazione.

11
00:00:28,420 --> 00:00:30,523
‫Quindi, esporta. aggiornaPassword.

12
00:00:35,142 --> 00:00:38,940
‫Va bene, e quindi, proprio come

13
00:00:38,940 --> 00:00:43,940
‫sempre, i nostri tre parametri Middleware qui, e va bene.

14
00:00:44,380 --> 00:00:48,250
‫Ora ricorda che questa funzionalità di aggiornamento della password è solo

15
00:00:48,250 --> 00:00:50,260
‫per gli utenti che hanno

16
00:00:50,260 --> 00:00:54,290
‫effettuato l'accesso, ma è comunque necessario che l'utente passi la sua password

17
00:00:54,290 --> 00:00:55,920
‫corrente, quindi per confermare

18
00:00:55,920 --> 00:00:58,990
‫che l'utente è effettivamente chi dice di essere.

19
00:00:58,990 --> 00:01:01,260
‫Quindi, solo come misura di sicurezza

20
00:01:01,260 --> 00:01:04,950
‫perché immagina che qualcuno possa trovare il tuo computer aperto e

21
00:01:04,950 --> 00:01:08,150
‫quindi essere in grado di modificare le password sui

22
00:01:08,150 --> 00:01:09,530
‫siti che hai

23
00:01:09,530 --> 00:01:12,610
‫attualmente aperti senza che venga richiesta nuovamente una password.

24
00:01:12,610 --> 00:01:15,300
‫E quindi in pratica ti

25
00:01:15,300 --> 00:01:18,260
‫disconnetterebbe da tutte le tue applicazioni esistenti,

26
00:01:18,260 --> 00:01:21,000
‫il che sarebbe, ovviamente, un'esperienza terribile.

27
00:01:21,000 --> 00:01:23,800
‫E quindi, come misura di sicurezza, dobbiamo

28
00:01:23,800 --> 00:01:27,800
‫sempre chiedere la password corrente prima di aggiornarla, va bene.

29
00:01:27,800 --> 00:01:30,530
‫E, con questo in mente, esponiamo tutti

30
00:01:30,530 --> 00:01:32,760
‫i passaggi che dobbiamo

31
00:01:32,760 --> 00:01:36,030
‫compiere per implementare questa funzionalità proprio come prima.

32
00:01:36,030 --> 00:01:39,530
‫Quindi, per prima cosa, dobbiamo prendere l'utente

33
00:01:39,530 --> 00:01:41,903
‫dalla raccolta, in pratica.

34
00:01:44,840 --> 00:01:47,480
‫Quindi, in secondo luogo, dobbiamo

35
00:01:47,480 --> 00:01:50,263
‫verificare se la password pubblicata è corretta.

36
00:01:56,430 --> 00:01:57,880
‫Destra.

37
00:01:57,880 --> 00:02:01,800
‫Quindi, terzo, quindi se la password è

38
00:02:01,800 --> 00:02:04,623
‫corretta, aggiorna la password.

39
00:02:07,170 --> 00:02:11,013
‫E infine, dobbiamo eseguire nuovamente l'accesso dell'utente,

40
00:02:12,180 --> 00:02:16,610
‫quindi in pratica per inviare nuovamente il jsonwebtoken all'utente,

41
00:02:16,610 --> 00:02:20,860
‫ora connesso con la nuova password appena aggiornata.

42
00:02:20,860 --> 00:02:23,860
‫Ok, e in realtà è tutto molto simile a

43
00:02:23,860 --> 00:02:25,510
‫quello che abbiamo già

44
00:02:25,510 --> 00:02:27,370
‫fatto prima, quindi lascio questo

45
00:02:27,370 --> 00:02:29,430
‫per te come una sfida, ok?

46
00:02:29,430 --> 00:02:32,660
‫Quindi, per favore, prova ad andare avanti e implementalo da

47
00:02:32,660 --> 00:02:35,313
‫solo e, se necessario, puoi ovviamente dare un'occhiata al

48
00:02:35,313 --> 00:02:36,800
‫codice che abbiamo scritto

49
00:02:36,800 --> 00:02:39,440
‫prima, ma prova davvero a scrivere il codice

50
00:02:39,440 --> 00:02:41,720
‫da solo senza copiare troppo, ok ?

51
00:02:41,720 --> 00:02:44,140
‫Quindi, puoi dare un'occhiata al resto del

52
00:02:44,140 --> 00:02:47,680
‫codice per vedere come funziona, ma poi non limitarti a copiarlo, ok?

53
00:02:47,680 --> 00:02:50,610
‫Perché allora non imparerai davvero, d'accordo.

54
00:02:50,610 --> 00:02:52,900
‫Quindi, metti in pausa il video qui e ci vediamo tra un

55
00:02:52,900 --> 00:02:54,083
‫secondo con la mia soluzione.

56
00:02:57,510 --> 00:03:00,450
‫Ok, quindi speravo che tu fossi riuscito

57
00:03:00,450 --> 00:03:03,533
‫a implementarlo e farlo funzionare, ecco come l'ho fatto.

58
00:03:04,960 --> 00:03:08,963
‫Quindi, come sempre, creiamo una nuova variabile utente e lì

59
00:03:09,970 --> 00:03:14,353
‫attendiamo il risultato dell'operazione User. findById, e ora

60
00:03:17,930 --> 00:03:20,940
‫da dove viene effettivamente questo ID?

61
00:03:20,940 --> 00:03:24,590
‫Ebbene, ricordiamo ancora che questa password di aggiornamento è solo

62
00:03:24,590 --> 00:03:27,710
‫per gli autenticati, quindi per gli utenti loggati, e

63
00:03:27,710 --> 00:03:30,830
‫quindi quindi, a questo punto, avremo già l'utente corrente

64
00:03:30,830 --> 00:03:33,123
‫sul nostro oggetto di richiesta.

65
00:03:34,380 --> 00:03:37,273
‫Ok, quindi viene dal middleware di protezione.

66
00:03:38,640 --> 00:03:42,670
‫Quindi, rich. utente. id, e

67
00:03:42,670 --> 00:03:46,933
‫poi ricorda che dobbiamo chiedere esplicitamente la password, ok?

68
00:03:48,830 --> 00:03:53,260
‫Perché, per impostazione predefinita, non è incluso nell'output.

69
00:03:53,260 --> 00:03:55,883
‫Quindi, l'abbiamo definito sullo schema, ricordi?

70
00:03:56,860 --> 00:03:58,730
‫E in realtà abbiamo bisogno

71
00:03:58,730 --> 00:04:01,860
‫di quella password perché ora vogliamo confrontarla con

72
00:04:01,860 --> 00:04:03,690
‫quella memorizzata nel database

73
00:04:03,690 --> 00:04:05,300
‫e per questo,

74
00:04:05,300 --> 00:04:08,850
‫proprio come prima, useremo questo oggetto istanza che abbiamo

75
00:04:08,850 --> 00:04:10,720
‫da qualche parte qui.

76
00:04:10,720 --> 00:04:13,360
‫Sì, quindi CorrectPassword, che è disponibile

77
00:04:13,360 --> 00:04:15,250
‫su tutti i

78
00:04:15,250 --> 00:04:17,680
‫documenti utente, quindi prende prima la

79
00:04:17,680 --> 00:04:21,850
‫password candidata e poi la password utente effettiva, tutto bene.

80
00:04:21,850 --> 00:04:23,370
‫Oh, e ora

81
00:04:23,370 --> 00:04:26,120
‫mi dà questo errore perché, ovviamente, non l'ho

82
00:04:26,120 --> 00:04:28,203
‫ancora dichiarato come una funzione asincrona.

83
00:04:29,610 --> 00:04:32,534
‫Quindi, asincrono, e prima di

84
00:04:32,534 --> 00:04:36,577
‫dimenticarlo, includiamolo anche qui nella funzione catchAsync.

85
00:04:38,589 --> 00:04:40,513
‫Ad ogni modo, proprio

86
00:04:40,513 --> 00:04:43,157
‫come prima, in pratica vogliamo creare un

87
00:04:43,157 --> 00:04:46,402
‫errore qui se la password corrente non è

88
00:04:46,402 --> 00:04:48,572
‫corretta, quindi scriviamolo nel codice.

89
00:04:48,572 --> 00:04:51,239
‫Quindi, se non utente. CorrectPassword, e

90
00:04:53,870 --> 00:04:56,283
‫poi la password candidata

91
00:04:56,283 --> 00:04:58,808
‫ricorda, e così quella sarà

92
00:04:58,808 --> 00:05:03,808
‫in un corpo, in una proprietà che chiameremo passwordConfirm.

93
00:05:03,980 --> 00:05:07,941
‫Ok, e poi come secondo argomento la password effettiva, quindi questo

94
00:05:07,941 --> 00:05:10,108
‫è un utente. parola d'ordine.

95
00:05:11,036 --> 00:05:13,820
‫E poi, ricorda che questa è una funzione

96
00:05:13,820 --> 00:05:16,323
‫asincrona, quindi dobbiamo aspettarla anche qui.

97
00:05:18,400 --> 00:05:22,173
‫Bene, quindi nel caso in cui la password non sia

98
00:05:24,020 --> 00:05:27,500
‫corretta, come sempre, creiamo un nuovo errore qui.

99
00:05:27,500 --> 00:05:32,000
‫Quindi, nuovo AppError, e questa volta stiamo

100
00:05:32,930 --> 00:05:37,930
‫dicendo che la tua password attuale è sbagliata, e

101
00:05:38,720 --> 00:05:43,660
‫quindi il codice di stato 401 per non autorizzato.

102
00:05:43,660 --> 00:05:45,650
‫Va bene, fantastico.

103
00:05:45,650 --> 00:05:48,240
‫Ora, se arriviamo a questo punto nel

104
00:05:48,240 --> 00:05:51,750
‫codice, quindi in pratica se anche la password è

105
00:05:51,750 --> 00:05:54,460
‫corretta, allora possiamo effettivamente aggiornare la password,

106
00:05:54,460 --> 00:05:56,400
‫e come lo facciamo?

107
00:05:56,400 --> 00:05:58,763
‫Bene, molto semplice, l'abbiamo fatto prima.

108
00:05:59,630 --> 00:06:04,630
‫Tutto ciò che diciamo è utente. la password è uguale a req. corpo. password, e

109
00:06:08,200 --> 00:06:11,793
‫poi lo stesso, ovviamente, per la conferma della password.

110
00:06:14,010 --> 00:06:17,560
‫Ok, e la convalida verrà eseguita automaticamente dal validatore

111
00:06:17,560 --> 00:06:21,300
‫che abbiamo specificato nello schema, e verrà eseguita una volta

112
00:06:21,300 --> 00:06:23,823
‫che lo avremo effettivamente salvato.

113
00:06:24,690 --> 00:06:29,280
‫Quindi, aspettiamo l'utente. salva, e quindi

114
00:06:29,280 --> 00:06:32,400
‫questa volta non disattiviamo la convalida

115
00:06:32,400 --> 00:06:35,920
‫perché, ovviamente, vogliamo che la convalida avvenga, quindi

116
00:06:35,920 --> 00:06:39,120
‫come ho detto prima, vogliamo verificare che

117
00:06:39,120 --> 00:06:42,010
‫la conferma della password sia effettivamente

118
00:06:42,010 --> 00:06:44,560
‫la stessa della password, giusto?

119
00:06:44,560 --> 00:06:45,570
‫Bene.

120
00:06:45,570 --> 00:06:49,460
‫E ora, solo per essere davvero sicuro che tu capisca perché non

121
00:06:49,460 --> 00:06:53,533
‫abbiamo fatto qualcosa come user. findByIdAndUpdate.

122
00:06:56,530 --> 00:06:59,260
‫Allora, perché non l'abbiamo fatto così?

123
00:06:59,260 --> 00:07:02,450
‫E so che ne ho parlato molte volte prima,

124
00:07:02,450 --> 00:07:05,330
‫ma voglio che capiate al cento per cento perché

125
00:07:05,330 --> 00:07:07,990
‫non possiamo usare questo aggiornamento, ed è per

126
00:07:07,990 --> 00:07:09,540
‫due motivi, quindi

127
00:07:09,540 --> 00:07:12,143
‫lasciatemi tornare di nuovo al nostro modello.

128
00:07:13,090 --> 00:07:14,650
‫Quindi, il

129
00:07:14,650 --> 00:07:18,920
‫primo è che questa convalida qui non funzionerà, ok?

130
00:07:18,920 --> 00:07:22,670
‫E questo è fondamentalmente perché questo. la password non

131
00:07:22,670 --> 00:07:27,420
‫è definita quando aggiorniamo, quindi quando usiamo find by ID e

132
00:07:27,420 --> 00:07:29,440
‫update, perché internamente, dietro

133
00:07:29,440 --> 00:07:33,200
‫le quinte, Mongoose non mantiene realmente l'oggetto corrente in

134
00:07:33,200 --> 00:07:36,230
‫memoria, e quindi, questo qui non funzionerà.

135
00:07:36,230 --> 00:07:39,130
‫E, come ho detto, ne ho già

136
00:07:39,130 --> 00:07:42,650
‫parlato prima, quindi in realtà è scritto anche qui, ok?

137
00:07:42,650 --> 00:07:45,600
‫Ma è davvero importante tenere a mente di

138
00:07:45,600 --> 00:07:49,340
‫non utilizzare l'aggiornamento per tutto ciò che riguarda le password, ok?

139
00:07:49,340 --> 00:07:51,160
‫Quindi, questo

140
00:07:51,160 --> 00:07:53,640
‫non funzionerà e anche questi

141
00:07:53,640 --> 00:07:56,510
‫due Middleware pre-salvati non funzioneranno.

142
00:07:56,510 --> 00:07:59,820
‫Quindi, se usassimo semplicemente update per aggiornare

143
00:07:59,820 --> 00:08:03,000
‫la password, quella password non verrebbe crittografata,

144
00:08:03,000 --> 00:08:04,750
‫che è questo

145
00:08:04,750 --> 00:08:07,530
‫primo Middleware, e quindi anche

146
00:08:07,530 --> 00:08:11,030
‫il timestamp passwordChangedAt non verrebbe impostato, ok?

147
00:08:11,030 --> 00:08:12,830
‫Quindi, niente di tutto questo funzionerebbe,

148
00:08:12,830 --> 00:08:15,943
‫e quindi di nuovo, abbiamo davvero bisogno di farlo in questo modo.

149
00:08:17,470 --> 00:08:19,020
‫Mettiamolo di nuovo qui.

150
00:08:21,330 --> 00:08:24,430
‫E così ora, (borbotta), abbiamo effettuato

151
00:08:24,430 --> 00:08:27,840
‫l'accesso dell'utente e inviato il token al client.

152
00:08:27,840 --> 00:08:30,210
‫Ora, questa sarebbe in realtà la quarta

153
00:08:30,210 --> 00:08:32,320
‫volta che eseguiamo lo stesso codice,

154
00:08:32,320 --> 00:08:34,190
‫quindi fondamentalmente questo pezzo di

155
00:08:34,190 --> 00:08:36,710
‫codice, e quindi ora lo riformuliamo molto

156
00:08:36,710 --> 00:08:38,410
‫rapidamente nella sua funzione.

157
00:08:38,410 --> 00:08:42,410
‫Ora, questo codice in realtà non è lo stesso ovunque.

158
00:08:42,410 --> 00:08:45,090
‫Quindi, qui abbiamo inviato il codice di

159
00:08:45,090 --> 00:08:47,250
‫stato 400 e non

160
00:08:47,250 --> 00:08:51,280
‫inviamo l'utente, ma poi quassù nel gestore di registrazione, abbiamo

161
00:08:51,280 --> 00:08:53,680
‫effettivamente un codice di stato diverso

162
00:08:53,680 --> 00:08:56,900
‫e abbiamo anche inviato l'utente al client, ok?

163
00:08:56,900 --> 00:08:59,873
‫E quindi, facciamo in modo che la nostra funzione lo tenga a mente.

164
00:09:00,890 --> 00:09:05,890
‫Quindi, creiamo una funzione qui, creiamo e inviamo token, quindi

165
00:09:06,140 --> 00:09:09,293
‫gli argomenti di cui abbiamo bisogno

166
00:09:11,100 --> 00:09:14,350
‫qui sono l'utente perché è lì

167
00:09:14,350 --> 00:09:17,070
‫che è memorizzato l'ID.

168
00:09:17,070 --> 00:09:18,893
‫Quindi, vogliamo anche

169
00:09:20,220 --> 00:09:24,060
‫il codice di stato e, naturalmente, dobbiamo avere accesso

170
00:09:24,060 --> 00:09:26,940
‫all'oggetto di risposta per poter effettivamente

171
00:09:26,940 --> 00:09:29,510
‫inviare una risposta al client, ok?

172
00:09:29,510 --> 00:09:32,473
‫E quindi, in pratica ora ciò di cui abbiamo bisogno è questo codice.

173
00:09:33,775 --> 00:09:35,930
‫Quindi, copiamolo, mettiamolo qui

174
00:09:35,930 --> 00:09:38,700
‫e poi sostituiamo le variabili irrilevanti.

175
00:09:38,700 --> 00:09:42,480
‫Quindi, l'utente viene semplicemente chiamato utente, quindi proprio

176
00:09:42,480 --> 00:09:44,963
‫così, e qui, lo stesso.

177
00:09:46,470 --> 00:09:47,510
‫Quindi, non

178
00:09:47,510 --> 00:09:51,150
‫un nuovo utente, e quindi qui lo sostituiamo con il codice

179
00:09:51,150 --> 00:09:54,440
‫di stato, quindi quello che sta entrando nella nostra funzione,

180
00:09:54,440 --> 00:09:57,053
‫e quindi immagino che sia effettivamente così.

181
00:09:58,330 --> 00:10:01,070
‫Quindi, ora andiamo avanti e

182
00:10:01,070 --> 00:10:06,070
‫sostituiamolo, quindi createSendToken, e qui l'utente è chiamato newUser, il codice

183
00:10:09,040 --> 00:10:10,763
‫di stato è

184
00:10:12,260 --> 00:10:15,093
‫201 e quindi ovviamente l'oggetto risposta.

185
00:10:16,730 --> 00:10:19,223
‫Ok, ora possiamo sbarazzarci di questo codice

186
00:10:20,680 --> 00:10:21,863
‫e copiamolo.

187
00:10:23,200 --> 00:10:26,903
‫Va bene, quindi nel log in abbiamo ovviamente inviato anche un

188
00:10:28,860 --> 00:10:32,630
‫token, ma questa volta l'utente si chiama effettivamente utente e il codice

189
00:10:32,630 --> 00:10:34,243
‫di stato è 200.

190
00:10:38,470 --> 00:10:39,920
‫E ora, copiamo questo.

191
00:10:42,210 --> 00:10:45,853
‫Quindi, il prossimo dovrebbe essere qui, e reimpostare la password,

192
00:10:46,930 --> 00:10:48,400
‫e qui in realtà

193
00:10:48,400 --> 00:10:51,323
‫è lo stesso, quindi il nome è utente

194
00:10:53,740 --> 00:10:57,550
‫e codice 200, e ora, finalmente, anche qui è lo stesso.

195
00:10:57,550 --> 00:11:02,360
‫E così, questo completa la nostra funzione di aggiornamento della password.

196
00:11:02,360 --> 00:11:03,740
‫Ora, per farlo funzionare,

197
00:11:03,740 --> 00:11:06,830
‫dobbiamo ovviamente implementare il percorso anche qui nel nostro

198
00:11:06,830 --> 00:11:08,033
‫router utente.

199
00:11:09,900 --> 00:11:14,400
‫Quindi, router. patch, e faremo una patch

200
00:11:14,400 --> 00:11:17,610
‫perché stiamo effettivamente cambiando, quindi stiamo manipolando il

201
00:11:17,610 --> 00:11:21,460
‫documento utente, e quindi è a questo che serve patch.

202
00:11:21,460 --> 00:11:24,590
‫E il percorso si chiama updateMyPassword.

203
00:11:29,060 --> 00:11:30,630
‫Quindi, la mia

204
00:11:30,630 --> 00:11:34,420
‫password perché è per l'utente attualmente connesso, quindi ricorda,

205
00:11:34,420 --> 00:11:36,810
‫di nuovo, funziona solo per gli

206
00:11:36,810 --> 00:11:41,770
‫utenti registrati, quindi dobbiamo usare authController. proteggere, che quindi metterà

207
00:11:41,770 --> 00:11:44,240
‫anche l'oggetto utente

208
00:11:44,240 --> 00:11:47,270
‫su un oggetto richiesta, ok?

209
00:11:47,270 --> 00:11:51,593
‫Quindi, proteggi e poi authController aggiorna la password

210
00:11:51,593 --> 00:11:55,640
‫che abbiamo appena creato, va bene.

211
00:11:55,640 --> 00:11:59,593
‫E quindi, ora andiamo avanti e proviamo questo, ok?

212
00:12:02,720 --> 00:12:05,763
‫Quindi, copiamo questo percorso qui, quindi UpdateMyPassword,

213
00:12:08,080 --> 00:12:09,790
‫e ora ciò che

214
00:12:14,300 --> 00:12:18,190
‫dobbiamo inviare nel corpo sono queste tre password in

215
00:12:18,190 --> 00:12:20,103
‫realtà, quindi è fondamentalmente

216
00:12:21,290 --> 00:12:24,817
‫la passwordCurrent, e per ora le lascio vuote,

217
00:12:30,350 --> 00:12:32,050
‫voglio semplicemente

218
00:12:32,050 --> 00:12:35,000
‫mettere il campo nomi qui per ora.

219
00:12:35,000 --> 00:12:38,750
‫Quindi, passwordCurrent quindi solo password, che è

220
00:12:38,750 --> 00:12:40,503
‫fondamentalmente quella

221
00:12:41,690 --> 00:12:44,110
‫nuova, e poi, ovviamente, passwordConfirm.

222
00:12:46,930 --> 00:12:50,320
‫Ok, e ora abbiamo effettivamente bisogno di accedere come

223
00:12:50,320 --> 00:12:53,140
‫utente perché ricorda, funziona solo se

224
00:12:53,140 --> 00:12:56,250
‫l'utente ha già effettuato l'accesso, va bene.

225
00:12:56,250 --> 00:12:59,333
‫E quindi, facciamolo con l'amministratore qui.

226
00:13:00,633 --> 00:13:04,620
‫E questa qui è, dovrebbe essere ancora la password

227
00:13:04,620 --> 00:13:07,610
‫corrente, e infatti, ora siamo registrati.

228
00:13:07,610 --> 00:13:10,520
‫E ricorda che questo token ora

229
00:13:10,520 --> 00:13:13,313
‫viene archiviato nella variabile

230
00:13:14,240 --> 00:13:17,080
‫di ambiente JWT, quindi, qui, per

231
00:13:17,080 --> 00:13:20,400
‫autenticarci, usiamolo proprio come abbiamo fatto prima.

232
00:13:20,400 --> 00:13:24,710
‫Quindi, in questa scheda di autorizzazione, selezioniamo Bearer

233
00:13:24,710 --> 00:13:27,480
‫Token e quindi precompilerà automaticamente

234
00:13:27,480 --> 00:13:29,293
‫questa variabile JWT.

235
00:13:30,140 --> 00:13:32,830
‫Va bene, quindi è da

236
00:13:32,830 --> 00:13:35,873
‫lì che verrà effettivamente l'ID utente, ricordi?

237
00:13:37,830 --> 00:13:42,830
‫Ad ogni modo, ora specifichiamo la password corrente, quindi pass1234,

238
00:13:42,999 --> 00:13:45,613
‫e poi diciamo newpassword, ok?

239
00:13:49,040 --> 00:13:50,713
‫Copialo e incollalo

240
00:13:51,560 --> 00:13:54,170
‫qui, ma in realtà di nuovo, voglio

241
00:13:54,170 --> 00:13:56,960
‫iniziare testandolo con una conferma di password

242
00:13:56,960 --> 00:13:59,810
‫errata, solo per vedere se la nostra

243
00:13:59,810 --> 00:14:02,720
‫convalida funziona ancora e ora il percorso non

244
00:14:02,720 --> 00:14:07,300
‫è definito, ma è semplicemente perché stiamo usando il verbo sbagliato qui.

245
00:14:07,300 --> 00:14:09,610
‫Certo, deve essere patch.

246
00:14:09,610 --> 00:14:11,430
‫Proviamo di nuovo, ma

247
00:14:11,430 --> 00:14:15,040
‫ora sappiamo che la tua password attuale è sbagliata, ma in

248
00:14:15,040 --> 00:14:18,270
‫realtà non lo è, quindi in realtà è corretta.

249
00:14:18,270 --> 00:14:21,163
‫Quindi, qualcosa deve essere sbagliato nel nostro codice, quindi

250
00:14:22,260 --> 00:14:24,143
‫proviamo a dare un'occhiata qui.

251
00:14:26,440 --> 00:14:28,440
‫E sì, quindi ecco

252
00:14:28,440 --> 00:14:32,240
‫in realtà il problema perché non vogliamo confrontare o confermare la

253
00:14:32,240 --> 00:14:34,763
‫password, ovviamente, ma con la password corrente.

254
00:14:35,750 --> 00:14:39,780
‫Ok, quindi è solo uno stupido bug, va bene, e

255
00:14:39,780 --> 00:14:41,620
‫quindi ora dovrebbe funzionare.

256
00:14:41,620 --> 00:14:45,000
‫Quindi, ovviamente, vogliamo confrontare la password

257
00:14:45,000 --> 00:14:47,050
‫corrente con quella

258
00:14:47,050 --> 00:14:50,220
‫attualmente memorizzata nel database, va bene.

259
00:14:50,220 --> 00:14:51,503
‫Quindi, proviamo di

260
00:14:52,670 --> 00:14:55,460
‫nuovo, e questo è l'errore di convalida che stavamo

261
00:14:55,460 --> 00:14:57,080
‫cercando, quindi le password non

262
00:14:57,080 --> 00:14:59,840
‫sono le stesse perché, in effetti, non lo sono.

263
00:14:59,840 --> 00:15:02,610
‫E ora, prima di aggiornare effettivamente la password,

264
00:15:02,610 --> 00:15:04,560
‫diamo un'occhiata a Compass qui.

265
00:15:06,070 --> 00:15:08,550
‫Aggiorniamolo qui velocemente e quindi,

266
00:15:08,550 --> 00:15:11,160
‫in questo momento, questa è la password.

267
00:15:11,160 --> 00:15:15,080
‫Quindi, la fine qui è pW1i, ok?

268
00:15:15,080 --> 00:15:17,410
‫Quindi, aggiorniamo la password

269
00:15:17,410 --> 00:15:21,333
‫ora e vediamo come sarà dopo, ok?

270
00:15:23,400 --> 00:15:25,633
‫Quindi, ora dovrebbe essere tutto corretto.

271
00:15:26,720 --> 00:15:31,720
‫E, in effetti, otteniamo il nostro successo e il nostro token, eccome.

272
00:15:33,500 --> 00:15:36,000
‫Quindi, confermiamolo qui velocemente, e, in

273
00:15:36,000 --> 00:15:38,570
‫effetti, vedi che la password è cambiata

274
00:15:38,570 --> 00:15:40,830
‫e anche il timestamp corrente,

275
00:15:40,830 --> 00:15:44,403
‫quindi l'ora in cui fondamentalmente sto registrando questo video.

276
00:15:45,370 --> 00:15:48,670
‫Va bene, e ora, proprio come

277
00:15:48,670 --> 00:15:51,960
‫prima, otteniamo questo test qui.

278
00:15:51,960 --> 00:15:55,433
‫Quindi, fondamentalmente archiviando il token come variabile di ambiente.

279
00:15:59,150 --> 00:16:03,910
‫Quindi, solo così tutto funziona davvero qui a Postman.

280
00:16:03,910 --> 00:16:06,453
‫Ok, salviamolo in realtà,

281
00:16:07,590 --> 00:16:12,590
‫aggiorniamo la password dell'utente corrente per renderla davvero esplicita,

282
00:16:14,560 --> 00:16:17,780
‫e sì, penso che sia così.

283
00:16:17,780 --> 00:16:21,090
‫Penso che questo sia tutto ciò che dobbiamo fare

284
00:16:21,090 --> 00:16:24,090
‫per aggiornare la password di un utente.

285
00:16:24,090 --> 00:16:27,890
‫Successivamente, implementeremo l'aggiornamento di altri dati utente, quindi

286
00:16:27,890 --> 00:16:30,713
‫cose come e-mail o password.

