1
00:00:01,260 --> 00:00:02,480
‫Jonas: Quindi

2
00:00:02,480 --> 00:00:04,560
‫in questa lezione implementeremo la funzionalità

3
00:00:04,560 --> 00:00:08,010
‫di accesso degli utenti in base a una determinata

4
00:00:08,010 --> 00:00:09,363
‫password e indirizzo e-mail.

5
00:00:10,920 --> 00:00:14,520
‫E proprio come prima, il concetto di accesso di

6
00:00:14,520 --> 00:00:17,400
‫un utente significa sostanzialmente firmare un token Web

7
00:00:17,400 --> 00:00:19,760
‫JSON e inviarlo al client.

8
00:00:19,760 --> 00:00:22,390
‫Ma in questo caso emettiamo il token solo

9
00:00:22,390 --> 00:00:24,860
‫nel caso in cui l'utente esista effettivamente

10
00:00:24,860 --> 00:00:27,310
‫e che la password sia corretta.

11
00:00:27,310 --> 00:00:29,773
‫Quindi, iniziamo a implementarlo.

12
00:00:31,480 --> 00:00:36,260
‫Esportazioni. l'accesso è...

13
00:00:39,090 --> 00:00:42,253
‫richiesta, risposta e successivo.

14
00:00:44,370 --> 00:00:47,060
‫E la prima cosa è leggere

15
00:00:47,060 --> 00:00:50,020
‫effettivamente l'e-mail e la password dal corpo.

16
00:00:50,020 --> 00:00:54,740
‫Quindi diciamo che const email è uguale a req. corpo. e-mail.

17
00:00:58,920 --> 00:01:02,070
‫Ok, e ora eslint ci dà questo avviso, o

18
00:01:02,070 --> 00:01:04,160
‫in realtà questo errore, e

19
00:01:04,160 --> 00:01:07,080
‫dice che dovremmo usare la destrutturazione degli oggetti, ok?

20
00:01:07,080 --> 00:01:09,620
‫E quindi ho lasciato che accadesse

21
00:01:09,620 --> 00:01:12,620
‫qui apposta solo per mostrarti come possiamo farlo

22
00:01:12,620 --> 00:01:14,950
‫con la destrutturazione di ES6.

23
00:01:14,950 --> 00:01:18,490
‫E penso di averne parlato prima nel corso, e spero

24
00:01:18,490 --> 00:01:20,930
‫anche che tu abbia già familiarità

25
00:01:20,930 --> 00:01:23,330
‫con il concetto, ma comunque, dal

26
00:01:23,330 --> 00:01:25,430
‫momento che il nome

27
00:01:25,430 --> 00:01:27,920
‫di questa proprietà qui è lo stesso

28
00:01:27,920 --> 00:01:30,260
‫del nome della variabile, possiamo semplicemente

29
00:01:30,260 --> 00:01:34,150
‫farlo come questo e sbarazzati del nome della proprietà qui, ok?

30
00:01:34,150 --> 00:01:36,520
‫E vogliamo anche ottenere la password.

31
00:01:36,520 --> 00:01:37,930
‫E quindi sarebbe lo stesso, quindi in

32
00:01:37,930 --> 00:01:42,470
‫pratica la password è uguale a una richiesta. corpo. parola d'ordine.

33
00:01:42,470 --> 00:01:43,647
‫E invece

34
00:01:43,647 --> 00:01:47,940
‫di farlo, possiamo semplicemente inserire email e password.

35
00:01:47,940 --> 00:01:50,250
‫E quindi proprio così,

36
00:01:50,250 --> 00:01:54,480
‫creiamo fondamentalmente queste due variabili dell'oggetto corpo, ok?

37
00:01:54,480 --> 00:01:56,380
‫Quindi fondamentalmente questo è il

38
00:01:56,380 --> 00:02:00,223
‫modo in cui l'utente invierà le credenziali di accesso per consentirci di verificare.

39
00:02:01,070 --> 00:02:04,130
‫Ok, e quel processo di controllo ha un paio

40
00:02:04,130 --> 00:02:05,830
‫di passaggi, quindi inseriamoli

41
00:02:05,830 --> 00:02:07,750
‫qui prima di iniziare a codificare.

42
00:02:07,750 --> 00:02:12,030
‫Quindi prima dobbiamo verificare se

43
00:02:12,030 --> 00:02:17,030
‫email e password esistono effettivamente, ok?

44
00:02:17,900 --> 00:02:22,900
‫Quindi numero due, controlla se l'utente esiste e

45
00:02:24,440 --> 00:02:29,440
‫allo stesso tempo se la password è corretta.

46
00:02:31,960 --> 00:02:33,943
‫E poi terzo, se

47
00:02:39,440 --> 00:02:44,440
‫tutto va bene, invia il token, quindi il token Web JSON al client.

48
00:02:45,800 --> 00:02:48,490
‫Ok, quindi il primo è molto facile.

49
00:02:48,490 --> 00:02:53,490
‫Quindi, se non ci sono e-mail o password, vogliamo inviare

50
00:02:56,810 --> 00:03:00,370
‫un messaggio di errore al nostro cliente.

51
00:03:00,370 --> 00:03:02,600
‫Ora come lo faremo?

52
00:03:02,600 --> 00:03:04,490
‫Bene, lo faremo usando

53
00:03:04,490 --> 00:03:07,490
‫gli strumenti che abbiamo implementato proprio nell'ultima sezione.

54
00:03:07,490 --> 00:03:10,730
‫Quindi fondamentalmente il nostro errore dell'app, lo ricordi?

55
00:03:10,730 --> 00:03:12,977
‫Quindi creeremo semplicemente un nuovo errore

56
00:03:12,977 --> 00:03:15,060
‫qui e il nostro middleware

57
00:03:15,060 --> 00:03:19,190
‫di gestione degli errori globale lo raccoglierà e invierà l'errore al client.

58
00:03:19,190 --> 00:03:22,483
‫E quindi iniziamo effettivamente importando quell'errore.

59
00:03:23,350 --> 00:03:25,260
‫Quindi ricorda che è

60
00:03:25,260 --> 00:03:28,463
‫questo qui dalla nostra classe AppError, giusto?

61
00:03:29,620 --> 00:03:34,620
‫Quindi diciamo AppError e poi require.

62
00:03:40,860 --> 00:03:44,150
‫Quindi un livello più alto da qui, poi nelle utility e

63
00:03:44,150 --> 00:03:45,050
‫poi appError.

64
00:03:48,990 --> 00:03:52,430
‫Ok, quindi dobbiamo chiamare il prossimo

65
00:03:52,430 --> 00:03:56,403
‫middleware, ed è qui che passiamo l'errore, ricordi?

66
00:03:57,260 --> 00:04:00,363
‫Quindi nuovo AppError e

67
00:04:02,510 --> 00:04:07,510
‫il messaggio è: fornire e-mail e password.

68
00:04:07,530 --> 00:04:12,530
‫E il codice di errore HTTP è 400 per una richiesta errata, ok?

69
00:04:12,720 --> 00:04:14,340
‫E ora ho alcuni

70
00:04:14,340 --> 00:04:19,090
‫errori qui, e questo mi sta aiutando di nuovo a correggere alcuni bug.

71
00:04:19,090 --> 00:04:20,710
‫Quindi vedo che

72
00:04:20,710 --> 00:04:24,010
‫quassù, di nuovo, l'ho usato con una T invece

73
00:04:24,010 --> 00:04:27,740
‫di D, e se lo salvo ora, è tutto corretto.

74
00:04:27,740 --> 00:04:32,393
‫Ok, quindi iniziamo a testarlo subito.

75
00:04:33,330 --> 00:04:34,700
‫E per

76
00:04:34,700 --> 00:04:39,700
‫questo inizierò semplicemente creando un token falso qui per ora, ok.

77
00:04:39,930 --> 00:04:43,287
‫E allora diciamo res. stato 200 per ok.

78
00:04:51,202 --> 00:04:53,573
‫JSON, e poi ovviamente, come

79
00:04:56,540 --> 00:05:01,010
‫sempre, lo stato impostato su success, e poi anche il nostro token.

80
00:05:01,010 --> 00:05:02,870
‫E questo è tutto ciò

81
00:05:02,870 --> 00:05:05,130
‫che invieremo come risposta al login, ok?

82
00:05:05,130 --> 00:05:08,290
‫Quindi nessun oggetto utente perché non è affatto necessario.

83
00:05:08,290 --> 00:05:10,800
‫Tutto ciò che vogliamo come risposta per l'accesso è

84
00:05:10,800 --> 00:05:12,140
‫in realtà il token.

85
00:05:12,140 --> 00:05:15,033
‫Questo è tutto ciò che conta quando l'utente accede.

86
00:05:16,210 --> 00:05:18,960
‫Successivamente, dobbiamo implementare il

87
00:05:18,960 --> 00:05:23,600
‫percorso, quindi ripetiamolo nel nostro router utente, ok?

88
00:05:23,600 --> 00:05:27,000
‫E questo è in realtà abbastanza simile a questo.

89
00:05:27,000 --> 00:05:30,310
‫Duplichiamolo e poi sostituiamo la registrazione

90
00:05:30,310 --> 00:05:34,780
‫in entrambi i casi qui con il login, ok?

91
00:05:34,780 --> 00:05:38,220
‫E ancora, questo è valido solo per una richiesta

92
00:05:38,220 --> 00:05:40,360
‫di posta, perché ovviamente vogliamo

93
00:05:40,360 --> 00:05:43,200
‫inviare le credenziali di accesso nel corpo.

94
00:05:43,200 --> 00:05:44,630
‫E così di nuovo

95
00:05:44,630 --> 00:05:47,610
‫è un post, ma non un get, non una patch e

96
00:05:47,610 --> 00:05:50,393
‫non un'eliminazione, perché in questo caso non ha alcun senso.

97
00:05:51,590 --> 00:05:54,033
‫Allora proviamolo subito.

98
00:05:54,970 --> 00:05:57,033
‫Copio anche questo URL qui.

99
00:05:58,050 --> 00:06:03,050
‫Sarà posta, login e ovviamente il

100
00:06:03,570 --> 00:06:05,140
‫corpo.

101
00:06:05,140 --> 00:06:08,700
‫Quindi di nuovo, raw e JSON.

102
00:06:08,700 --> 00:06:11,443
‫Quindi creiamo un corpo semplice qui.

103
00:06:17,680 --> 00:06:19,960
‫Va bene, quindi proviamo a

104
00:06:19,960 --> 00:06:22,993
‫inviarlo senza alcuna password e vediamo cosa succede.

105
00:06:24,460 --> 00:06:27,470
‫E infatti funziona, quindi riceviamo il nostro messaggio qui:

106
00:06:27,470 --> 00:06:30,030
‫per favore fornisci email e password.

107
00:06:30,030 --> 00:06:31,820
‫E ancora, dal momento che siamo

108
00:06:31,820 --> 00:06:34,110
‫in fase di sviluppo, stiamo ottenendo tutto questo

109
00:06:34,110 --> 00:06:36,910
‫stack di errori qui e l'errore completo con il nostro

110
00:06:36,910 --> 00:06:39,350
‫codice di stato, lo stato e ovviamente anche dicendo

111
00:06:39,350 --> 00:06:41,330
‫che si tratta di un errore operativo.

112
00:06:41,330 --> 00:06:45,840
‫Quindi, proprio come abbiamo definito nella sezione precedente, ok?

113
00:06:45,840 --> 00:06:48,433
‫Ora proviamo lo stesso con la password.

114
00:06:50,750 --> 00:06:55,750
‫Quindi password, impostala su Penso che fosse quella giusta,

115
00:06:56,400 --> 00:06:58,893
‫quindi elimina l'e-mail.

116
00:07:00,590 --> 00:07:02,950
‫E questo ovviamente innesca lo stesso.

117
00:07:02,950 --> 00:07:06,000
‫Ok, e con tutto ciò che è corretto dovrebbe funzionare,

118
00:07:06,000 --> 00:07:08,803
‫e in effetti qui otteniamo il nostro token falso.

119
00:07:10,300 --> 00:07:12,890
‫Ora solo una cosa che dovremmo fare

120
00:07:12,890 --> 00:07:14,880
‫qui è anche tornare.

121
00:07:14,880 --> 00:07:16,790
‫Quindi l'abbiamo fatto molte volte prima e lascia

122
00:07:16,790 --> 00:07:18,680
‫che te lo spieghi di nuovo.

123
00:07:18,680 --> 00:07:21,610
‫È semplicemente perché dopo aver chiamato il

124
00:07:21,610 --> 00:07:24,380
‫prossimo middleware, vogliamo assicurarci che questa

125
00:07:24,380 --> 00:07:27,873
‫funzione di accesso qui finisca subito, va bene?

126
00:07:30,260 --> 00:07:32,080
‫E poiché non lo avevamo

127
00:07:32,080 --> 00:07:34,560
‫prima, ora vedi di nuovo questo errore qui.

128
00:07:34,560 --> 00:07:38,060
‫Quindi questo è già abbastanza familiare a questo punto, giusto?

129
00:07:38,060 --> 00:07:40,940
‫Quindi non è possibile impostare le intestazioni dopo che sono state inviate

130
00:07:40,940 --> 00:07:43,360
‫al client, perché di nuovo, abbiamo inviato due risposte.

131
00:07:43,360 --> 00:07:47,840
‫Prima la risposta all'errore, e poi anche questo codice qui eseguito, cosa che

132
00:07:47,840 --> 00:07:50,040
‫ovviamente non avrebbe dovuto fare.

133
00:07:50,040 --> 00:07:52,933
‫E così ancora una volta usiamo return qui per risolvere il problema.

134
00:07:53,790 --> 00:07:57,430
‫Ok, ora controlliamo se esiste effettivamente un utente per

135
00:07:57,430 --> 00:07:59,870
‫l'e-mail che è stata pubblicata.

136
00:07:59,870 --> 00:08:04,870
‫Quindi const user, quindi ora usiamo il findOne in realtà, perché

137
00:08:09,940 --> 00:08:13,400
‫questa volta non stiamo selezionando un utente dall'ID,

138
00:08:13,400 --> 00:08:16,650
‫ma invece dalla sua email, giusto?

139
00:08:16,650 --> 00:08:19,460
‫E quindi dobbiamo passare quell'oggetto

140
00:08:19,460 --> 00:08:24,190
‫filtro in cui possiamo dire e-mail uguale a e-mail, ok?

141
00:08:24,190 --> 00:08:25,940
‫Quindi il campo si chiama

142
00:08:25,940 --> 00:08:28,270
‫e-mail e la variabile si chiama anche e-mail.

143
00:08:28,270 --> 00:08:32,163
‫E così in ES6 possiamo abbreviarlo semplicemente come questo.

144
00:08:33,060 --> 00:08:34,490
‫Ora, prima di andare

145
00:08:34,490 --> 00:08:36,110
‫avanti qui, c'è davvero qualcosa

146
00:08:36,110 --> 00:08:38,520
‫di importante che devo fare per la sicurezza.

147
00:08:38,520 --> 00:08:41,220
‫Quindi lascia che te lo mostri

148
00:08:41,220 --> 00:08:43,970
‫a Postman, dove abbiamo registrato un nuovo account.

149
00:08:43,970 --> 00:08:46,540
‫E quindi vedi qui che

150
00:08:46,540 --> 00:08:49,810
‫nell'output dell'utente, otteniamo effettivamente la password, ok?

151
00:08:49,810 --> 00:08:52,010
‫In realtà è crittografato,

152
00:08:52,010 --> 00:08:55,010
‫ma comunque non è una buona pratica divulgare

153
00:08:55,010 --> 00:08:57,710
‫i dati della password al client, ok?

154
00:08:57,710 --> 00:09:01,090
‫Ad esempio, se avessimo il nostro ottieni tutti gli

155
00:09:01,090 --> 00:09:03,480
‫utenti qui e questo percorso non è

156
00:09:03,480 --> 00:09:07,170
‫ancora implementato, ma se dovessimo ottenere tutti gli utenti dalla

157
00:09:07,170 --> 00:09:09,440
‫raccolta, allora tutti avrebbero la

158
00:09:09,440 --> 00:09:12,720
‫password visibile e non lo vogliamo , va bene?

159
00:09:12,720 --> 00:09:15,790
‫E quindi aggiustarlo è in realtà abbastanza facile,

160
00:09:15,790 --> 00:09:17,850
‫perché l'abbiamo fatto prima.

161
00:09:17,850 --> 00:09:19,973
‫Tutto quello che dobbiamo

162
00:09:20,820 --> 00:09:25,270
‫fare è dire la password, quindi selezionarla e impostarla su false.

163
00:09:25,270 --> 00:09:28,100
‫E così in questo modo non verrà mai visualizzato automaticamente

164
00:09:28,100 --> 00:09:29,123
‫in nessun output.

165
00:09:30,520 --> 00:09:32,520
‫E lascia che

166
00:09:32,520 --> 00:09:37,023
‫te lo dimostri in realtà iscrivendoti come qualcos'altro, così così.

167
00:09:39,070 --> 00:09:41,920
‫E vediamo, oh, in realtà abbiamo

168
00:09:41,920 --> 00:09:45,833
‫già un utente con quell'e-mail, quindi facciamo solo test3.

169
00:09:47,300 --> 00:09:50,830
‫E ora la password in realtà è ancora qui, ma

170
00:09:50,830 --> 00:09:54,100
‫immagino che sia semplicemente perché potremmo semplicemente crearla, questo

171
00:09:54,100 --> 00:09:55,610
‫nuovo documento qui,

172
00:09:55,610 --> 00:09:58,030
‫e quindi quindi non lo seleziona

173
00:09:58,030 --> 00:10:01,460
‫davvero perché non lo stiamo effettivamente leggendo dal database.

174
00:10:01,460 --> 00:10:03,250
‫Quindi implementiamo molto

175
00:10:03,250 --> 00:10:05,100
‫rapidamente questo percorso qui,

176
00:10:05,100 --> 00:10:07,690
‫ci vorrà solo un minuto.

177
00:10:07,690 --> 00:10:10,300
‫Quindi, solo per vedere se questo qui funziona davvero.

178
00:10:10,300 --> 00:10:12,230
‫Perché questo passaggio è

179
00:10:12,230 --> 00:10:15,170
‫davvero importante per quello che faremo dopo, ok?

180
00:10:15,170 --> 00:10:18,820
‫Quindi andiamo avanti e copiamo questo codice da getAllTours,

181
00:10:18,820 --> 00:10:22,000
‫e non copiamo veramente, ma quello che faremo

182
00:10:22,000 --> 00:10:25,133
‫è abbastanza simile a questo ovviamente.

183
00:10:26,750 --> 00:10:28,590
‫Quindi copierò semplicemente questo,

184
00:10:28,590 --> 00:10:30,450
‫ma senza le funzionalità API.

185
00:10:30,450 --> 00:10:33,700
‫Quindi non mi interessa molto, ok?

186
00:10:33,700 --> 00:10:35,500
‫E quindi questo lo

187
00:10:35,500 --> 00:10:39,170
‫farò nel controller utente, perché ottenere tutti gli utenti non ha

188
00:10:39,170 --> 00:10:41,350
‫nulla a che fare con l'autenticazione.

189
00:10:41,350 --> 00:10:43,570
‫E quindi in questo caso

190
00:10:43,570 --> 00:10:47,020
‫il controller utente è il posto perfetto per farlo.

191
00:10:47,020 --> 00:10:49,440
‫Ora ovviamente ho anche bisogno di

192
00:10:49,440 --> 00:10:51,990
‫importare rapidamente il modello utente qui, quindi

193
00:10:51,990 --> 00:10:56,580
‫copiamo anche quello dal tourController, che non è lo stesso ma è simile.

194
00:10:56,580 --> 00:11:00,550
‫Quindi prendiamo in realtà tutto questo nel

195
00:11:04,200 --> 00:11:06,370
‫nostro controller utente.

196
00:11:06,370 --> 00:11:09,683
‫Questo non ci serve, ma abbiamo anche bisogno di catchAsync.

197
00:11:10,520 --> 00:11:13,640
‫Ok, quindi tour sarà

198
00:11:13,640 --> 00:11:18,400
‫user, e qui sarà userModel, va bene?

199
00:11:18,400 --> 00:11:21,420
‫Poi qui abbiamo i tour, e quaggiù e quaggiù,

200
00:11:21,420 --> 00:11:23,790
‫quindi premo Comando + D per selezionarli

201
00:11:23,790 --> 00:11:26,033
‫tutti e cambiarli in utenti.

202
00:11:27,190 --> 00:11:32,190
‫E poi qui ovviamente quello che stiamo aspettando è Utente. trova.

203
00:11:34,870 --> 00:11:36,320
‫Ora, poiché abbiamo

204
00:11:36,320 --> 00:11:41,310
‫un'attesa qui, abbiamo bisogno di async, quindi abbiamo anche bisogno di next, e

205
00:11:41,310 --> 00:11:42,810
‫poiché abbiamo un async

206
00:11:42,810 --> 00:11:46,580
‫qui, dovremmo quindi avvolgere l'intera cosa in un catch async.

207
00:11:46,580 --> 00:11:47,713
‫Quindi facciamolo.

208
00:11:50,090 --> 00:11:51,700
‫Ok, e quindi a

209
00:11:51,700 --> 00:11:53,810
‫questo punto non è più una

210
00:11:53,810 --> 00:11:58,120
‫novità per te, siamo già abituati a fare questo genere di cose, giusto?

211
00:11:58,120 --> 00:12:00,670
‫Quindi, questo dovrebbe già funzionare a

212
00:12:00,670 --> 00:12:02,470
‫questo punto, quindi proviamolo.

213
00:12:02,470 --> 00:12:06,460
‫Quindi prendi tutti gli utenti, e ora in effetti vediamo

214
00:12:06,460 --> 00:12:10,030
‫che la loro password non è inclusa nell'output.

215
00:12:10,030 --> 00:12:13,853
‫E questo è importante perché in realtà, nel find,

216
00:12:15,090 --> 00:12:17,093
‫quindi qui nell'AuthController, anche

217
00:12:18,030 --> 00:12:21,490
‫questo qui ora non conterrà la password, ok?

218
00:12:21,490 --> 00:12:23,060
‫E quindi l'output di

219
00:12:23,060 --> 00:12:25,920
‫questo qui ora non conterrà nemmeno la password.

220
00:12:25,920 --> 00:12:28,890
‫Ma abbiamo bisogno della password per verificare

221
00:12:28,890 --> 00:12:30,810
‫se è corretta, giusto?

222
00:12:30,810 --> 00:12:34,500
‫E quindi dobbiamo anche selezionarlo esplicitamente.

223
00:12:34,500 --> 00:12:37,460
‫Quindi ricorda come abbiamo usato select prima

224
00:12:37,460 --> 00:12:40,150
‫per selezionare semplicemente un paio di

225
00:12:40,150 --> 00:12:43,450
‫campi dal database, solo quelli di cui avevamo bisogno?

226
00:12:43,450 --> 00:12:45,460
‫Ora in questo caso, quando vogliamo

227
00:12:45,460 --> 00:12:47,640
‫che il campo che è di default non

228
00:12:47,640 --> 00:12:50,853
‫selezionato, abbiamo bisogno di user plus e poi il nome del campo.

229
00:12:51,720 --> 00:12:53,610
‫Quindi password in questo caso.

230
00:12:53,610 --> 00:12:58,220
‫E così in questo modo, tornerà nell'output, ok?

231
00:12:58,220 --> 00:13:01,750
‫Ovviamente dobbiamo attendere questa query

232
00:13:01,750 --> 00:13:06,260
‫e quindi contrassegnare la funzione come asincrona.

233
00:13:06,260 --> 00:13:08,140
‫E poi,

234
00:13:08,140 --> 00:13:12,010
‫proprio come prima, per evitare quel brutto

235
00:13:12,010 --> 00:13:16,253
‫blocco try catch, avvolgere l'intera funzione in catchAsync.

236
00:13:18,520 --> 00:13:20,163
‫Va bene, ha senso?

237
00:13:22,170 --> 00:13:26,770
‫Quindi ora registriamo rapidamente l'utente sulla console, solo per

238
00:13:26,770 --> 00:13:28,353
‫vedere se funziona.

239
00:13:32,220 --> 00:13:34,033
‫Quindi questo qui.

240
00:13:35,460 --> 00:13:39,600
‫Otteniamo il nostro successo e in effetti otteniamo l'utente qui.

241
00:13:39,600 --> 00:13:42,650
‫Quindi con esattamente l'e-mail che ho appena pubblicato,

242
00:13:42,650 --> 00:13:45,830
‫e poi anche la password è tornata ad essere

243
00:13:45,830 --> 00:13:47,890
‫inclusa nell'output, va bene?

244
00:13:47,890 --> 00:13:51,453
‫E così di nuovo, è perché l'abbiamo selezionato esplicitamente qui.

245
00:13:52,490 --> 00:13:54,950
‫E quindi ora è il momento di confrontare

246
00:13:54,950 --> 00:13:57,400
‫effettivamente le password che abbiamo nel database con

247
00:13:57,400 --> 00:13:59,830
‫quella che l'utente ha appena pubblicato.

248
00:13:59,830 --> 00:14:01,930
‫Ma come lo faremo?

249
00:14:01,930 --> 00:14:05,190
‫Perché ad esempio, la password

250
00:14:05,190 --> 00:14:09,169
‫potrebbe essere, o è in questo esempio, pass1234,

251
00:14:09,169 --> 00:14:13,983
‫ma quella che abbiamo memorizzato nel documento ha questo aspetto.

252
00:14:15,040 --> 00:14:17,220
‫Allora come lo confrontiamo?

253
00:14:17,220 --> 00:14:19,960
‫Non c'è davvero un modo per farlo, giusto?

254
00:14:19,960 --> 00:14:22,300
‫Ma in realtà c'è, tutto ciò

255
00:14:22,300 --> 00:14:25,890
‫che dobbiamo fare è usare di nuovo il pacchetto bcrypt, ok?

256
00:14:25,890 --> 00:14:29,400
‫Quindi abbiamo usato bcrypt per generare questa password con hash

257
00:14:29,400 --> 00:14:31,230
‫e possiamo anche usare lo stesso

258
00:14:31,230 --> 00:14:34,930
‫pacchetto per confrontare sostanzialmente una password originale come questa qui con la

259
00:14:34,930 --> 00:14:36,283
‫password con hash.

260
00:14:37,230 --> 00:14:40,700
‫Ovviamente questa password qui, poiché è crittografata, non c'è

261
00:14:40,700 --> 00:14:43,350
‫modo di recuperare la vecchia,

262
00:14:43,350 --> 00:14:46,680
‫quindi la password originale da questa stringa, giusto?

263
00:14:46,680 --> 00:14:48,150
‫Quindi questo è il

264
00:14:48,150 --> 00:14:50,550
‫punto centrale della crittografia di una password.

265
00:14:50,550 --> 00:14:52,410
‫Quindi l'unico modo

266
00:14:52,410 --> 00:14:54,890
‫per farlo è che questo pacchetto

267
00:14:54,890 --> 00:14:58,100
‫per questo algoritmo crittografi effettivamente anche questa

268
00:14:58,100 --> 00:15:02,210
‫password e poi la confronti con quella crittografata, ok?

269
00:15:02,210 --> 00:15:05,110
‫Quindi implementiamo una funzione che lo faccia,

270
00:15:05,110 --> 00:15:08,350
‫e per questo useremo, di nuovo, il pacchetto bcrypt.

271
00:15:08,350 --> 00:15:11,280
‫E lo faremo nel modello utente.

272
00:15:11,280 --> 00:15:13,767
‫E potresti chiedere "Perché lo stiamo facendo

273
00:15:13,767 --> 00:15:16,310
‫in un modello "e non solo qui", ma è,

274
00:15:16,310 --> 00:15:19,730
‫ancora una volta, perché questo è davvero correlato ai dati stessi.

275
00:15:19,730 --> 00:15:22,930
‫E inoltre abbiamo già quel pacchetto lì dentro,

276
00:15:22,930 --> 00:15:26,090
‫quindi è più facile farlo semplicemente lì.

277
00:15:26,090 --> 00:15:28,663
‫Quindi sbarazziamoci di questa stringa e poi

278
00:15:30,600 --> 00:15:32,360
‫creiamo una funzione qui,

279
00:15:32,360 --> 00:15:34,580
‫che controllerà se la password data

280
00:15:34,580 --> 00:15:37,473
‫è la stessa di quella memorizzata nel documento.

281
00:15:38,520 --> 00:15:41,100
‫Quindi per la prima volta ora creeremo

282
00:15:41,100 --> 00:15:43,000
‫qualcosa chiamato metodo di istanza.

283
00:15:43,000 --> 00:15:46,120
‫Quindi un metodo di istanza è fondamentalmente un metodo

284
00:15:46,120 --> 00:15:48,500
‫che sarà disponibile su tutti i documenti

285
00:15:48,500 --> 00:15:50,843
‫di una certa raccolta, ok?

286
00:15:51,680 --> 00:15:53,320
‫E funziona così.

287
00:15:53,320 --> 00:15:56,120
‫Quindi di nuovo, è definito

288
00:15:56,120 --> 00:16:01,050
‫su un userSchema, quindi diciamo metodi, e ora in questo

289
00:16:01,050 --> 00:16:05,273
‫caso vogliamo chiamare la funzione CorrectPassword, va bene?

290
00:16:10,340 --> 00:16:12,810
‫Quindi funzione, ora questa funzione accetterà una

291
00:16:12,810 --> 00:16:14,470
‫password candidate, quindi la

292
00:16:17,734 --> 00:16:19,650
‫password che l'utente passa nel

293
00:16:19,650 --> 00:16:22,347
‫corpo, e poi anche la password utente, ok?

294
00:16:26,010 --> 00:16:28,590
‫Ora all'interno di questi metodi

295
00:16:28,590 --> 00:16:31,470
‫istanziati, poiché sono disponibili nel documento,

296
00:16:31,470 --> 00:16:35,430
‫la parola chiave this punta effettivamente al documento corrente.

297
00:16:35,430 --> 00:16:37,610
‫Ma in questo caso, dal

298
00:16:37,610 --> 00:16:42,080
‫momento che abbiamo la password impostata per selezionare false, quindi questo qui, ricordi?

299
00:16:42,080 --> 00:16:43,690
‫Ok, e

300
00:16:43,690 --> 00:16:47,920
‫per questo, questo. la password non sarà disponibile.

301
00:16:47,920 --> 00:16:50,780
‫Quindi idealmente lo faremmo in questo modo, e

302
00:16:50,780 --> 00:16:52,360
‫quindi in questo

303
00:16:52,360 --> 00:16:56,130
‫modo dovremmo solo passare la candidatePassword e non la userPassword.

304
00:16:56,130 --> 00:16:58,690
‫Ma ancora una volta, in questo

305
00:16:58,690 --> 00:17:02,350
‫momento non è possibile perché la password non è disponibile nell'output.

306
00:17:02,350 --> 00:17:03,420
‫Ed ecco

307
00:17:03,420 --> 00:17:06,380
‫perché dobbiamo effettivamente passare anche userPassword.

308
00:17:06,380 --> 00:17:07,890
‫Quindi l'obiettivo di

309
00:17:07,890 --> 00:17:11,030
‫questa funzione è restituire solo vero o falso.

310
00:17:11,030 --> 00:17:14,000
‫Quindi sostanzialmente vero se le password sono le stesse

311
00:17:14,000 --> 00:17:15,663
‫e false in caso contrario.

312
00:17:16,560 --> 00:17:21,410
‫Quindi ritorna, e poi bcrypt che già conosciamo, e

313
00:17:21,410 --> 00:17:26,257
‫poi useremo la funzione di confronto, ok?

314
00:17:26,257 --> 00:17:29,190
‫E la funzione di confronto è

315
00:17:29,190 --> 00:17:32,200
‫davvero semplice, tutto ciò di cui abbiamo

316
00:17:32,200 --> 00:17:37,060
‫bisogno è passare la candidatePassword e la userPassword, non userSchema, userPassword, ok?

317
00:17:39,270 --> 00:17:42,090
‫E proprio come la funzione hash

318
00:17:42,090 --> 00:17:45,383
‫qui sopra, anche questa è una funzione asincrona.

319
00:17:46,270 --> 00:17:50,973
‫E così, proprio come prima, usiamo wait, e poi qui async.

320
00:17:53,330 --> 00:17:54,940
‫Ok, ha senso?

321
00:17:54,940 --> 00:17:57,630
‫Quindi, di nuovo, questa funzione di confronto

322
00:17:57,630 --> 00:17:59,800
‫qui restituirà semplicemente true se

323
00:17:59,800 --> 00:18:04,470
‫queste due password qui sono le stesse e false in caso contrario.

324
00:18:04,470 --> 00:18:07,030
‫E ancora, non possiamo confrontarli

325
00:18:07,030 --> 00:18:10,020
‫manualmente perché la password candidata non è

326
00:18:10,020 --> 00:18:12,800
‫sottoposta ad hashing, quindi è la password

327
00:18:12,800 --> 00:18:15,580
‫originale proveniente dall'utente, ma userPassword è

328
00:18:15,580 --> 00:18:18,230
‫ovviamente sottoposta ad hashing, quindi senza

329
00:18:18,230 --> 00:18:21,830
‫questa funzione qui non avremmo modo di confrontarli, ok?

330
00:18:21,830 --> 00:18:23,990
‫Quindi qui restituiamo true o false,

331
00:18:23,990 --> 00:18:26,893
‫ora tutto ciò che dobbiamo fare è chiamare effettivamente

332
00:18:26,893 --> 00:18:28,633
‫questa funzione in authController.

333
00:18:29,920 --> 00:18:31,873
‫Chiudiamo un paio di questi.

334
00:18:34,080 --> 00:18:38,253
‫Va bene, quindi questo qui era solo per dimostrazione.

335
00:18:41,400 --> 00:18:43,563
‫Quindi chiamiamolo semplicemente qui corretto, e

336
00:18:44,400 --> 00:18:47,110
‫ora ricordiamo che la funzione che abbiamo appena definito

337
00:18:47,110 --> 00:18:48,670
‫è un metodo istanziato.

338
00:18:48,670 --> 00:18:52,260
‫E quindi è disponibile su tutti i documenti utente.

339
00:18:52,260 --> 00:18:54,780
‫E quindi questa variabile qui in questo

340
00:18:54,780 --> 00:18:57,050
‫momento è un documento utente, giusto?

341
00:18:57,050 --> 00:19:00,270
‫Perché è il risultato dell'interrogazione del modello utente.

342
00:19:00,270 --> 00:19:03,637
‫E quindi ora possiamo dire utente. password corretta.

343
00:19:06,760 --> 00:19:10,650
‫Ora tutto ciò che dobbiamo fare è passare la password

344
00:19:10,650 --> 00:19:13,020
‫candidata, che è password, ricorda.

345
00:19:13,020 --> 00:19:17,830
‫Quindi questo qui e poi userPassword.

346
00:19:17,830 --> 00:19:22,830
‫E quindi questo è in utente. password, ok?

347
00:19:23,450 --> 00:19:26,373
‫E quindi questo qui ora sarà vero o falso.

348
00:19:27,990 --> 00:19:30,810
‫Va bene, e ora usiamo effettivamente queste due

349
00:19:30,810 --> 00:19:33,500
‫variabili per capire se l'utente esiste e

350
00:19:33,500 --> 00:19:35,200
‫la password è corretta.

351
00:19:35,200 --> 00:19:36,710
‫Quindi l'abbiamo già

352
00:19:36,710 --> 00:19:40,390
‫capito, ma ora dobbiamo effettivamente scrivere la nostra istruzione if.

353
00:19:40,390 --> 00:19:45,390
‫Quindi, se non c'è un utente, o la password non è corretta, quindi

354
00:19:46,160 --> 00:19:49,853
‫sostanzialmente corretto è falso, che è ciò che significa.

355
00:19:50,860 --> 00:19:54,590
‫In tal caso, vogliamo, ancora una volta, tornare

356
00:19:54,590 --> 00:19:58,640
‫e passare direttamente al nostro prossimo middleware con un

357
00:19:58,640 --> 00:19:59,640
‫nuovo AppError.

358
00:20:00,980 --> 00:20:05,973
‫E in questo caso dire email o password errate, ok?

359
00:20:08,990 --> 00:20:11,560
‫E poi il codice di

360
00:20:11,560 --> 00:20:14,870
‫stato è 401, che significa non autorizzato, ok?

361
00:20:14,870 --> 00:20:16,910
‫Ora avremmo potuto farlo separatamente,

362
00:20:16,910 --> 00:20:18,847
‫quindi prima controlla l'utente

363
00:20:18,847 --> 00:20:21,440
‫e poi controlla la password corretta.

364
00:20:21,440 --> 00:20:24,600
‫Ma in tal caso forniremmo a un

365
00:20:24,600 --> 00:20:28,710
‫potenziale aggressore informazioni se l'e-mail o la password non sono corrette.

366
00:20:28,710 --> 00:20:31,550
‫E in questo modo qui è un po' più vago.

367
00:20:31,550 --> 00:20:34,830
‫Quindi non stiamo davvero specificando cosa non è corretto qui.

368
00:20:34,830 --> 00:20:37,060
‫Quindi se è email o se è la password.

369
00:20:37,060 --> 00:20:38,700
‫Quindi, se c'è un

370
00:20:38,700 --> 00:20:41,150
‫utente malintenzionato che cerca di inserire dati

371
00:20:41,150 --> 00:20:43,640
‫casuali, non saprà se l'e-mail esiste effettivamente

372
00:20:43,640 --> 00:20:47,143
‫o se è solo la password che è sbagliata, ok?

373
00:20:47,990 --> 00:20:50,860
‫Ora solo due cose qui, e la

374
00:20:50,860 --> 00:20:53,140
‫prima è che dobbiamo

375
00:20:53,140 --> 00:20:55,480
‫effettivamente attendere questa funzione asincrona, ok?

376
00:20:55,480 --> 00:20:57,470
‫Quindi ricorda che la password corretta

377
00:20:57,470 --> 00:20:59,000
‫è una funzione

378
00:20:59,000 --> 00:21:01,333
‫asincrona, quindi anche qui dobbiamo aspettare.

379
00:21:02,690 --> 00:21:04,530
‫E poi c'è anche un

380
00:21:04,530 --> 00:21:06,980
‫altro problema, perché questo utente non esiste

381
00:21:06,980 --> 00:21:10,950
‫qui, quindi questa prossima riga di codice non può davvero essere eseguita, ok?

382
00:21:10,950 --> 00:21:13,550
‫Perché, ad esempio, utente. la password

383
00:21:13,550 --> 00:21:15,400
‫non sarà disponibile.

384
00:21:15,400 --> 00:21:18,800
‫E quindi abbiamo effettivamente bisogno di spostare tutto

385
00:21:18,800 --> 00:21:20,690
‫questo, o in realtà

386
00:21:20,690 --> 00:21:24,343
‫solo questo codice, lo sposteremo qui nell'istruzione if else.

387
00:21:26,740 --> 00:21:29,000
‫Va bene, quindi in questo modo,

388
00:21:29,000 --> 00:21:32,550
‫se l'utente non esiste, quindi se questo è vero, allora

389
00:21:32,550 --> 00:21:34,900
‫non eseguirà nemmeno questo codice qui, e

390
00:21:34,900 --> 00:21:37,070
‫quindi non ci saranno problemi.

391
00:21:37,070 --> 00:21:40,510
‫Ma se l'utente esiste, eseguirà anche questo codice e

392
00:21:40,510 --> 00:21:43,600
‫verificherà se la password è effettivamente corretta.

393
00:21:43,600 --> 00:21:45,520
‫E quindi se la password

394
00:21:45,520 --> 00:21:50,010
‫è corretta, solo in quel caso raggiungiamo questo pezzo di codice qui.

395
00:21:50,010 --> 00:21:52,710
‫Quindi questa è l'idea di questa funzione.

396
00:21:52,710 --> 00:21:55,030
‫Quindi fondamentalmente controlliamo gli aspetti negativi.

397
00:21:55,030 --> 00:21:57,270
‫Quindi, se non ci sono e-mail e

398
00:21:57,270 --> 00:21:58,880
‫password, otteniamo questo errore.

399
00:21:58,880 --> 00:22:01,690
‫Se non c'è nessun utente o se c'è una

400
00:22:01,690 --> 00:22:03,540
‫password errata, crea questo errore.

401
00:22:03,540 --> 00:22:05,610
‫Ma se non ci fosse

402
00:22:05,610 --> 00:22:09,060
‫alcun errore, in tal caso raggiungiamo questa parte del

403
00:22:09,060 --> 00:22:10,820
‫codice, dove ora generiamo

404
00:22:10,820 --> 00:22:13,490
‫un token e poi lo rimandiamo all'utente.

405
00:22:13,490 --> 00:22:16,740
‫Ora creare questo token sarà esattamente la stessa cosa che

406
00:22:16,740 --> 00:22:18,500
‫abbiamo fatto prima qui.

407
00:22:18,500 --> 00:22:20,780
‫E quindi invece di ripetere

408
00:22:20,780 --> 00:22:24,210
‫tutto questo codice, creiamo effettivamente una funzione per questo, ok?

409
00:22:24,210 --> 00:22:25,840
‫Quindi copierò

410
00:22:25,840 --> 00:22:29,427
‫questo codice, e poi qui molto rapidamente

411
00:22:31,900 --> 00:22:36,090
‫const signToken, che riceverà come unico input l'ID utente.

412
00:22:36,090 --> 00:22:41,090
‫Quindi ID, e poi restituirà il token, ok?

413
00:22:43,370 --> 00:22:46,793
‫Quindi firmerà semplicemente questo e lo restituirà immediatamente.

414
00:22:47,700 --> 00:22:50,920
‫Va bene, quindi quello che

415
00:22:50,920 --> 00:22:55,920
‫faremo è firmare il token e passare questo documento d'identità.

416
00:23:04,970 --> 00:23:09,330
‫E poi, ovviamente, dobbiamo anche cambiarlo qui, ok?

417
00:23:09,330 --> 00:23:11,750
‫Quindi imposta questo ID su questo ID, che

418
00:23:11,750 --> 00:23:14,893
‫come già sai a questo punto è lo stesso di questo.

419
00:23:15,950 --> 00:23:19,763
‫Va bene, quindi ora andiamo avanti e facciamo lo stesso qui.

420
00:23:22,547 --> 00:23:26,340
‫signToken, e quindi in questo caso è user. _ID.

421
00:23:31,300 --> 00:23:33,910
‫Uff, è stata una

422
00:23:33,910 --> 00:23:37,090
‫lunga conferenza, ora andiamo avanti e proviamolo.

423
00:23:37,090 --> 00:23:38,363
‫Quindi ora dovrebbe funzionare.

424
00:23:39,250 --> 00:23:43,470
‫Quindi ricorda, questo è ora un altro utente, ma so che questa

425
00:23:43,470 --> 00:23:46,030
‫è la password che ho usato.

426
00:23:46,030 --> 00:23:48,580
‫Quindi per ora usiamone un

427
00:23:48,580 --> 00:23:52,003
‫altro, quindi test12 e vediamo cosa succede.

428
00:23:53,540 --> 00:23:57,450
‫Aspettiamo, e in effetti, email o password errate.

429
00:23:57,450 --> 00:24:00,230
‫E così otteniamo ovviamente anche il nostro

430
00:24:00,230 --> 00:24:04,600
‫401, e in effetti significa che il nostro codice sta già

431
00:24:04,600 --> 00:24:05,933
‫testando la password.

432
00:24:06,780 --> 00:24:10,230
‫Quindi, se ora scegliamo la password corretta,

433
00:24:10,230 --> 00:24:12,793
‫dovrebbe passare, quindi aspettiamo.

434
00:24:13,760 --> 00:24:16,760
‫Ma riceviamo ancora questo errore.

435
00:24:16,760 --> 00:24:20,453
‫Bene, quindi liberiamoci semplicemente di tutti i nostri utenti qui,

436
00:24:22,170 --> 00:24:24,420
‫solo per assicurarci che non debba

437
00:24:24,420 --> 00:24:28,740
‫fare nulla con gli utenti, e poi creiamone uno nuovo, va bene.

438
00:24:33,080 --> 00:24:37,473
‫Quindi ciao@jonas e passa1234.

439
00:24:38,710 --> 00:24:42,373
‫Andiamo avanti e copiamolo, lo mando subito.

440
00:24:46,800 --> 00:24:50,070
‫E quindi queste credenziali ora sono sicuramente corrette.

441
00:24:50,070 --> 00:24:52,760
‫Quindi, se ora non funziona, c'è un qualche tipo di bug.

442
00:24:52,760 --> 00:24:55,870
‫Ma ora in realtà ha funzionato, alla grande.

443
00:24:55,870 --> 00:25:00,090
‫Quindi ecco il nostro token, e sembra esattamente come prima, quindi

444
00:25:00,090 --> 00:25:02,483
‫possiamo presumere che sia corretto.

445
00:25:03,570 --> 00:25:06,333
‫Ora proviamo di nuovo, cancellando questo, ok.

446
00:25:07,810 --> 00:25:10,753
‫E quindi con la password sbagliata non funziona.

447
00:25:11,890 --> 00:25:15,423
‫Ora mettiamo la password giusta e l'e-mail sbagliata, e poi

448
00:25:18,230 --> 00:25:19,730
‫otteniamo lo stesso errore.

449
00:25:19,730 --> 00:25:21,883
‫Quindi email o password errate.

450
00:25:22,930 --> 00:25:25,560
‫E ancora, se rimettiamo tutto a posto,

451
00:25:25,560 --> 00:25:27,560
‫otteniamo un nuovo token.

452
00:25:27,560 --> 00:25:30,810
‫E così ora siamo davvero registrati nell'applicazione.

453
00:25:30,810 --> 00:25:33,580
‫E so che questo potrebbe sembrare un po'

454
00:25:33,580 --> 00:25:37,340
‫astratto, quindi tutto ciò che otteniamo davvero è un token, e

455
00:25:37,340 --> 00:25:40,020
‫questo significa che siamo registrati nell'applicazione, giusto?

456
00:25:40,020 --> 00:25:44,720
‫Ma, beh, è così che funziona con l'autenticazione senza stato.

457
00:25:44,720 --> 00:25:47,810
‫In seguito, quando creeremo davvero il sito

458
00:25:47,810 --> 00:25:50,190
‫Web dinamico, ovviamente sarà molto

459
00:25:50,190 --> 00:25:53,900
‫più visibile se l'utente è connesso o disconnesso, giusto?

460
00:25:53,900 --> 00:25:55,920
‫Ma funzionerà ancora dietro le quinte

461
00:25:55,920 --> 00:25:57,670
‫utilizzando lo stesso token.

462
00:25:57,670 --> 00:26:01,560
‫Quindi, se non ci sono token, il sito Web avrà un aspetto

463
00:26:01,560 --> 00:26:03,800
‫in un modo, e se c'è

464
00:26:03,800 --> 00:26:06,630
‫un token, il sito Web avrà un aspetto diverso,

465
00:26:06,630 --> 00:26:11,150
‫con l'immagine dell'utente e il nome utente proprio lì nel sito Web, ad esempio.

466
00:26:11,150 --> 00:26:13,373
‫Comunque, questa è stata una conferenza piuttosto lunga.

467
00:26:14,370 --> 00:26:17,100
‫Assicurati di tornare qui e cerca davvero

468
00:26:17,100 --> 00:26:20,210
‫di capire tutto questo codice che abbiamo qui, va bene?

469
00:26:20,210 --> 00:26:21,870
‫Perché so che alcune di

470
00:26:21,870 --> 00:26:23,660
‫queste potrebbero essere un po' confuse.

471
00:26:23,660 --> 00:26:26,963
‫Ad esempio, questa funzione CorrectPassword qui.

472
00:26:27,850 --> 00:26:30,933
‫E poi sono sicuro che tutto avrà un senso per te.