1
00:00:03,710 --> 00:00:10,135
Questa è la seconda parte dell'Esercizio Express Sessions.

2
00:00:10,135 --> 00:00:12,320
Abbiamo completato la prima parte in precedenza,

3
00:00:12,320 --> 00:00:15,310
dove abbiamo aggiunto il supporto per Express Sessions,

4
00:00:15,310 --> 00:00:20,340
e utilizzare Express Sessions come un modo per monitorare gli utenti sul lato server

5
00:00:20,340 --> 00:00:24,160
e riconoscere le richieste in arrivo dagli utenti.

6
00:00:24,160 --> 00:00:30,930
In questo esercizio, non ci stiamo concentrando così tanto sulle sessioni Express,

7
00:00:30,930 --> 00:00:36,605
ma vedremo un modo per estendere il nostro server API REST express per supportare

8
00:00:36,605 --> 00:00:42,435
un nuovo modello per la registrazione e l'autenticazione degli utenti.

9
00:00:42,435 --> 00:00:48,635
Quindi, introdurremo un nuovo modello utente e schema nella nostra applicazione.

10
00:00:48,635 --> 00:00:52,295
Abbiamo già il percorso degli utenti slash che

11
00:00:52,295 --> 00:00:57,290
il generatore espresso ha già montato il router di un utente.

12
00:00:57,290 --> 00:01:00,035
Quindi, abbiamo intenzione di sfruttare questo e quindi aggiornarlo

13
00:01:00,035 --> 00:01:03,205
per supportare la registrazione di nuovi utenti,

14
00:01:03,205 --> 00:01:05,390
l'autenticazione di un utente esistente,

15
00:01:05,390 --> 00:01:11,695
e anche la disconnessione di un utente dal nostro sito server.

16
00:01:11,695 --> 00:01:17,915
Quindi, esamineremo Express Sessions come un modo per monitorare gli utenti una volta che l'utente accede,

17
00:01:17,915 --> 00:01:19,820
e quindi quando l'utente si disconnette,

18
00:01:19,820 --> 00:01:22,680
la sessione verrà rimossa dal sistema.

19
00:01:22,680 --> 00:01:27,480
Quindi, come facciamo a fare questa estensione in questo esercizio?

20
00:01:27,480 --> 00:01:29,700
Andiamo a scoprirlo.

21
00:01:29,800 --> 00:01:35,485
Continuando con il nostro server API REST espresso,

22
00:01:35,485 --> 00:01:41,835
andiamo ora nei modelli e aggiungere un nuovo file chiamato user.js.

23
00:01:41,835 --> 00:01:46,440
Questo è il file in cui creeremo lo schema utente e il modello.

24
00:01:46,440 --> 00:01:51,405
Verrà creato uno schema utente semplice che tiene traccia del nome utente e della password

25
00:01:51,405 --> 00:01:55,520
e anche un flag impostato per indicare

26
00:01:55,520 --> 00:01:59,540
se l'utente è un amministratore o un utente normale.

27
00:01:59,540 --> 00:02:03,660
Quindi, questo è un modo per distinguere tra diversi tipi di utenti.

28
00:02:03,660 --> 00:02:07,210
Quindi, in questo file,

29
00:02:07,210 --> 00:02:16,510
cerchiamo prima di richiedere Mongoose perché stiamo creando uno schema Mongoose,

30
00:02:16,510 --> 00:02:26,710
e poi creeremo uno schema denominato Schema Mongoose,

31
00:02:26,710 --> 00:02:29,720
e poi diremo utente var.

32
00:02:29,720 --> 00:02:32,870
Quindi questo è lo schema utente che stiamo per creare,

33
00:02:32,870 --> 00:02:38,150
e diremo nuovo schema utente.

34
00:02:38,150 --> 00:02:42,740
Lo schema utente sarà definito come ho appena detto,

35
00:02:42,740 --> 00:02:47,705
con tre campi qui chiamati username

36
00:02:47,705 --> 00:02:55,755
che ovviamente sarebbe della stringa di tipo,

37
00:02:55,755 --> 00:02:59,290
e questo è un campo obbligatorio,

38
00:02:59,290 --> 00:03:03,975
e questo è un campo univoco.

39
00:03:03,975 --> 00:03:07,580
Non si desidera che due utenti con lo stesso nome utente nel sistema,

40
00:03:07,580 --> 00:03:12,810
quindi creiamo il nome utente e quindi il secondo campo è campo password.

41
00:03:12,810 --> 00:03:15,259
Ora, naturalmente, è possibile estendere

42
00:03:15,259 --> 00:03:19,820
questo schema utente per consentire all'utente di monitorare l'intero profilo,

43
00:03:19,820 --> 00:03:23,985
ma lo faremo in uno degli esercizi successivi, per il momento,

44
00:03:23,985 --> 00:03:30,604
un utente viene riconosciuto all'interno del sistema semplicemente dal nome utente e dalla password.

45
00:03:30,604 --> 00:03:36,290
Quindi, la password è della stringa di tipo e quindi è richiesta.

46
00:03:37,300 --> 00:03:44,320
Il terzo campo che userò è chiamato admin.

47
00:03:44,320 --> 00:03:48,025
Quindi l'amministratore è del tipo booleano,

48
00:03:48,025 --> 00:03:58,270
e diremo default false.

49
00:03:58,270 --> 00:04:02,905
Quindi, per impostazione predefinita, quando viene creato

50
00:04:02,905 --> 00:04:04,830
un utente, viene creato un nuovo utente,

51
00:04:04,830 --> 00:04:06,855
il flag di amministratore sarà impostato su false. È

52
00:04:06,855 --> 00:04:09,925
possibile impostarlo esplicitamente su true dall'interno

53
00:04:09,925 --> 00:04:14,605
del codice per contrassegnare un utente come utente amministrativo.

54
00:04:14,605 --> 00:04:18,460
Forse è possibile fornire privilegi aggiuntivi a un utente amministrativo

55
00:04:18,460 --> 00:04:21,230
o, forse, consentire all'utente amministratore di eseguire

56
00:04:21,230 --> 00:04:24,810
determinate operazioni che gli utenti normali non lo farebbero.

57
00:04:24,810 --> 00:04:27,760
Vedremo che in uno degli esercizi successivi,

58
00:04:27,760 --> 00:04:31,500
per il momento, questo è lo schema utente che abbiamo creato,

59
00:04:31,500 --> 00:04:38,150
creiamo un modulo da questo ed esportiamo da

60
00:04:38,150 --> 00:04:47,075
questo modulo un modello Mangusta del nome utente.

61
00:04:47,075 --> 00:04:51,115
Quindi, questo è il modello Mongoose e lo schema è

62
00:04:51,115 --> 00:04:55,840
lo schema utente che abbiamo appena definito un po 'prima.

63
00:04:55,840 --> 00:05:00,615
Quindi, questo è il modo in cui definiamo il nostro schema utente.

64
00:05:00,615 --> 00:05:03,770
Quindi, ora che abbiamo definito il nostro schema utente,

65
00:05:03,770 --> 00:05:08,660
andiamo nel router che è già stato impostato

66
00:05:08,660 --> 00:05:15,610
dal generatore express quando genera questa applicazione express.

67
00:05:15,610 --> 00:05:17,775
Quindi, se vai nella cartella route,

68
00:05:17,775 --> 00:05:20,890
vedrai questo file chiamato users.js.

69
00:05:20,890 --> 00:05:26,780
Quindi, questo file users.js verrà esteso per creare il router.

70
00:05:26,780 --> 00:05:36,720
Quindi, proprio lì quello che ho intenzione di fare è importare corpo-parser,

71
00:05:41,510 --> 00:05:46,395
e poi dichiareranno il router espresso,

72
00:05:46,395 --> 00:05:50,145
e poi diremo anche importare

73
00:05:50,145 --> 00:05:57,100
lo schema utente e il

74
00:05:57,100 --> 00:06:03,420
modello da modelli utente,

75
00:06:03,950 --> 00:06:09,220
e poi per il router espresso diremo,

76
00:06:09,220 --> 00:06:13,380
router usa body parser.

77
00:06:16,190 --> 00:06:20,690
Quindi, ora che abbiamo dichiarato il parser corpo lì dentro,

78
00:06:20,690 --> 00:06:23,650
stiamo andando a lasciare questa parte come tale, in

79
00:06:23,650 --> 00:06:28,040
seguito lo modificheremo per consentire

80
00:06:28,040 --> 00:06:30,470
all'amministratore di essere in grado di recuperare

81
00:06:30,470 --> 00:06:33,750
tutti gli utenti che sono registrati nel sistema, ma per il momento,

82
00:06:33,750 --> 00:06:37,705
stiamo andando a lasciare quel percorso in quanto tale.

83
00:06:37,705 --> 00:06:40,500
Aggiungeremo qualche altro percorso qui,

84
00:06:40,500 --> 00:06:42,965
quindi diremo, «Router post».

85
00:06:42,965 --> 00:06:49,970
Quindi supporteremo l'operazione di post su un percorso chiamato registrazione e, come ci si aspetta,

86
00:06:49,970 --> 00:06:55,790
questo percorso di registrazione permetterà a un utente di

87
00:06:55,790 --> 00:07:04,920
registrarsi sul sistema, quindi questo supporterà la registrazione dell'utente.

88
00:07:04,920 --> 00:07:08,355
Quindi diremo: «Rec, res, il prossimo.»

89
00:07:08,355 --> 00:07:16,090
E così questo sarebbe il post di registrazione del router,

90
00:07:16,590 --> 00:07:23,410
i metodi rimanenti non saranno consentiti sulla parte finale della registrazione.

91
00:07:23,410 --> 00:07:25,865
Quindi, per accedere a questo,

92
00:07:25,865 --> 00:07:31,420
dal momento che questo router utenti è montato su utenti barra,

93
00:07:31,420 --> 00:07:35,645
vorremmo specificare questo endpoint come barra utenti slash registrazione,

94
00:07:35,645 --> 00:07:41,765
e questo è il punto finale che verrà utilizzato per registrare nuovi utenti all'interno del sistema.

95
00:07:41,765 --> 00:07:45,080
Quindi, la prima cosa che faremo è usare

96
00:07:45,080 --> 00:07:53,300
il metodo utente e l'aspettativa è che per un utente si iscriva,

97
00:07:53,300 --> 00:07:58,145
il nome utente e la password saranno forniti come una stringa JSON

98
00:07:58,145 --> 00:08:03,185
all'interno del corpo della richiesta di post in arrivo.

99
00:08:03,185 --> 00:08:05,160
Quindi, dal corpo,

100
00:08:05,160 --> 00:08:09,200
dal momento che il corpo sarebbe già stato analizzato dal parser del corpo,

101
00:08:09,200 --> 00:08:10,370
quindi dal corpo,

102
00:08:10,370 --> 00:08:13,920
controllerà prima per assicurarsi che

103
00:08:13,920 --> 00:08:22,130
l'utente con quel nome utente non esista all'interno del sistema.

104
00:08:22,130 --> 00:08:24,380
Se l'utente con quel nome utente esiste,

105
00:08:24,380 --> 00:08:26,900
si sta tentando di registrare un utente duplicato

106
00:08:26,900 --> 00:08:29,715
e questo non dovrebbe essere consentito nel sistema.

107
00:08:29,715 --> 00:08:37,340
Quindi, diremo, «Gli utenti ne trovano uno», e poi cercheremo di trovare se

108
00:08:37,340 --> 00:08:41,090
c'è un utente con il nome utente che è stato

109
00:08:41,090 --> 00:08:45,405
selezionato dal client che sta cercando di registrare un nuovo utente.

110
00:08:45,405 --> 00:08:47,020
Se l'utente esiste già

111
00:08:47,020 --> 00:08:51,850
, ovviamente non permetterai al nuovo utente di registrarsi con lo stesso nome utente.

112
00:08:51,850 --> 00:08:55,665
Quindi, diremo, «Allora utente».

113
00:08:55,665 --> 00:09:03,295
Quindi, questo restituirà l'utente qui e all'interno di questo campo utente,

114
00:09:03,295 --> 00:09:09,080
quindi controlleremo se l'utente esiste già,

115
00:09:09,080 --> 00:09:12,350
e quindi mi permetta di rilevare l'errore qui.

116
00:09:12,350 --> 00:09:19,140
Quindi diremo, «Catch error», e poi, «next error».

117
00:09:19,140 --> 00:09:26,160
Quindi, lo passeremo al gestore degli errori lì.

118
00:09:26,160 --> 00:09:33,345
Quindi, se questa ricerca per l'utente restituisce il campo utente,

119
00:09:33,345 --> 00:09:40,460
se l'utente non è uguale a null.

120
00:09:40,460 --> 00:09:45,170
Quindi, se l'utente restituito da questa ricerca

121
00:09:45,170 --> 00:09:50,510
non è nullo, significa che l'utente con quel nome utente esiste già,

122
00:09:50,510 --> 00:09:53,420
quindi non dovresti consentire una registrazione duplicata.

123
00:09:53,420 --> 00:09:58,765
Quindi diremo, «Var err nuovo errore.»

124
00:09:58,765 --> 00:10:09,075
E diremo, «User req. body username.»

125
00:10:09,075 --> 00:10:15,410
Esiste già. Quindi, fondamentalmente,

126
00:10:15,410 --> 00:10:20,565
stai impedendo a un utente duplicato di registrarsi e quindi diremo

127
00:10:20,565 --> 00:10:29,280
err.status 403 rispetto al proibito e quindi esci,

128
00:10:29,280 --> 00:10:33,735
chiamando il gestore degli errori, prossimo err.

129
00:10:33,735 --> 00:10:36,880
Altrimenti, questo significa che l'utente non esiste,

130
00:10:36,880 --> 00:10:39,670
quindi dovresti consentire all'utente di essere disconnesso.

131
00:10:39,670 --> 00:10:41,950
Quindi, nella parte altrimenti,

132
00:10:41,950 --> 00:10:46,150
diremo, restituisce user.create ().

133
00:10:47,200 --> 00:10:56,165
Creeremo un nuovo utente con il nome utente impostato su req.body.username,

134
00:10:56,165 --> 00:11:02,555
e poi lasciatemi mettere questo nella riga successiva in modo che sia più chiaro per voi,

135
00:11:02,555 --> 00:11:09,620
e diremo password: req.body.password.

136
00:11:09,620 --> 00:11:14,550
Ora, sappiamo già che il flag admin per impostazione predefinita sarà impostato su false,

137
00:11:14,550 --> 00:11:17,700
quindi lo lasceremo come tale,

138
00:11:17,730 --> 00:11:28,175
e questo permetterà al nostro nuovo utente di essere registrato e quando il nuovo utente è iscritto,

139
00:11:28,175 --> 00:11:37,880
questo restituirà una promessa e all'interno del «allora» gestiremo questa promessa qui.

140
00:11:37,880 --> 00:11:41,460
Quindi, questo restituirà la promessa da

141
00:11:41,460 --> 00:11:45,625
questo «allora» e poi la gestiremo nel prossimo «allora» qui.

142
00:11:45,625 --> 00:12:02,120
Dirà quindi, res.statusCode è 200,

143
00:12:02,120 --> 00:12:10,640
Res.SetHeader e diremo Content-type application/json

144
00:12:19,830 --> 00:12:38,000
e diremo, res.json (status: Registrazione riuscita),

145
00:12:42,960 --> 00:12:45,760
e se vuoi,

146
00:12:45,760 --> 00:12:49,659
possiamo caricare l'utente in

147
00:12:49,659 --> 00:12:58,270
questo messaggio di risposta qui come proprietà nel json.

148
00:13:02,790 --> 00:13:06,890
Dirà Registrazione riuscita.

149
00:13:07,830 --> 00:13:14,950
Quindi se c'è un errore in

150
00:13:14,950 --> 00:13:22,790
questa operazione dirà «prossimo errore».

151
00:13:22,790 --> 00:13:25,200
Quindi gestirà l'errore.

152
00:13:25,440 --> 00:13:29,220
Se la promessa non si risolve correttamente,

153
00:13:29,220 --> 00:13:32,020
verrà gestita da questo. Quindi questo è tutto.

154
00:13:32,020 --> 00:13:36,150
Quindi qui, abbiamo un modo per l'utente di registrarsi.

155
00:13:36,150 --> 00:13:38,280
Quindi, affinché l'utente si iscriva,

156
00:13:38,280 --> 00:13:46,570
l'utente farà un post su/users/signup e nel corpo del messaggio,

157
00:13:46,570 --> 00:13:51,810
il client includerà una stringa json

158
00:13:51,810 --> 00:13:57,760
con proprietà username e password in quella stringa json.

159
00:13:57,760 --> 00:14:01,200
Ecco come ti iscrivi per un nuovo utente.

160
00:14:01,200 --> 00:14:06,135
Ora, vediamo come accederemo l'utente.

161
00:14:06,135 --> 00:14:14,605
Ora, useremo ancora le sessioni Express che abbiamo fatto in precedenza per tenere traccia dell'utente.

162
00:14:14,605 --> 00:14:24,270
Quindi, per registrare un utente dirà «router.post» sul punto finale/login.

163
00:14:24,820 --> 00:14:29,370
Quindi sull'endpoint /login,

164
00:14:32,280 --> 00:14:35,800
faremo un router.post.

165
00:14:35,800 --> 00:14:42,460
Ovviamente invece di dire funzione,

166
00:14:42,460 --> 00:14:48,575
è possibile utilizzare la funzione freccia qui per il router.post,

167
00:14:48,575 --> 00:14:50,780
ho intenzione di fare la stessa cosa qui.

168
00:14:50,780 --> 00:14:53,930
Mi sono appassionato alle funzioni delle frecce.

169
00:14:53,930 --> 00:14:57,125
Quindi, faremo una funzione freccia qui.

170
00:14:57,125 --> 00:15:00,080
Quindi, per il login, come procede il login?

171
00:15:00,080 --> 00:15:01,880
Quindi, per il login,

172
00:15:01,880 --> 00:15:10,850
quello che faremo è che andremo al file app.js e poi all'interno di questa autenticazione,

173
00:15:11,760 --> 00:15:17,050
stavamo facendo quella registrazione per l'utente lì.

174
00:15:17,050 --> 00:15:20,315
Quindi, quello che faro' e' copiare

175
00:15:20,315 --> 00:15:25,730
tutta questa faccenda, perche' comunque non farei tutto questo.

176
00:15:25,730 --> 00:15:32,970
Quindi, piuttosto lasciami copiare tutto il percorso da questo punto in poi fino a req.session.user.

177
00:15:32,970 --> 00:15:36,925
Quindi, la parte if di req.session.user ho intenzione di copiare,

178
00:15:36,925 --> 00:15:44,120
e poi venire a users.js e per il login.

179
00:15:44,120 --> 00:15:47,305
È esattamente come farò l'autenticazione.

180
00:15:47,305 --> 00:15:51,025
Quindi diremo se non req.session.user.

181
00:15:51,025 --> 00:15:55,965
Ciò significa che l'utente non si è ancora autenticato.

182
00:15:55,965 --> 00:15:59,420
Quindi, si prevede l'autenticazione di base come

183
00:15:59,420 --> 00:16:02,780
meccanismo per l'utente da utilizzare per l'autenticazione.

184
00:16:02,780 --> 00:16:07,890
Quindi diremo var authHeader se! AuthHeader quindi solleveremo l'errore,

185
00:16:07,890 --> 00:16:17,760
altrimenti recupereremo il nome utente e la password dall'intestazione.

186
00:16:17,760 --> 00:16:25,235
Ora, qui stavamo facendo se il nome utente è uguale a admin e la password è uguale alla password.

187
00:16:25,235 --> 00:16:30,535
Ma ora, quello che faremo è che stiamo andando a cercare

188
00:16:30,535 --> 00:16:36,695
nel database per vedere se quel particolare utente esiste.

189
00:16:36,695 --> 00:16:39,595
Quindi, invece di farlo qui,

190
00:16:39,595 --> 00:16:42,995
invece di farlo se username e password,

191
00:16:42,995 --> 00:16:48,380
diremo, user.findone

192
00:16:49,650 --> 00:16:56,020
e diremo username è username.

193
00:16:56,020 --> 00:17:00,730
Quindi questa proprietà è uguale a questo nome utente che abbiamo appena recuperato

194
00:17:00,730 --> 00:17:06,820
e poi diremo poi utente.

195
00:17:09,770 --> 00:17:18,600
Quindi dentro questo «allora».

196
00:17:18,600 --> 00:17:23,110
Quindi ho intenzione di spostare questo codice all'interno di questo «allora» perché

197
00:17:23,110 --> 00:17:28,395
ora quello che ho intenzione di controllare è ora che ho recuperato l'utente,

198
00:17:28,395 --> 00:17:35,625
ho bisogno di controllare per assicurarmi che questo utente sia esattamente quello che sto cercando.

199
00:17:35,625 --> 00:17:37,405
Quindi, a questo punto,

200
00:17:37,405 --> 00:17:42,485
ci accingiamo prima a verificare che l'utente non sia nullo.

201
00:17:42,485 --> 00:17:49,915
Quindi diremo se l'utente è nullo.

202
00:17:49,915 --> 00:17:51,390
Quindi, se l'utente è nullo, il

203
00:17:51,390 --> 00:17:55,930
che significa che non siamo riusciti a trovare un utente con quel particolare nome utente.

204
00:17:55,930 --> 00:17:59,860
Quindi, dovrai restituire un errore qui.

205
00:17:59,860 --> 00:18:04,540
Quindi lasciami copiare questa parte e poi incollarla

206
00:18:04,540 --> 00:18:09,840
qui e poi torneremo dicendo var nuovo errore

207
00:18:09,840 --> 00:18:14,575
e diremo che il nome

208
00:18:14,575 --> 00:18:23,120
utente spazio utente

209
00:18:23,580 --> 00:18:28,750
non esiste.

210
00:18:28,750 --> 00:18:30,600
Quindi in questo caso,

211
00:18:30,600 --> 00:18:35,230
questo utente non esiste, quindi rimuoverò questa parte e

212
00:18:35,230 --> 00:18:41,840
quindi lo stato di errore corrispondente sarebbe 403 qui.

213
00:18:42,450 --> 00:18:44,960
Quindi questa è la prima parte.

214
00:18:44,960 --> 00:18:55,000
Se l'utente è nullo allora stiamo ovviamente andando a dire che l'utente non esiste.

215
00:18:55,000 --> 00:19:03,780
La seconda parte che stiamo andando a controllare è Else se password utente.

216
00:19:03,780 --> 00:19:06,800
Quindi il che significa che l'utente esiste a questo punto.

217
00:19:06,800 --> 00:19:12,420
Quindi, il secondo controllo che faremo è che la password dell'utente non è

218
00:19:12,420 --> 00:19:22,330
uguale alla password allora.

219
00:19:22,330 --> 00:19:25,090
Abbiamo ancora bisogno di indicare l'errore lì.

220
00:19:25,090 --> 00:19:28,820
Quindi l'errore direbbe,

221
00:19:29,790 --> 00:19:34,570
in questo caso, diremo

222
00:19:34,570 --> 00:19:41,390
«la tua password non è corretta».

223
00:19:41,390 --> 00:19:44,085
Quindi questa è la seconda parte qui.

224
00:19:44,085 --> 00:19:49,650
Quindi la tua password non è corretta e poi l'ultima parte.

225
00:19:49,650 --> 00:19:52,515
Diremo «altro».

226
00:19:52,515 --> 00:19:59,755
Quindi lasciami indentare questo codice.

227
00:19:59,755 --> 00:20:05,775
Quindi se user.username

228
00:20:05,775 --> 00:20:15,815
è username che ovviamente dovrebbe essere vero in questo caso.

229
00:20:15,815 --> 00:20:17,990
Quindi la seconda parte,

230
00:20:17,990 --> 00:20:27,620
user.password è uguale alla password che ovviamente dovrebbe essere corretta a questo punto.

231
00:20:27,620 --> 00:20:29,720
Ma in ogni caso,

232
00:20:29,720 --> 00:20:38,885
ho intenzione di controllare questo problema qui e questo altro non si verificherà affatto in questo caso.

233
00:20:38,885 --> 00:20:41,695
Quindi, quando raggiungi questo punto,

234
00:20:41,695 --> 00:20:45,410
il nome utente dovrebbe essere

235
00:20:45,410 --> 00:20:48,980
lo stesso del nome utente e la password dovrebbe essere la stessa di una password,

236
00:20:48,980 --> 00:20:55,240
ma in ogni caso ho messo un doppio controllo a quel punto solo per essere doppiamente sicuro.

237
00:20:55,240 --> 00:20:56,590
Quindi in questo caso,

238
00:20:56,590 --> 00:21:02,765
diremo che req.session.user è autenticato.

239
00:21:02,765 --> 00:21:05,440
Quindi, imposteremo questo su autenticato

240
00:21:05,440 --> 00:21:16,480
e anche questo, diremo

241
00:21:16,480 --> 00:21:18,660
res.statusCode è 200.

242
00:21:18,660 --> 00:21:21,870
Quindi siamo stati in grado di autenticare con successo l'utente.

243
00:21:21,870 --> 00:21:29,030
Quindi, diremo res.statusCode è 200 e poi diremo res.setHeader

244
00:21:30,540 --> 00:21:43,690
Content-Type testo semplice e

245
00:21:43,690 --> 00:21:51,500
res.end semplicemente invieremo un messaggio dicendo «Sei autenticato».

246
00:21:53,700 --> 00:22:00,825
Questo è tutto. Quindi, questo copre la parte allora dell'utente findOn.

247
00:22:00,825 --> 00:22:05,360
Quindi prima, controlliamo che se l'utente è nullo,

248
00:22:05,360 --> 00:22:07,410
ciò significa che non siamo riusciti a trovare l'utente,

249
00:22:07,410 --> 00:22:12,025
quindi stiamo ovviamente restituendo un errore che dice che il nome utente non esiste.

250
00:22:12,025 --> 00:22:15,195
Se la password dell'utente non corrisponde alla password,

251
00:22:15,195 --> 00:22:16,450
quindi a questo punto,

252
00:22:16,450 --> 00:22:19,150
l'utente esiste ma la password non corrisponde, quindi diremo,

253
00:22:19,150 --> 00:22:22,640
«La password non è corretta», e poi, infine,

254
00:22:22,640 --> 00:22:29,050
raggiungiamo questo punto, quindi il nome utente e la password dovrebbero essere identificati correttamente.

255
00:22:29,330 --> 00:22:35,780
Anche se non ho bisogno di questo controllo, ma l'ho appena messo lì e poi a questo punto,

256
00:22:35,780 --> 00:22:38,680
imposterò req.session.user per

257
00:22:38,680 --> 00:22:41,830
autenticarlo e quindi impostare il codice di stato su 200, il che significa che sei stato

258
00:22:41,830 --> 00:22:48,880
in grado di autenticare l'utente e quindi puoi finire a quel punto.

259
00:22:48,880 --> 00:22:51,490
Poiché questo è un allora,

260
00:22:51,490 --> 00:22:54,685
inserirò una cattura a questo punto,

261
00:22:54,685 --> 00:23:03,845
quindi diremo errore catch e se si verifica l'errore,

262
00:23:03,845 --> 00:23:09,130
allora passerò semplicemente l'errore

263
00:23:09,130 --> 00:23:14,560
al successivo in modo

264
00:23:14,560 --> 00:23:20,090
che il gestore degli errori sia in grado di gestire l'errore in modo appropriato.

265
00:23:20,090 --> 00:23:24,415
In modo che finisca questo utente findONE.

266
00:23:24,415 --> 00:23:31,020
Ora, questo è il caso in cui req.session.user non è impostato.

267
00:23:31,020 --> 00:23:32,905
Se questo è già

268
00:23:32,905 --> 00:23:38,095
impostato, significa che l'utente è già connesso.

269
00:23:38,095 --> 00:23:40,630
Quindi, in questo caso,

270
00:23:40,630 --> 00:23:50,650
l'altra parte qui si occupa della situazione dicendo che imposteremo

271
00:23:50,650 --> 00:23:52,660
lo StatusCode su 200

272
00:23:52,660 --> 00:24:12,205
e il Content-Type su text/plain e poi diremo,

273
00:24:12,205 --> 00:24:17,680
«Sei già autenticato».

274
00:24:17,680 --> 00:24:21,910
Quindi, se raggiungi quest'altra parte,

275
00:24:22,690 --> 00:24:29,060
verresti qui perché req.session.user non è già nullo,

276
00:24:29,060 --> 00:24:32,150
quindi il che significa che l'utente è già stato autenticato,

277
00:24:32,150 --> 00:24:34,995
quindi significa che quando raggiungi questo punto,

278
00:24:34,995 --> 00:24:38,200
l'utente ha già effettuato l'accesso in precedenza,

279
00:24:38,200 --> 00:24:41,100
quindi non è necessario verificare.

280
00:24:41,100 --> 00:24:42,220
Quindi direte semplicemente

281
00:24:42,220 --> 00:24:46,270
«Sei già autenticato» e poi finisci a questo punto.

282
00:24:46,270 --> 00:24:54,975
Ok. Quindi ora, l'ultimo metodo che implementeremo è per disconnettere l'utente.

283
00:24:54,975 --> 00:24:59,180
Quindi, faremo un router.get su/logout.

284
00:24:59,180 --> 00:25:02,170
Vi starete chiedendo perché facciamo un get

285
00:25:02,170 --> 00:25:07,000
sul logout piuttosto che un post che abbiamo fatto sul login?

286
00:25:07,000 --> 00:25:11,090
Al login, è necessario inviare il nome utente e la password.

287
00:25:11,090 --> 00:25:14,900
Per il logout stai semplicemente disconnettendo te stesso dal sistema,

288
00:25:14,900 --> 00:25:17,590
quindi non è necessario fornire ulteriori informazioni perché

289
00:25:17,590 --> 00:25:20,910
il server ti sta già monitorando in base al

290
00:25:20,910 --> 00:25:30,665
tuo ID di sessione e all'interno di quel cookie di sessione qui.

291
00:25:30,665 --> 00:25:32,620
Quindi, è per questo che non abbiamo

292
00:25:32,620 --> 00:25:38,890
esplicitamente bisogno di inviare ulteriori informazioni nel corpo del messaggio.

293
00:25:38,890 --> 00:25:46,120
Quindi diremo se req.session in modo che significa che la sessione deve esistere

294
00:25:46,120 --> 00:25:50,070
, altrimenti si sta cercando di disconnettere un utente che non ha effettuato l'accesso.

295
00:25:50,070 --> 00:25:52,280
Quindi non ha senso.

296
00:25:52,280 --> 00:25:57,490
Ora, la sessione stessa fornisce questo metodo

297
00:25:57,490 --> 00:26:03,415
chiamato destroy e quando si chiama il metodo destroy,

298
00:26:03,415 --> 00:26:07,520
la sessione viene distrutta e le informazioni vengono rimosse

299
00:26:07,520 --> 00:26:12,945
dal lato server relativo a questa sessione.

300
00:26:12,945 --> 00:26:16,970
Quindi, il che significa che se il client tenta di inviare nuovamente

301
00:26:16,970 --> 00:26:19,190
le informazioni di sessione che sono memorizzate sotto forma

302
00:26:19,190 --> 00:26:21,430
di un cookie firmato sul lato client,

303
00:26:21,430 --> 00:26:22,640
ciò non sarà valido.

304
00:26:22,640 --> 00:26:27,870
Quindi abbiamo bisogno di un metodo per eliminare il cookie che viene memorizzato sul lato client.

305
00:26:27,870 --> 00:26:31,110
Ora, questa operazione rimuoverà

306
00:26:31,110 --> 00:26:36,805
le informazioni di sessione dal lato server in modo che la sessione non sia più valida.

307
00:26:36,805 --> 00:26:38,060
Quindi, a questo punto,

308
00:26:38,060 --> 00:26:45,115
diremo req.session.destroy e poi diremo, res.clearcookie.

309
00:26:45,115 --> 00:26:49,640
Quindi ClearCookie è un modo per chiedere al client di

310
00:26:49,640 --> 00:26:54,875
rimuovere il cookie e il nome del cookie è l'ID della sessione.

311
00:26:54,875 --> 00:26:56,630
Quindi, nell'esercizio precedente,

312
00:26:56,630 --> 00:27:00,910
abbiamo visto che il cookie è stato memorizzato con il nome dell'ID di sessione sul lato client.

313
00:27:00,910 --> 00:27:05,430
Quindi stiamo chiedendo al cliente di eliminare questo cookie

314
00:27:05,430 --> 00:27:10,935
dal lato client nel messaggio di risposta e poi diremo,

315
00:27:10,935 --> 00:27:16,835
res.redirect e lo reindirizzeremo alla homepage qui.

316
00:27:16,835 --> 00:27:21,540
Quindi, questo è un modo per reindirizzare l'utente per accedere alla loro pagina standard,

317
00:27:21,540 --> 00:27:24,790
quindi ad esempio, la homepage della tua applicazione.

318
00:27:24,790 --> 00:27:31,090
Quindi, questo è il modo in cui gestiresti il logout del sistema.

319
00:27:31,090 --> 00:27:33,200
Se la req.session non esiste,

320
00:27:33,200 --> 00:27:35,380
significa che non hai effettuato l'accesso,

321
00:27:35,380 --> 00:27:37,310
quindi dovremo generare un errore.

322
00:27:37,310 --> 00:27:38,945
Quindi diremo var err,

323
00:27:38,945 --> 00:27:46,370
nuovo errore, «Non sei connesso»,

324
00:27:47,100 --> 00:27:52,615
e imposteremo lo stato di errore su 403,

325
00:27:52,615 --> 00:27:54,760
questa è un'operazione proibita e

326
00:27:54,760 --> 00:28:01,060
quindi generare l'errore al gestore degli errori, il gioco è fatto.

327
00:28:01,060 --> 00:28:08,830
Così ora, si vede che abbiamo esteso il router dell'utente per supportare tre nuovi endpoint,

328
00:28:08,830 --> 00:28:13,330
l'endpoint di registrazione che consente a un utente di registrarsi,

329
00:28:13,330 --> 00:28:17,785
l'endpoint di login che consente a un utente registrato di accedere,

330
00:28:17,785 --> 00:28:24,730
e quindi l'endpoint di logout che consente a un utente connesso di disconnettersi dal sistema.

331
00:28:24,730 --> 00:28:26,970
Nel processo di disconnessione,

332
00:28:26,970 --> 00:28:29,340
stai distruggendo la sessione sul lato server,

333
00:28:29,340 --> 00:28:31,890
stai anche cancellando il cookie sul lato client, in

334
00:28:31,890 --> 00:28:40,350
modo che il client non possa essere utilizzato nella sessione scaduta per provare a contattare quel server.

335
00:28:40,350 --> 00:28:43,480
Una correzione minore in users.js,

336
00:28:43,480 --> 00:28:49,225
questo dovrebbe essere var User require.. /models/user,

337
00:28:49,225 --> 00:28:58,095
ricorda che il file users.js si trova nella cartella route e quindi

338
00:28:58,095 --> 00:29:01,130
il file user.js si trova

339
00:29:01,130 --> 00:29:07,440
nella cartella models che è su di un livello e quindi nella cartella models.

340
00:29:07,440 --> 00:29:11,620
Quindi, questo dovrebbe essere.. /models/user,

341
00:29:11,620 --> 00:29:15,655
quindi fai quella correzione minore, il gioco è fatto.

342
00:29:15,655 --> 00:29:19,040
Abbiamo modificato il file users.js,

343
00:29:19,040 --> 00:29:23,690
ora l'ultima cosa che dobbiamo fare è andare a riparare il file app.js.

344
00:29:23,690 --> 00:29:25,965
Nel file app.js dell'app,

345
00:29:25,965 --> 00:29:29,520
se si naviga nel file app.js,

346
00:29:29,520 --> 00:29:31,160
si vedrebbe che abbiamo

347
00:29:31,160 --> 00:29:37,240
questo indice barra qui e gli utenti barra qui dopo l'autenticazione.

348
00:29:37,240 --> 00:29:43,360
Ora, questo non funzionerà per noi perché se hai bisogno di registrarti,

349
00:29:43,360 --> 00:29:49,140
allora l'utente dovrebbe registrarsi e accedere prima che l'autorizzazione sia confermata,

350
00:29:49,140 --> 00:29:54,910
comunque se l'iscrizione e l'accesso è per il processo di registrazione,

351
00:29:54,910 --> 00:30:04,295
quindi ho intenzione di spostarli su prima della fase di autenticazione qui.

352
00:30:04,295 --> 00:30:09,280
Quindi, lo sposteremo in questo posto.

353
00:30:09,280 --> 00:30:15,430
Quindi, un utente in arrivo può accedere

354
00:30:15,430 --> 00:30:21,589
al file di indice alla barra e anche accedere all'endpoint degli utenti senza essere autenticato,

355
00:30:21,589 --> 00:30:23,205
ma qualsiasi altro endpoint,

356
00:30:23,205 --> 00:30:25,400
l'utente deve essere autenticato,

357
00:30:25,400 --> 00:30:28,665
quindi questo è il modo in cui impostiamo questo.

358
00:30:28,665 --> 00:30:32,375
All' interno dell'autenticazione della funzione, diremo,

359
00:30:32,375 --> 00:30:40,695
«Se non req.session.user,» quindi notare che questo posto,

360
00:30:40,695 --> 00:30:47,980
non permetteremmo all'utente di entrare qui senza che l'utente abbia effettuato l'accesso.

361
00:30:47,980 --> 00:30:50,450
Quindi, se non req.session.user,

362
00:30:50,450 --> 00:30:55,170
allora diremo semplicemente che non sei autenticato.

363
00:31:03,600 --> 00:31:09,330
Questa autenticazione deve essere eseguita utilizzando il metodo di login qui.

364
00:31:09,330 --> 00:31:13,510
Quindi, ho intenzione di rimuovere tutta questa parte qui.

365
00:31:17,340 --> 00:31:22,285
Quindi, diremo, se non req.session.user,

366
00:31:22,285 --> 00:31:28,670
diremo che non sei autenticato e quindi dovremo inviare una foto tre qui,

367
00:31:28,670 --> 00:31:31,560
quindi il che significa che non dovresti mai scendere in questo punto

368
00:31:31,560 --> 00:31:34,785
senza che l'utente acceda.

369
00:31:34,785 --> 00:31:37,575
Quindi, diremo che non sei autenticato.

370
00:31:37,575 --> 00:31:41,990
Ricorda che devi autenticarti facendo un POST

371
00:31:41,990 --> 00:31:47,120
sul punto finale di accesso barra degli utenti.

372
00:31:47,120 --> 00:31:50,930
Quindi diremo che non sei autenticato, altrimenti,

373
00:31:50,930 --> 00:31:56,175
se req.session.user è uguale a,

374
00:31:56,175 --> 00:32:01,720
ricorda che nella funzione di login nel

375
00:32:01,720 --> 00:32:07,780
users.js abbiamo impostato l'utente della sessione successiva sulla stringa autenticata.

376
00:32:07,780 --> 00:32:10,055
Quindi, questo è quello che stiamo andando a controllare.

377
00:32:10,055 --> 00:32:14,355
Diciamo, se req.session.user è autenticato,

378
00:32:14,355 --> 00:32:21,955
diremo dopo, altrimenti non si è autenticati di nuovo.

379
00:32:21,955 --> 00:32:31,990
Poi invieremo un messaggio proibito. Questo è tutto.

380
00:32:31,990 --> 00:32:33,995
Quindi, con questo aggiornamento,

381
00:32:33,995 --> 00:32:36,375
anche il mio file app.js è pronto.

382
00:32:36,375 --> 00:32:38,590
Ora, dopo aver fatto questi aggiornamenti,

383
00:32:38,590 --> 00:32:42,470
andiamo a controllare come funziona la nostra applicazione ora.

384
00:32:42,470 --> 00:32:44,350
Andando al terminale,

385
00:32:44,350 --> 00:32:49,655
se il server è in esecuzione, interromperlo e quindi riavviare il server.

386
00:32:49,655 --> 00:32:51,600
Il mio server non è in esecuzione al momento,

387
00:32:51,600 --> 00:32:53,405
quindi dirò npm start

388
00:32:53,405 --> 00:32:56,440
e il mio server dovrebbe essere attivo e funzionante.

389
00:32:56,440 --> 00:33:00,540
Vediamo ora come accederemo al server.

390
00:33:00,540 --> 00:33:04,150
Andando a Postman, fammi fare un GET su

391
00:33:04,150 --> 00:33:07,290
localhost: 3000/piatti e poi vedrai immediatamente

392
00:33:07,290 --> 00:33:10,375
che si lamenta dicendo che non sei autenticato.

393
00:33:10,375 --> 00:33:13,095
Ovviamente, non sono autenticato qui.

394
00:33:13,095 --> 00:33:19,560
Permettetemi di provare ad accedere solo al localhost: 3000 e vedrete che,

395
00:33:19,560 --> 00:33:22,625
quella radice è disponibile per noi.

396
00:33:22,625 --> 00:33:29,850
Ora, naturalmente, vogliamo prima registrare un utente e quindi accedere

397
00:33:29,850 --> 00:33:37,745
come utente e poi ottenere l'accesso al resto degli endpoint API REST.

398
00:33:37,745 --> 00:33:40,480
Quindi, per prima cosa, fammi registrare un utente.

399
00:33:40,480 --> 00:33:41,925
Per registrare l'utente,

400
00:33:41,925 --> 00:33:51,410
ho bisogno di fare un POST per localhost: 3000/users/signup.

401
00:33:53,700 --> 00:33:57,710
Per questo messaggio POST,

402
00:33:57,930 --> 00:34:01,635
nel corpo del messaggio,

403
00:34:01,635 --> 00:34:07,860
ho bisogno di includere nel corpo

404
00:34:07,860 --> 00:34:15,080
del messaggio una stringa JSON con il nome utente.

405
00:34:15,080 --> 00:34:19,390
Quindi, lasciami accedere da

406
00:34:19,390 --> 00:34:27,770
solo e poi userò la password come password.

407
00:34:28,810 --> 00:34:31,835
Questa è una registrazione valida.

408
00:34:31,835 --> 00:34:35,505
Quindi, quando mi iscrivo come utente con

409
00:34:35,505 --> 00:34:42,150
queste informazioni sotto forma di una stringa JSON inclusa nel corpo del messaggio,

410
00:34:42,150 --> 00:34:47,590
fammi vedere che l'intestazione ora contiene l'applicazione di tipo di contenuto,

411
00:34:47,590 --> 00:34:50,440
JSON perché ho impostato il JSON nel corpo

412
00:34:50,440 --> 00:34:54,660
del messaggio e quindi inviare il POST alla registrazione.

413
00:34:54,660 --> 00:34:57,175
Quindi, quando invio il POST alla registrazione,

414
00:34:57,175 --> 00:35:02,460
vedi immediatamente cosa viene restituito dal server qui.

415
00:35:02,460 --> 00:35:05,630
Quindi, vedi che il server è tornato dicendo,

416
00:35:05,630 --> 00:35:10,205
«Registrazione riuscita» e se stesso,

417
00:35:10,205 --> 00:35:13,485
mi dà i dettagli dell'utente qui.

418
00:35:13,485 --> 00:35:19,340
Quindi, questo è un record che esiste nel mio MongoDB e

419
00:35:19,340 --> 00:35:25,090
nota che il tipo di modello è il tipo di modello utente che abbiamo impostato.

420
00:35:25,090 --> 00:35:28,300
Quindi, abbiamo il nome utente e la password e

421
00:35:28,300 --> 00:35:33,535
il flag di amministratore come puoi vedere è impostato su false per impostazione predefinita.

422
00:35:33,535 --> 00:35:37,285
Una volta registrato l'utente,

423
00:35:37,285 --> 00:35:40,370
questo utente è ora un utente valido.

424
00:35:40,370 --> 00:35:45,640
Quindi, fammi provare a POST di nuovo lo stesso utente e vedere cosa succede.

425
00:35:45,640 --> 00:35:48,935
Quindi, quando POSSO lo stesso utente ovviamente,

426
00:35:48,935 --> 00:35:50,385
lì dal lato server,

427
00:35:50,385 --> 00:35:52,840
risponde dicendo che questo utente esiste già.

428
00:35:52,840 --> 00:35:58,480
Quindi, puoi vedere che abbiamo impostato la nostra procedura di registrazione per non consentire all'

429
00:35:58,480 --> 00:36:04,580
utente di duplicare il registro con lo stesso ID utente.

430
00:36:04,580 --> 00:36:07,135
Ok. Quindi, questa e' la seconda parte.

431
00:36:07,135 --> 00:36:13,570
Ora, facciamo un login dell'utente.

432
00:36:13,570 --> 00:36:15,770
Per fare un login dell'utente,

433
00:36:15,770 --> 00:36:20,400
lasciami rimuovere il tipo di contenuto e quindi

434
00:36:20,400 --> 00:36:25,440
rimuoverò anche il corpo perché per il login, non è richiesto.

435
00:36:25,440 --> 00:36:28,200
Quindi, non inserisco nulla

436
00:36:28,200 --> 00:36:31,790
nell'intestazione e poi provo ad accedere e quando ho provato ad accedere,

437
00:36:31,790 --> 00:36:34,805
risponde dicendo che non sei autenticato.

438
00:36:34,805 --> 00:36:36,175
Non sei autorizzato.

439
00:36:36,175 --> 00:36:39,595
Ora, ho bisogno di registrarmi.

440
00:36:39,595 --> 00:36:42,940
Quindi, questo è dove posso usare l'autenticazione di base.

441
00:36:42,940 --> 00:36:46,240
Quindi, nell'autenticazione di base,

442
00:36:46,240 --> 00:36:51,170
sto solo andando a digitare il mio nome utente e

443
00:36:51,170 --> 00:36:56,575
password che ho appena registrato nel passaggio precedente e quindi aggiornare la mia richiesta,

444
00:36:56,575 --> 00:37:00,060
e quindi fare un POST sul login.

445
00:37:00,060 --> 00:37:02,400
Quindi, quando faccio un POST sul login,

446
00:37:02,400 --> 00:37:06,935
vedi che il server risponde dicendo «Sei autenticato».

447
00:37:06,935 --> 00:37:08,740
Quindi, a questo punto,

448
00:37:08,740 --> 00:37:11,400
posso eseguire le

449
00:37:11,400 --> 00:37:16,115
richieste GET, PUT, POST e DELETE su tutti gli altri endpoint.

450
00:37:16,115 --> 00:37:26,370
Quindi, a questo punto, se faccio un GET sull'endpoint piatti,

451
00:37:28,760 --> 00:37:32,675
vedresti che questo restituisce

452
00:37:32,675 --> 00:37:39,160
il campo vuoto perché il mio database è attualmente vuoto.

453
00:37:39,160 --> 00:37:44,370
Permettetemi di cancellare l'autorizzazione e anche dall'intestazione rimuovere

454
00:37:44,370 --> 00:37:49,575
l'autorizzazione e quindi fare GET e la sua cassetta degli attrezzi va bene.

455
00:37:49,575 --> 00:37:52,480
Quindi, puoi vedere che ora sono in grado di

456
00:37:52,480 --> 00:37:56,065
accedere agli endpoint perché ho effettuato l'accesso.

457
00:37:56,065 --> 00:38:00,040
Quindi ora, lasciami fare un logout dell'utente.

458
00:38:00,040 --> 00:38:05,910
Quindi, diremo, localhost: 3000 e logout.

459
00:38:05,910 --> 00:38:08,875
Si noti inoltre che, nei cookie,

460
00:38:08,875 --> 00:38:12,290
un cookie è stato impostato all'ID di sessione proprio lì.

461
00:38:12,290 --> 00:38:17,080
Quindi, quel cookie esiste sul mio sito cliente.

462
00:38:17,080 --> 00:38:22,715
Quindi ora, lasciami uscire dicendo GET localhost: 3000/utenti/logout.

463
00:38:22,715 --> 00:38:26,580
Quindi, quando eseguo un log out dall'utente,

464
00:38:26,580 --> 00:38:29,765
vedrai immediatamente che vengo reindirizzato a

465
00:38:29,765 --> 00:38:37,830
quell'endpoint localhost: 3000 e noterò anche che il cookie è sparito.

466
00:38:37,830 --> 00:38:40,140
Quindi, quando guardo i cookie,

467
00:38:40,140 --> 00:38:42,040
vedi che il localhost,

468
00:38:42,040 --> 00:38:46,470
il cookie è sparito perché dal mio lato server quando faccio il logout

469
00:38:46,470 --> 00:38:51,495
invia un cookie chiaro di riposo al lato client e quindi il cookie è sparito.

470
00:38:51,495 --> 00:38:54,555
Ora, se provo a fare un GET

471
00:38:54,555 --> 00:39:02,480
sull'endpoint localhost: 3000/piatti,

472
00:39:02,480 --> 00:39:05,899
questo non funzionerà perché non sono autenticato.

473
00:39:05,899 --> 00:39:11,610
Quindi, questo dimostra come è possibile estendere il server Express per

474
00:39:11,610 --> 00:39:17,190
consentire agli utenti di registrarsi e quindi consentire all'utente di accedere al sistema

475
00:39:17,190 --> 00:39:19,860
e quindi anche disconnettersi dal sistema.

476
00:39:19,860 --> 00:39:25,520
Sul lato server si sta tracciando un utente connesso utilizzando la sessione e utilizzando

477
00:39:25,520 --> 00:39:28,260
il cookie sul lato client e quando l'utente si

478
00:39:28,260 --> 00:39:31,375
disconnette il cookie viene distrutto sul lato client.

479
00:39:31,375 --> 00:39:34,540
Con questo, completiamo questo esercizio.

480
00:39:34,540 --> 00:39:37,390
Questo è un buon momento per fare un commit Git,

481
00:39:37,390 --> 00:39:42,420
con il messaggio, le sessioni Express parte due.