1
00:00:03,950 --> 00:00:09,180
Ora che abbiamo capito passaporto e come passaporto aggiunge

2
00:00:09,180 --> 00:00:14,294
in un semplice middleware di autenticazione per la nostra applicazione NodeJS,

3
00:00:14,294 --> 00:00:18,435
e fornisce un

4
00:00:18,435 --> 00:00:22,935
modo flessibile facile da configurare e fornisce varie strategie per l'autenticazione utente,

5
00:00:22,935 --> 00:00:27,850
andiamo in un viaggio con il nostro passaporto.

6
00:00:27,890 --> 00:00:31,020
Per iniziare a questo esercizio,

7
00:00:31,020 --> 00:00:33,945
come primo passo, installiamo i

8
00:00:33,945 --> 00:00:40,135
moduli del nodo passaporto, passport-local e passport-local-mangusta nel nostro server di confusione.

9
00:00:40,135 --> 00:00:44,030
Quindi al prompt digitare npm instal_passport,

10
00:00:44,030 --> 00:00:49,820
passport-local,

11
00:00:49,820 --> 00:00:59,430
passaporto local-mangusta mnus meno salvare e installare questi tre moduli.

12
00:00:59,430 --> 00:01:05,980
Come potete vedere al momento stiamo iniziando con il passaporto 0.4.0, il

13
00:01:05,980 --> 00:01:15,004
passaporto locale 1.0.0 e il passport-local-mangusta 5.0.1 versioni in questo corso.

14
00:01:15,004 --> 00:01:20,110
Ora che abbiamo installato passaporto, passport-local, e

15
00:01:20,110 --> 00:01:25,640
passport-local-mangusta, andiamo al server confusione e andiamo al file user.js.

16
00:01:25,640 --> 00:01:31,325
Aggiorneremo lo schema utente e il modello per utilizzare il passport-local-mangusta.

17
00:01:31,325 --> 00:01:33,735
Per fare questo, qui diremo

18
00:01:33,735 --> 00:01:41,060
var PassportLocalMongoose

19
00:01:41,060 --> 00:01:45,390
richiedono passaporto-local-mangusta.

20
00:01:46,190 --> 00:01:50,330
Quindi questo installeremo come

21
00:01:50,330 --> 00:01:56,780
il plugin mangusta nella nostra applicazione e siamo

22
00:01:56,780 --> 00:02:00,440
in grado di rimuovere il nome utente e la password perché questi sarebbero automaticamente aggiunti

23
00:02:00,440 --> 00:02:04,535
dal passport-local-mangusta plugin qui e di

24
00:02:04,535 --> 00:02:12,980
utilizzare che come plugin nel nostro schema mangusta e modello.

25
00:02:12,980 --> 00:02:20,160
Diciamo l'utente plug in e passport-local-mangusta.

26
00:02:20,160 --> 00:02:23,360
Quindi, questo sarà automaticamente come ho detto aggiungendo il supporto per il

27
00:02:23,360 --> 00:02:28,040
nome utente e l'archiviazione hash della password usando

28
00:02:28,040 --> 00:02:33,305
l'hash e il sale e aggiungendo

29
00:02:33,305 --> 00:02:37,235
metodi aggiuntivi sullo schema utente

30
00:02:37,235 --> 00:02:40,880
e sul modello che sono utili per l'autenticazione del passaporto.

31
00:02:40,880 --> 00:02:48,390
Quindi, una volta completato l'aggiornamento del file user.js poi nella nostra cartella di progetto,

32
00:02:48,390 --> 00:02:55,160
creeremo un nuovo file e chiamarlo come authenticate.js.

33
00:02:55,160 --> 00:02:57,800
Nel file authentic.js,

34
00:02:57,800 --> 00:03:03,420
lasciami importare il passaporto.

35
00:03:03,940 --> 00:03:10,700
Quindi diremo richiedono passaporto e

36
00:03:10,700 --> 00:03:16,700
useremo questo file per memorizzare le strategie di autenticazione che configureremo.

37
00:03:16,700 --> 00:03:26,195
Quindi diremo var. LocalStrategy richiede passport-local,

38
00:03:26,195 --> 00:03:36,140
quindi il modulo locale passaporto esporta una strategia che possiamo utilizzare per la nostra applicazione.

39
00:03:36,140 --> 00:03:39,800
Quindi diremo Passport-local.Strategy

40
00:03:39,800 --> 00:03:56,700
e poi importeremo utente da modelli utente.

41
00:03:58,550 --> 00:04:06,270
Vediamo ora configurare il passaporto con la nuova strategia locale

42
00:04:06,270 --> 00:04:13,970
e quindi esporteremo questo da questo file perché questo sta per essere un modulo nodo.

43
00:04:13,970 --> 00:04:23,940
Quindi diremo exports.local e diremo passaporto e si

44
00:04:23,940 --> 00:04:28,580
può vedere che il passaporto supporta i vari metodi

45
00:04:28,580 --> 00:04:33,710
qui quindi diremo l'uso del passaporto e dire

46
00:04:33,710 --> 00:04:39,125
nuova LocalStrategy e poi questo è dove

47
00:04:39,125 --> 00:04:47,715
le funzioni che sono supportate dal passaporto-local-mangusta viene in nostro aiuto.

48
00:04:47,715 --> 00:04:52,225
Quindi la strategia locale dovrà essere fornita con la funzione di verifica.

49
00:04:52,225 --> 00:04:55,210
All' interno di questa funzione verificheremo l'utente.

50
00:04:55,210 --> 00:04:59,090
Questa funzione di verifica verrà chiamata con il nome utente e la password che il

51
00:04:59,090 --> 00:05:03,380
passaporto estrarrà dalla nostra richiesta in arrivo.

52
00:05:03,380 --> 00:05:09,620
Ora nella richiesta in arrivo per LocalStrategy il nome utente e la password

53
00:05:09,620 --> 00:05:16,800
devono essere forniti nel corpo del messaggio sotto forma di una stringa Json.

54
00:05:17,680 --> 00:05:21,560
Ancora una volta perché stiamo facendo corpo-parser in modo che venga

55
00:05:21,560 --> 00:05:24,500
aggiunto nel corpo del messaggio e poi da lì passaporto

56
00:05:24,500 --> 00:05:29,000
lo recupereremo e quindi useremo e fornire il nome utente e la password

57
00:05:29,000 --> 00:05:34,775
come parametri per la funzione di verifica che forniremo al LocalStrategy.

58
00:05:34,775 --> 00:05:37,565
Dal momento che stiamo usando il plugin mangusta passaporto,

59
00:05:37,565 --> 00:05:44,915
il plugin mangusta stesso aggiunge questa funzione chiamata user.authenticate.

60
00:05:44,915 --> 00:05:51,495
Quindi aggiunge questo metodo allo schema utente e al modello.

61
00:05:51,495 --> 00:05:55,775
Stiamo andando a fornire che come la funzione

62
00:05:55,775 --> 00:06:00,350
che fornirà l'autenticazione per la LocalStrategy.

63
00:06:00,350 --> 00:06:02,540
Ora, se non si utilizza

64
00:06:02,540 --> 00:06:06,875
passport-local-mangusta quando si imposta un plugin mangusta che abbiamo fatto,

65
00:06:06,875 --> 00:06:08,060
se non si utilizza questo,

66
00:06:08,060 --> 00:06:12,540
allora è necessario scrivere la propria funzione di autenticazione utente qui.

67
00:06:12,540 --> 00:06:15,720
Nella lezione precedente,

68
00:06:15,720 --> 00:06:18,860
ti avevo mostrato una semplice funzione di autenticazione utente

69
00:06:18,860 --> 00:06:22,580
che può essere utilizzata qui, ma quella

70
00:06:22,580 --> 00:06:25,610
fornita dal modulo passport-local-mangusta è più

71
00:06:25,610 --> 00:06:30,200
completa e quindi questo è ciò che faremo uso nella nostra applicazione.

72
00:06:30,200 --> 00:06:36,365
Anche dal momento che stiamo ancora utilizzando sessioni per monitorare gli utenti nella nostra applicazione,

73
00:06:36,365 --> 00:06:43,775
abbiamo bisogno di serializzare e deserializzare l'utente.

74
00:06:43,775 --> 00:06:47,345
Quindi questo fondamentalmente prende le informazioni dell'utente.

75
00:06:47,345 --> 00:06:54,815
Ora ricordare che l'autenticazione passaporto monterà la proprietà req.user o utente

76
00:06:54,815 --> 00:06:58,715
al messaggio di richiesta e in modo

77
00:06:58,715 --> 00:07:04,610
che le informazioni utente saranno serializzate e deserializzate realizzato utilizzando

78
00:07:04,610 --> 00:07:17,295
questo dicendo serializzare utente e passaporto deserializzare utente.

79
00:07:17,295 --> 00:07:22,235
Inoltre diremo utente deserializzare utente.

80
00:07:22,235 --> 00:07:27,920
Queste due funzioni che serializzano utente e deserializzare utente sono forniti

81
00:07:27,920 --> 00:07:35,030
sullo schema utente e modello dall'uso del passport-local-mangusta plugin qui.

82
00:07:35,030 --> 00:07:38,240
Quindi questo si prenderà cura di tutto ciò che è necessario per

83
00:07:38,240 --> 00:07:42,860
il nostro supporto per le sessioni sul passaporto.

84
00:07:42,860 --> 00:07:48,375
Quindi, una volta completato questo aggiornamento al file authenticate.js,

85
00:07:48,375 --> 00:07:54,200
questo file sarà richiesto ovunque sia necessario per noi da utilizzare nella nostra autenticazione.

86
00:07:54,200 --> 00:07:57,695
Avanti andando al file users.js,

87
00:07:57,695 --> 00:07:59,795
nel file users.js,

88
00:07:59,795 --> 00:08:04,170
prima importeremo il passaporto.

89
00:08:04,170 --> 00:08:09,525
Quindi diremo passaporto var richiedono passaporto.

90
00:08:09,525 --> 00:08:16,100
Quindi, poiché stiamo usando il plugin mangusta locale passaporto,

91
00:08:16,100 --> 00:08:20,525
il plugin mangusta fornisce alcune metriche che sono

92
00:08:20,525 --> 00:08:25,380
utili per noi da utilizzare nel processo di registrazione e nel processo di login.

93
00:08:25,380 --> 00:08:29,030
Quindi, andando giù al post del router qui,

94
00:08:29,030 --> 00:08:34,120
il plugin mangusta ci fornisce un metodo chiamato registro,

95
00:08:34,120 --> 00:08:37,275
sullo schema utente e sul modello.

96
00:08:37,275 --> 00:08:44,460
Quindi diremo registro utente e questo sarà trasformato in dire nuovo utente.

97
00:08:44,460 --> 00:08:51,035
Questo nuovo utente è il primo parametro che il registro prende

98
00:08:51,035 --> 00:08:58,245
e il secondo parametro è la password del corpo req.

99
00:08:58,245 --> 00:09:05,440
Quindi la password che arriva come secondo parametro nel corpo del messaggio.

100
00:09:05,440 --> 00:09:08,460
Quindi ricorda che il nome utente e la password vengono passati

101
00:09:08,460 --> 00:09:12,020
quando ti iscrivi nel corpo del messaggio.

102
00:09:12,020 --> 00:09:14,255
Ora, in questo caso,

103
00:09:14,255 --> 00:09:19,855
ciò comporterà una funzione di richiamo che fornisce errore

104
00:09:19,855 --> 00:09:25,825
e l'utente come i due valori di callback qui e sfortunatamente

105
00:09:25,825 --> 00:09:28,790
, questo non funziona in questo caso.

106
00:09:28,790 --> 00:09:33,045
Quindi dovrò ritagliarlo da qui e poi

107
00:09:33,045 --> 00:09:39,415
invece gestirlo all'interno di questo metodo di callback qui.

108
00:09:39,415 --> 00:09:43,820
Quindi, lasciami solo indentare questo,

109
00:09:43,820 --> 00:09:48,060
in modo che sia più facile vedere il codice qui.

110
00:09:48,060 --> 00:09:51,830
Quindi dirò, registro utente e il primo parametro è

111
00:09:51,830 --> 00:09:53,630
un nuovo utente creato con

112
00:09:53,630 --> 00:09:57,590
il nome utente fornito qui e il secondo parametro è la password,

113
00:09:57,590 --> 00:10:02,550
e quindi il risultato è questa funzione di callback che

114
00:10:02,550 --> 00:10:06,100
chiamerà, diremo utente errore qui.

115
00:10:06,100 --> 00:10:11,260
In questo caso, dobbiamo modificare un po 'il codice qui.

116
00:10:11,260 --> 00:10:14,620
Quindi nella prima parte,

117
00:10:14,620 --> 00:10:21,850
diremo se errore,

118
00:10:21,850 --> 00:10:28,150
quindi dovranno inviare esplicitamente la risposta.

119
00:10:28,150 --> 00:10:34,945
Quindi, ho intenzione di copiare questi due qui.

120
00:10:34,945 --> 00:10:37,670
Quindi diremo, se l'errore,

121
00:10:37,740 --> 00:10:40,860
quindi res codice di stato,

122
00:10:40,860 --> 00:10:46,970
imposteremo questo a 500 e impostare il tipo di contenuto di intestazione e poi,

123
00:10:46,970 --> 00:10:52,520
imposteremo res json e poi errore, errore.

124
00:10:52,520 --> 00:10:56,790
Quindi costruiremo un oggetto json con l'errore come

125
00:10:56,790 --> 00:11:01,590
valore per la proprietà error in lì e quindi invieremo questo indietro.

126
00:11:01,590 --> 00:11:06,145
Quindi questo è il modo in cui gestiresti l'errore in questo caso.

127
00:11:06,145 --> 00:11:11,110
Altrimenti, quello che facciamo qui è che

128
00:11:11,110 --> 00:11:18,970
diremo passaporto autenticare locale.

129
00:11:18,970 --> 00:11:23,810
Quindi, se abbiamo intenzione di utilizzare il passaporto per autenticare nuovamente l'utente.

130
00:11:23,810 --> 00:11:25,930
Quindi diremo passaporto autenticare locale.

131
00:11:25,930 --> 00:11:28,820
Per garantire che la registrazione dell'utente abbia avuto successo.

132
00:11:28,820 --> 00:11:33,145
cercheremo di autenticare lo stesso utente che abbiamo appena registrato e

133
00:11:33,145 --> 00:11:38,335
qui diremo req res e questo

134
00:11:38,335 --> 00:11:48,355
restituirà come terzo valore quella funzione all'interno della quale,

135
00:11:48,355 --> 00:11:52,300
invieremo la risposta al nostro cliente.

136
00:11:52,300 --> 00:12:01,140
Quindi diremo. Lasciami rimuovere questo e poi aggiungerlo qui.

137
00:12:01,140 --> 00:12:03,190
Ora possiamo rimuovere questo allora,

138
00:12:03,190 --> 00:12:11,070
perché questo allora non è necessario per noi e questa è la chiusura del registro utente.

139
00:12:11,070 --> 00:12:12,990
Nella parte altra,

140
00:12:12,990 --> 00:12:16,810
faremo passaporto autenticare locale.

141
00:12:16,970 --> 00:12:19,510
Guarda la sintassi qui.

142
00:12:19,510 --> 00:12:23,425
Quindi questo è passaporto autenticare locale e quindi seguendo che,

143
00:12:23,425 --> 00:12:29,325
dobbiamo chiamare questa funzione qui che i parametri req,

144
00:12:29,325 --> 00:12:35,245
res e che il terzo è una funzione di callback qui.

145
00:12:35,245 --> 00:12:42,275
Quindi questo è il modo in cui questo è implementato perché passaporto si aspetta che tu lo faccia in questo modo.

146
00:12:42,275 --> 00:12:46,495
Qui, imposteremo req res codice di stato è 200,

147
00:12:46,495 --> 00:12:49,930
impostare intestazione contenuto applicazione json e poi ci

148
00:12:49,930 --> 00:12:59,410
res registrazione di stato json successo e non passeremo il valore utente qui.

149
00:12:59,410 --> 00:13:03,240
Invece, quello che farò è

150
00:13:03,240 --> 00:13:10,695
impostare una bandiera chiamata successo qui a true qui.

151
00:13:10,695 --> 00:13:15,620
Ora in questo modo, dal lato client quando questo json viene ricevuto,

152
00:13:15,620 --> 00:13:20,550
il client può semplicemente estrarre la proprietà di successo e quindi verificare se è vero

153
00:13:20,550 --> 00:13:25,695
o meno per verificare rapidamente se la registrazione ha avuto successo o meno.

154
00:13:25,695 --> 00:13:32,000
Quindi questo è il modo in cui gestiremo il processo di registrazione degli utenti qui.

155
00:13:32,000 --> 00:13:35,470
Quindi nota come il codice si è notevolmente semplificato.

156
00:13:35,470 --> 00:13:38,924
Se l'utente non si è registrato correttamente

157
00:13:38,924 --> 00:13:45,665
, questo invierà un errore in modo appropriato e anche l'autenticazione fallirà.

158
00:13:45,665 --> 00:13:51,115
Quindi entrambi i casi, capirai la situazione quando l'autenticazione dell'utente fallisce.

159
00:13:51,115 --> 00:13:56,270
Ora, anche il processo di login stesso viene notevolmente semplificato.

160
00:13:56,270 --> 00:14:01,650
Quindi, non abbiamo bisogno di fare tutto questo nel percorso di accesso qui.

161
00:14:01,650 --> 00:14:07,220
Quindi ho intenzione di rimuovere tutto questo codice e questo percorso di accesso diventa semplificato qui.

162
00:14:07,220 --> 00:14:14,365
Ora per il percorso di accesso- per il post router quando lo facciamo qui,

163
00:14:14,365 --> 00:14:19,150
anche qui ci aspettiamo che il nome utente e la password siano inclusi

164
00:14:19,150 --> 00:14:24,240
nel corpo del messaggio post che sta arrivando lei.

165
00:14:24,240 --> 00:14:32,030
A differenza del caso precedente in cui lo includevamo nell'intestazione di autorizzazione,

166
00:14:32,030 --> 00:14:37,865
qui ci aspettiamo che questo sia incluso nel corpo del messaggio post in arrivo.

167
00:14:37,865 --> 00:14:47,730
Quindi, per autenticare, diremo semplicemente l'autenticazione del passaporto e diremo locale qui.

168
00:14:47,730 --> 00:14:52,320
Quindi questa sarà la seconda chiamata qui.

169
00:14:52,320 --> 00:14:55,360
Quindi questo è il secondo middleware qui che stiamo per tagliare.

170
00:14:55,360 --> 00:15:01,690
Quindi, quando il post del router arriva sull'endpoint di accesso,

171
00:15:01,690 --> 00:15:06,095
chiameremo prima il passaporto autenticare locale.

172
00:15:06,095 --> 00:15:09,660
Se questo ha successo, questo entrerà

173
00:15:09,660 --> 00:15:13,485
e verrà eseguita la funzione successiva che segue.

174
00:15:13,485 --> 00:15:15,760
Se si verifica un errore nell'autenticazione,

175
00:15:15,760 --> 00:15:18,850
questo passaporto autenticare locale

176
00:15:18,850 --> 00:15:24,210
invierà automaticamente una risposta al client circa l'errore dell'autenticazione.

177
00:15:24,210 --> 00:15:26,190
Quindi questo è già preso cura di.

178
00:15:26,190 --> 00:15:33,345
Quindi nota come il codice nel processo di login viene notevolmente semplificato.

179
00:15:33,345 --> 00:15:36,565
Quindi, se questo va avanti con successo,

180
00:15:36,565 --> 00:15:42,775
ho solo bisogno di controllare la req e res e qui quello che

181
00:15:42,775 --> 00:15:49,665
farò è semplicemente inviare un messaggio al lato client con queste informazioni qui dentro.

182
00:15:49,665 --> 00:15:53,775
Diciamo res codice di stato 200,

183
00:15:53,775 --> 00:16:02,145
res set intestazione tipo di contenuto applicazione json e res json successo vero stato.

184
00:16:02,145 --> 00:16:13,010
Diciamo che hai effettuato l'accesso con successo.

185
00:16:13,010 --> 00:16:18,100
Questo è tutto. Questa è la modifica che faremo al file users.js.

186
00:16:18,100 --> 00:16:21,275
Quindi nota come, a causa del passaporto utente,

187
00:16:21,275 --> 00:16:24,655
sia il processo di registrazione che il processo di login,

188
00:16:24,655 --> 00:16:28,205
il codice si è notevolmente semplificato in questo caso.

189
00:16:28,205 --> 00:16:34,465
Ora passeremo ad aggiornare il file app.js andando a app.js ora.

190
00:16:34,465 --> 00:16:37,555
In app.js proprio qui

191
00:16:37,555 --> 00:16:50,540
inseriremo il passaporto.

192
00:16:51,270 --> 00:16:55,310
Quindi, importeremo

193
00:16:59,820 --> 00:17:07,120
il modulo di autenticazione che abbiamo appena implementato.

194
00:17:07,120 --> 00:17:15,390
Diremo var authenticate e nel file app.js qui sotto dopo la sessione,

195
00:17:15,390 --> 00:17:25,320
aggiungiamo app.use (passport.initialize)

196
00:17:25,320 --> 00:17:32,100
e app.use (.session).

197
00:17:32,950 --> 00:17:37,810
Se l'utente è connesso,

198
00:17:37,810 --> 00:17:42,945
allora ciò che accade è che quando la sessione viene avviata di nuovo,

199
00:17:42,945 --> 00:17:47,095
si ricorda che quando si accede qui,

200
00:17:47,095 --> 00:17:48,735
si accede qui,

201
00:17:48,735 --> 00:17:51,705
e una chiamata al passaporto autenticare locale,

202
00:17:51,705 --> 00:17:53,730
quando questo viene fatto nella fase di login,

203
00:17:53,730 --> 00:17:56,460
il passaporto autenticare locale

204
00:17:56,460 --> 00:18:00,625
aggiunge automaticamente la proprietà utente al messaggio di richiesta.

205
00:18:00,625 --> 00:18:03,415
Quindi, aggiungerà req.user e poi,

206
00:18:03,415 --> 00:18:07,265
la sessione di passaporto che abbiamo fatto qui

207
00:18:07,265 --> 00:18:12,575
serializzerà automaticamente le informazioni dell'utente e quindi memorizzarlo nella sessione.

208
00:18:12,575 --> 00:18:15,925
Quindi, e successivamente, ogni volta che

209
00:18:15,925 --> 00:18:19,135
una richiesta in arrivo arriva dal lato client

210
00:18:19,135 --> 00:18:22,630
con il cookie di sessione già in atto,

211
00:18:22,630 --> 00:18:29,250
questo caricherà automaticamente il req.user sulla richiesta in arrivo.

212
00:18:29,250 --> 00:18:32,735
Quindi, è così che viene organizzata la sessione del passaporto stessa.

213
00:18:32,735 --> 00:18:34,445
Quindi, una volta fatto questo,

214
00:18:34,445 --> 00:18:40,075
anche il nostro codice di autenticazione diventerà molto più semplice qui.

215
00:18:40,075 --> 00:18:42,400
Quindi, nel codice di autenticazione,

216
00:18:42,400 --> 00:18:49,450
diremo semplicemente, se req.user.

217
00:18:49,450 --> 00:18:55,690
Quindi, il req.user verrà caricato automaticamente dal middleware sessione passaporto,

218
00:18:55,690 --> 00:18:58,845
quindi diremo req.user.

219
00:18:58,845 --> 00:19:03,940
Se non req.user diremo var err, nuovo errore,

220
00:19:03,940 --> 00:19:09,495
non sei autenticato, e tutti questi messaggi qui.

221
00:19:09,495 --> 00:19:15,410
Altrimenti, vedi anche la parte else ora viene semplificata.

222
00:19:17,280 --> 00:19:20,010
Diremo altro.

223
00:19:20,010 --> 00:19:27,335
Quindi, il tuo codice di autenticazione diventa molto più semplice perché se req.user non è presente,

224
00:19:27,335 --> 00:19:31,695
significa che l'autenticazione non è stata eseguita correttamente, quindi

225
00:19:31,695 --> 00:19:33,345
è per questo che indichi l'errore.

226
00:19:33,345 --> 00:19:35,470
In caso contrario, si è autenticati.

227
00:19:35,470 --> 00:19:37,110
Se req.user è presente,

228
00:19:37,110 --> 00:19:39,900
significa che il passaporto ha eseguito l'autenticazione e l'utente

229
00:19:39,900 --> 00:19:42,970
req.user viene caricato sul messaggio di richiesta,

230
00:19:42,970 --> 00:19:46,410
e quindi puoi semplicemente andare più in basso.

231
00:19:46,410 --> 00:19:49,815
Quindi, questo è il cambiamento che dobbiamo fare a app.js.

232
00:19:49,815 --> 00:19:57,775
Salviamo tutte le modifiche e poi guardiamo l'applicazione in Postman.

233
00:19:57,775 --> 00:20:01,385
Una volta salvate tutte le modifiche, riavviare il server.

234
00:20:01,385 --> 00:20:02,600
Se il server è in esecuzione,

235
00:20:02,600 --> 00:20:04,700
arrestarlo e riavviare il server.

236
00:20:04,700 --> 00:20:07,680
Fammi avviare il mio server.

237
00:20:08,160 --> 00:20:10,450
Una volta che il server è attivo e funzionante,

238
00:20:10,450 --> 00:20:13,900
andiamo a Postman e fare un paio di richieste.

239
00:20:13,900 --> 00:20:17,650
Andando a Postman, lasciami ora provare a registrare un nuovo utente

240
00:20:17,650 --> 00:20:22,120
facendo un post sull'endpoint di registrazione degli utenti.

241
00:20:22,120 --> 00:20:28,485
Quando la registrazione viene pubblicata,

242
00:20:28,485 --> 00:20:31,850
si vede che nel corpo del messaggio di risposta dice,

243
00:20:31,850 --> 00:20:35,805
successo vero e registrazione stato riuscita.

244
00:20:35,805 --> 00:20:40,430
Quindi, l'utente è stato registrato con successo sul lato client.

245
00:20:40,430 --> 00:20:44,870
Quindi, ora, fammi fare un login dell'utente.

246
00:20:44,870 --> 00:20:50,000
Quindi, diremo «Accedi» e forniremo comunque

247
00:20:50,000 --> 00:20:55,765
il nome utente e la password nel corpo del messaggio qui.

248
00:20:55,765 --> 00:20:58,345
Quindi, quando clicco su «Invia»,

249
00:20:58,345 --> 00:21:05,050
noterai immediatamente che

250
00:21:05,050 --> 00:21:09,440
in basso, dice, successo, vero e stato, sei loggato e poi nell'intestazione stessa,

251
00:21:09,440 --> 00:21:13,515
vedrai un set-cookie in arrivo perché stiamo impostando la sessione,

252
00:21:13,515 --> 00:21:17,390
e poi vedi il cookie in atto lì.

253
00:21:17,390 --> 00:21:19,465
Quando si fa clic sui cookie,

254
00:21:19,465 --> 00:21:23,875
si vede l'ID di sessione proprio lì.

255
00:21:23,875 --> 00:21:26,980
Quindi, ora abbiamo effettuato l'accesso con successo.

256
00:21:26,980 --> 00:21:35,630
Inviamo una richiesta all'endpoint Get localhost: 3000 piatti.

257
00:21:35,630 --> 00:21:42,210
Si vede che la richiesta è stata inviata correttamente e quindi è stata inviata una risposta.

258
00:21:42,210 --> 00:21:43,350
Naturalmente, in questo momento,

259
00:21:43,350 --> 00:21:48,330
il mio database è vuoto, ecco perché invia un array vuoto

260
00:21:48,330 --> 00:21:54,530
dal sito del server quando chiedo localhost: 3000/piatti.

261
00:21:55,050 --> 00:21:58,165
Questo va benissimo.

262
00:21:58,165 --> 00:22:00,610
Permettetemi ora di disconnettere l'utente.

263
00:22:00,610 --> 00:22:02,995
Quindi, quando disconnetto l'utente, ora,

264
00:22:02,995 --> 00:22:10,450
noterai che l'utente è stato disconnesso e quando fai clic sui cookie,

265
00:22:10,450 --> 00:22:14,660
noterai che, quel cookie per localhost è già andato.

266
00:22:14,660 --> 00:22:19,245
Quindi, ora, se si tenta di fare un get sul localhost: piatti,

267
00:22:19,245 --> 00:22:24,910
si vede che la risposta dice,

268
00:22:24,910 --> 00:22:26,640
non si è autenticati.

269
00:22:26,640 --> 00:22:32,760
Accediamo ancora una volta facendo un post sul login degli utenti,

270
00:22:32,760 --> 00:22:36,290
e poi, si vede che possiamo accedere con successo a questo punto.

271
00:22:36,290 --> 00:22:37,830
Si nota anche che,

272
00:22:37,830 --> 00:22:40,075
che il nuovo cookie è stato impostato qui.

273
00:22:40,075 --> 00:22:44,480
Poi, se facciamo un get sul localhost: piatti qui,

274
00:22:44,480 --> 00:22:46,465
ora, questo avrà successo.

275
00:22:46,465 --> 00:22:51,624
Dal momento che stiamo usando mangusta locale come plugin mangusta,

276
00:22:51,624 --> 00:22:55,790
andiamo anche a controllare il nostro server MongoDB per vedere come

277
00:22:55,790 --> 00:23:00,410
le informazioni dell'utente sono effettivamente memorizzate nel nostro MongoDB.

278
00:23:00,410 --> 00:23:04,880
Quindi, nel tuo terminale,

279
00:23:04,880 --> 00:23:06,970
puoi aprire l'ondulazione Mongo,

280
00:23:06,970 --> 00:23:11,775
quindi diciamo Mongo al terminale e poi connetterti al nostro server MongoDB,

281
00:23:11,775 --> 00:23:16,500
e poi dire usa Confusione.

282
00:23:16,500 --> 00:23:26,285
Quindi diremo db.users.find () .pretty () e quindi stampare le informazioni dell'utente.

283
00:23:26,285 --> 00:23:31,180
Quindi, quando si stampano le informazioni dell'utente come si vede qui,

284
00:23:31,180 --> 00:23:35,235
c'è un utente che abbiamo registrato in precedenza.

285
00:23:35,235 --> 00:23:40,840
Quindi, vedrai che il record dell'utente contiene l'ID dell'oggetto e quindi,

286
00:23:40,840 --> 00:23:42,665
il nome utente qui sotto,

287
00:23:42,665 --> 00:23:46,060
e il flag admin che è falso e poi,

288
00:23:46,060 --> 00:23:53,720
nota anche che invece di memorizzare la password stessa ciò che

289
00:23:53,720 --> 00:23:57,515
fa il plugin mangusta locale Mongos è memorizza

290
00:23:57,515 --> 00:24:01,865
il suo valore salt qui e un valore hash qui.

291
00:24:01,865 --> 00:24:08,655
Ora, quello che fa il plugin di Mongo è che userà il sale come modo di

292
00:24:08,655 --> 00:24:15,990
crittografare la password e installare la password hash in questo campo hash qui.

293
00:24:15,990 --> 00:24:17,980
Quindi, quando si tenta di accedere,

294
00:24:17,980 --> 00:24:23,130
si applicherà la stessa trasformazione alla password in entrata

295
00:24:23,130 --> 00:24:27,330
e quindi si tenta di abbinarlo a questo valore hash memorizzato qui.

296
00:24:27,330 --> 00:24:29,580
Quindi, puoi vedere che nel database stesso,

297
00:24:29,580 --> 00:24:32,855
la password non viene memorizzata direttamente

298
00:24:32,855 --> 00:24:38,280
all'interno del valore hash della password che viene hash usando questa chiave salt qui,

299
00:24:38,280 --> 00:24:39,435
che vediamo qui,

300
00:24:39,435 --> 00:24:42,780
è memorizzata nel record lì.

301
00:24:42,780 --> 00:24:47,440
Quindi, questo è il modo in cui il plugin Mongoose locale del passaporto ci permette di

302
00:24:47,440 --> 00:24:53,905
memorizzare le informazioni dell'utente all'interno del nostro database.

303
00:24:53,905 --> 00:24:58,680
Con questa rapida comprensione di come passaporto, passport-local

304
00:24:58,680 --> 00:25:02,590
e Passport-Local-Mongoose ci aiutano a semplificare

305
00:25:02,590 --> 00:25:09,390
la strategia locale per nome utente e password nella nostra applicazione.

306
00:25:09,390 --> 00:25:11,660
Completiamo questo esercizio.

307
00:25:11,660 --> 00:25:18,390
Questo è un buon momento per fare un commit Git con il passaporto del messaggio.