﻿1
00:00:01,260 --> 00:00:02,480
‫Jonas: In

2
00:00:02,480 --> 00:00:04,560
‫diesem Vortrag implementieren wir also die

3
00:00:04,560 --> 00:00:08,010
‫Funktionalität des Einloggens von Benutzern basierend auf einem gegebenen Passwort

4
00:00:08,010 --> 00:00:09,363
‫und einer gegebenen E-Mail-Adresse.

5
00:00:10,920 --> 00:00:14,520
‫Und genau wie zuvor bedeutet das Konzept des Anmeldens

6
00:00:14,520 --> 00:00:17,400
‫eines Benutzers im Wesentlichen, einen JSON-Webtoken zu signieren

7
00:00:17,400 --> 00:00:19,760
‫und an den Client zurückzusenden.

8
00:00:19,760 --> 00:00:22,390
‫Aber in diesem Fall stellen wir das Token

9
00:00:22,390 --> 00:00:24,860
‫nur dann aus, wenn der Benutzer tatsächlich

10
00:00:24,860 --> 00:00:27,310
‫existiert und das Passwort korrekt ist.

11
00:00:27,310 --> 00:00:29,773
‫Beginnen wir also mit der Umsetzung.

12
00:00:31,480 --> 00:00:36,260
‫Exporte. Login ist...

13
00:00:39,090 --> 00:00:42,253
‫anfordern, antwortet und weiter.

14
00:00:44,370 --> 00:00:47,060
‫Und das erste ist, dass wir die

15
00:00:47,060 --> 00:00:50,020
‫E-Mail und das Passwort tatsächlich aus dem Text lesen.

16
00:00:50,020 --> 00:00:54,740
‫Nehmen wir an, const email ist gleich req. Karosserie. Email.

17
00:00:58,920 --> 00:01:02,070
‫Okay, und jetzt gibt uns eslint diese Warnung oder

18
00:01:02,070 --> 00:01:04,160
‫eigentlich diesen Fehler und sagt,

19
00:01:04,160 --> 00:01:07,080
‫dass wir die Objektdestrukturierung verwenden sollten, okay?

20
00:01:07,080 --> 00:01:09,620
‫Und so habe ich dies hier absichtlich

21
00:01:09,620 --> 00:01:12,620
‫geschehen lassen, nur damit ich Ihnen zeigen kann, wie

22
00:01:12,620 --> 00:01:14,950
‫wir es mit ES6-Destrukturierung machen können.

23
00:01:14,950 --> 00:01:18,490
‫Und ich glaube, darüber habe ich im Kurs schon einmal

24
00:01:18,490 --> 00:01:20,930
‫gesprochen, und ich hoffe auch, dass Sie

25
00:01:20,930 --> 00:01:23,330
‫mit dem Konzept bereits vertraut sind,

26
00:01:23,330 --> 00:01:25,430
‫aber trotzdem, da der Name

27
00:01:25,430 --> 00:01:27,920
‫dieser Eigenschaft hier der gleiche ist wie

28
00:01:27,920 --> 00:01:30,260
‫der Variablenname, können wir es einfach

29
00:01:30,260 --> 00:01:34,150
‫so machen das und den Namen der Eigenschaft hier loswerden, okay?

30
00:01:34,150 --> 00:01:36,520
‫Und auch wir wollen das Passwort bekommen.

31
00:01:36,520 --> 00:01:37,930
‫Und damit wäre das gleich, also

32
00:01:37,930 --> 00:01:42,470
‫entspricht das Passwort im Grunde einer Anfrage. Karosserie. Passwort.

33
00:01:42,470 --> 00:01:43,647
‫Und

34
00:01:43,647 --> 00:01:47,940
‫stattdessen können wir einfach E-Mail und Passwort eingeben.

35
00:01:47,940 --> 00:01:50,250
‫Und so erstellen wir

36
00:01:50,250 --> 00:01:54,480
‫im Grunde diese beiden Variablen des Körperobjekts, okay?

37
00:01:54,480 --> 00:01:56,380
‫Im Grunde sendet der

38
00:01:56,380 --> 00:02:00,223
‫Benutzer also die Anmeldedaten zur Überprüfung durch uns ein.

39
00:02:01,070 --> 00:02:04,130
‫Okay, und dieser Prüfprozess besteht aus ein paar Schritten. Lassen Sie

40
00:02:04,130 --> 00:02:05,830
‫uns sie also hier darstellen,

41
00:02:05,830 --> 00:02:07,750
‫bevor wir mit dem Codieren beginnen.

42
00:02:07,750 --> 00:02:12,030
‫Zuerst müssen wir also prüfen,

43
00:02:12,030 --> 00:02:17,030
‫ob E-Mail und Passwörter tatsächlich existieren, in Ordnung?

44
00:02:17,900 --> 00:02:22,900
‫Dann Nummer zwei, prüfen Sie, ob der Benutzer

45
00:02:24,440 --> 00:02:29,440
‫existiert und gleichzeitig das Passwort korrekt ist.

46
00:02:31,960 --> 00:02:33,943
‫Und dann drittens, wenn alles

47
00:02:39,440 --> 00:02:44,440
‫in Ordnung ist, senden Sie das Token, also das JSON-Webtoken, zurück an den Client.

48
00:02:45,800 --> 00:02:48,490
‫Okay, der erste ist also ganz einfach.

49
00:02:48,490 --> 00:02:53,490
‫Wenn also keine E-Mail oder kein Passwort vorhanden ist, möchten

50
00:02:56,810 --> 00:03:00,370
‫wir unserem Kunden eine Fehlermeldung senden.

51
00:03:00,370 --> 00:03:02,600
‫Wie sollen wir das jetzt machen?

52
00:03:02,600 --> 00:03:04,490
‫Nun, wir werden das mit den

53
00:03:04,490 --> 00:03:07,490
‫Tools machen, die wir gleich im letzten Abschnitt implementiert haben.

54
00:03:07,490 --> 00:03:10,730
‫Also im Grunde unser App-Fehler, erinnerst du dich daran?

55
00:03:10,730 --> 00:03:12,977
‫Wir werden hier also einfach einen neuen

56
00:03:12,977 --> 00:03:15,060
‫Fehler erstellen, und unsere globale

57
00:03:15,060 --> 00:03:19,190
‫Middleware zur Fehlerbehandlung wird ihn dann aufnehmen und an den Client zurücksenden.

58
00:03:19,190 --> 00:03:22,483
‫Beginnen wir also mit dem Importieren dieses Fehlers.

59
00:03:23,350 --> 00:03:25,260
‫Denken Sie also daran,

60
00:03:25,260 --> 00:03:28,463
‫dass es dieser hier aus unserer AppError-Klasse ist, richtig?

61
00:03:29,620 --> 00:03:34,620
‫Sagen wir also AppError und dann require.

62
00:03:40,860 --> 00:03:44,150
‫Also eine Ebene höher von hier, dann in den Dienstprogrammen und

63
00:03:44,150 --> 00:03:45,050
‫dann appError.

64
00:03:48,990 --> 00:03:52,430
‫Okay, also müssen wir die nächste Middleware aufrufen,

65
00:03:52,430 --> 00:03:56,403
‫und dann übergeben wir hier den Fehler, erinnern Sie sich daran?

66
00:03:57,260 --> 00:04:00,363
‫Also neuer AppError, und

67
00:04:02,510 --> 00:04:07,510
‫die Meldung lautet: Bitte E-Mail und Passwort angeben.

68
00:04:07,530 --> 00:04:12,530
‫Und der HTTP-Fehlercode ist 400 für eine fehlerhafte Anfrage, okay?

69
00:04:12,720 --> 00:04:14,340
‫Und jetzt habe ich

70
00:04:14,340 --> 00:04:19,090
‫hier einige Fehler, und so hilft mir eslint wieder, einige Fehler zu beheben.

71
00:04:19,090 --> 00:04:20,710
‫So sehe ich das

72
00:04:20,710 --> 00:04:24,010
‫hier oben wieder, ich habe es mit einem T statt

73
00:04:24,010 --> 00:04:27,740
‫D verwendet, und wenn ich es jetzt speichere, ist alles richtig.

74
00:04:27,740 --> 00:04:32,393
‫Okay, also lasst uns gleich mit dem Testen beginnen.

75
00:04:33,330 --> 00:04:34,700
‫Und dafür

76
00:04:34,700 --> 00:04:39,700
‫werde ich hier erstmal einfach einen gefälschten Token erstellen, okay.

77
00:04:39,930 --> 00:04:43,287
‫Sagen wir also res. Status 200 für ok.

78
00:04:51,202 --> 00:04:53,573
‫JSON, und dann natürlich wie

79
00:04:56,540 --> 00:05:01,010
‫immer der Status auf Erfolg gesetzt und dann auch noch unser Token.

80
00:05:01,010 --> 00:05:02,870
‫Und das ist eigentlich alles, was

81
00:05:02,870 --> 00:05:05,130
‫wir als Antwort auf die Anmeldung senden, okay?

82
00:05:05,130 --> 00:05:08,290
‫Also kein Benutzerobjekt, weil das gar nicht nötig ist.

83
00:05:08,290 --> 00:05:10,800
‫Alles, was wir als Antwort für die Anmeldung benötigen,

84
00:05:10,800 --> 00:05:12,140
‫ist eigentlich das Token.

85
00:05:12,140 --> 00:05:15,033
‫Das ist alles, was zählt, wenn sich der Benutzer anmeldet.

86
00:05:16,210 --> 00:05:18,960
‫Als nächstes müssen wir die Route

87
00:05:18,960 --> 00:05:23,600
‫implementieren, also machen wir das noch einmal in unserem Benutzerrouter, okay?

88
00:05:23,600 --> 00:05:27,000
‫Und dieser ist diesem tatsächlich ziemlich ähnlich.

89
00:05:27,000 --> 00:05:30,310
‫Lass es uns einfach duplizieren und dann

90
00:05:30,310 --> 00:05:34,780
‫die Anmeldung in beiden Fällen hier durch die Anmeldung ersetzen, okay?

91
00:05:34,780 --> 00:05:38,220
‫Und das gilt wiederum nur für eine

92
00:05:38,220 --> 00:05:40,360
‫Postanfrage, denn natürlich wollen

93
00:05:40,360 --> 00:05:43,200
‫wir die Zugangsdaten im Body mitschicken.

94
00:05:43,200 --> 00:05:44,630
‫Es ist also wieder

95
00:05:44,630 --> 00:05:47,610
‫ein Post, aber kein Get, kein Patch und kein Delete,

96
00:05:47,610 --> 00:05:50,393
‫denn das macht in diesem Fall keinen Sinn.

97
00:05:51,590 --> 00:05:54,033
‫Also lass es uns gleich testen.

98
00:05:54,970 --> 00:05:57,033
‫Ich werde diese URL auch hier kopieren.

99
00:05:58,050 --> 00:06:03,050
‫Es wird posten, einloggen und dann natürlich

100
00:06:03,570 --> 00:06:05,140
‫der Text.

101
00:06:05,140 --> 00:06:08,700
‫Also wieder Raw und JSON.

102
00:06:08,700 --> 00:06:11,443
‫Lassen Sie uns hier also einen einfachen Körper erstellen.

103
00:06:17,680 --> 00:06:19,960
‫Alles klar, also versuchen wir, dies

104
00:06:19,960 --> 00:06:22,993
‫ohne Passwort zu senden und sehen, was passiert.

105
00:06:24,460 --> 00:06:27,470
‫Und tatsächlich funktioniert es, daher erhalten wir hier unsere Nachricht:

106
00:06:27,470 --> 00:06:30,030
‫Bitte geben Sie E-Mail und Passwort an.

107
00:06:30,030 --> 00:06:31,820
‫Und wieder, da wir

108
00:06:31,820 --> 00:06:34,110
‫noch in der Entwicklung sind, bekommen wir

109
00:06:34,110 --> 00:06:36,910
‫hier den ganzen Fehlerstack und den kompletten Fehler mit

110
00:06:36,910 --> 00:06:39,350
‫unserem Statuscode, den Status und natürlich auch, dass

111
00:06:39,350 --> 00:06:41,330
‫es sich um einen Betriebsfehler handelt.

112
00:06:41,330 --> 00:06:45,840
‫Also genau wie im vorherigen Abschnitt definiert, okay?

113
00:06:45,840 --> 00:06:48,433
‫Jetzt versuchen wir das gleiche mit dem Passwort.

114
00:06:50,750 --> 00:06:55,750
‫Also Passwort, setze es auf Ich glaube, das war das Richtige,

115
00:06:56,400 --> 00:06:58,893
‫und dann lösche die E-Mail.

116
00:07:00,590 --> 00:07:02,950
‫Und das löst natürlich das gleiche aus.

117
00:07:02,950 --> 00:07:06,000
‫Okay, und mit allem korrekten sollte das dann funktionieren,

118
00:07:06,000 --> 00:07:08,803
‫und tatsächlich bekommen wir hier unseren Fake-Token.

119
00:07:10,300 --> 00:07:12,890
‫Jetzt sollten wir nur noch eines hier

120
00:07:12,890 --> 00:07:14,880
‫tun, um auch zurückzukehren.

121
00:07:14,880 --> 00:07:16,790
‫Das haben wir schon oft gemacht, und lassen

122
00:07:16,790 --> 00:07:18,680
‫Sie es mich noch einmal erklären.

123
00:07:18,680 --> 00:07:21,610
‫Es liegt einfach daran, dass wir nach dem

124
00:07:21,610 --> 00:07:24,380
‫Aufruf der nächsten Middleware sicherstellen möchten,

125
00:07:24,380 --> 00:07:27,873
‫dass diese Login-Funktion hier sofort beendet wird, in Ordnung?

126
00:07:30,260 --> 00:07:32,080
‫Und da wir das vorher

127
00:07:32,080 --> 00:07:34,560
‫nicht hatten, sehen Sie diesen Fehler jetzt hier wieder.

128
00:07:34,560 --> 00:07:38,060
‫Das kommt mir jetzt schon irgendwie bekannt vor, oder?

129
00:07:38,060 --> 00:07:40,940
‫Daher können keine Header gesetzt werden, nachdem sie an den Client

130
00:07:40,940 --> 00:07:43,360
‫gesendet wurden, da wir wiederum zwei Antworten gesendet haben.

131
00:07:43,360 --> 00:07:47,840
‫Erst die Fehlerantwort und dann auch dieser Code hier laufen, was

132
00:07:47,840 --> 00:07:50,040
‫natürlich nicht hätte gehen sollen.

133
00:07:50,040 --> 00:07:52,933
‫Und so verwenden wir hier wieder return, um das zu beheben.

134
00:07:53,790 --> 00:07:57,430
‫Okay, als nächstes prüfen wir, ob es tatsächlich einen

135
00:07:57,430 --> 00:07:59,870
‫Benutzer für die gepostete E-Mail gibt.

136
00:07:59,870 --> 00:08:04,870
‫Also const user, und verwenden wir jetzt tatsächlich findOne, denn diesmal

137
00:08:09,940 --> 00:08:13,400
‫wählen wir einen Benutzer nicht nach der ID

138
00:08:13,400 --> 00:08:16,650
‫aus, sondern nach seiner E-Mail, oder?

139
00:08:16,650 --> 00:08:19,460
‫Also müssen wir dieses Filterobjekt übergeben,

140
00:08:19,460 --> 00:08:24,190
‫in dem wir sagen können, dass E-Mail gleich E-Mail ist, okay?

141
00:08:24,190 --> 00:08:25,940
‫Das Feld heißt also

142
00:08:25,940 --> 00:08:28,270
‫E-Mail und die Variable heißt auch E-Mail.

143
00:08:28,270 --> 00:08:32,163
‫In ES6 können wir das einfach so abkürzen.

144
00:08:33,060 --> 00:08:34,490
‫Bevor wir hier

145
00:08:34,490 --> 00:08:36,110
‫weitermachen, muss ich noch

146
00:08:36,110 --> 00:08:38,520
‫etwas Wichtiges für die Sicherheit tun.

147
00:08:38,520 --> 00:08:41,220
‫Lassen Sie mich Ihnen das in Postman zeigen,

148
00:08:41,220 --> 00:08:43,970
‫wo wir uns für ein neues Konto angemeldet haben.

149
00:08:43,970 --> 00:08:46,540
‫Und Sie sehen hier, dass wir

150
00:08:46,540 --> 00:08:49,810
‫in der Benutzerausgabe tatsächlich das Passwort erhalten, okay?

151
00:08:49,810 --> 00:08:52,010
‫Es ist tatsächlich verschlüsselt,

152
00:08:52,010 --> 00:08:55,010
‫aber es ist trotzdem keine gute Praxis,

153
00:08:55,010 --> 00:08:57,710
‫die Passwortdaten an den Client weiterzugeben, okay?

154
00:08:57,710 --> 00:09:01,090
‫Wenn wir zum Beispiel alle Benutzer hierher bekommen hätten

155
00:09:01,090 --> 00:09:03,480
‫und diese Route noch nicht implementiert

156
00:09:03,480 --> 00:09:07,170
‫ist, aber wenn wir alle Benutzer aus der Sammlung holen

157
00:09:07,170 --> 00:09:09,440
‫würden, dann hätten alle das

158
00:09:09,440 --> 00:09:12,720
‫Passwort sichtbar, und das wollen wir nicht , okay?

159
00:09:12,720 --> 00:09:15,790
‫Und so ist es eigentlich ganz einfach, es zu reparieren,

160
00:09:15,790 --> 00:09:17,850
‫weil wir es vorher gemacht haben.

161
00:09:17,850 --> 00:09:19,973
‫Alles, was wir tun müssen, ist,

162
00:09:20,820 --> 00:09:25,270
‫das Passwort zu sagen und es dann auszuwählen und auf false zu setzen.

163
00:09:25,270 --> 00:09:28,100
‫Und so wird es automatisch in keiner

164
00:09:28,100 --> 00:09:29,123
‫Ausgabe angezeigt.

165
00:09:30,520 --> 00:09:32,520
‫Und damit ich Ihnen das

166
00:09:32,520 --> 00:09:37,023
‫tatsächlich beweisen kann, indem ich mich als etwas anderes anmelde, also so.

167
00:09:39,070 --> 00:09:41,920
‫Und mal sehen, oh, tatsächlich haben wir

168
00:09:41,920 --> 00:09:45,833
‫bereits einen Benutzer mit dieser E-Mail, also machen wir einfach test3.

169
00:09:47,300 --> 00:09:50,830
‫Und jetzt ist das Passwort eigentlich immer noch hier, aber ich

170
00:09:50,830 --> 00:09:54,100
‫denke, das liegt einfach daran, dass wir es einfach erstellen

171
00:09:54,100 --> 00:09:55,610
‫konnten, dieses neue

172
00:09:55,610 --> 00:09:58,030
‫Dokument hier, und daher wird es nicht

173
00:09:58,030 --> 00:10:01,460
‫wirklich ausgewählt, weil wir es nicht wirklich aus der Datenbank lesen.

174
00:10:01,460 --> 00:10:03,250
‫Also lass uns

175
00:10:03,250 --> 00:10:05,100
‫diese Route hier ganz schnell

176
00:10:05,100 --> 00:10:07,690
‫tatsächlich umsetzen, das dauert nur eine Minute.

177
00:10:07,690 --> 00:10:10,300
‫Also nur um zu sehen, ob das hier wirklich funktioniert.

178
00:10:10,300 --> 00:10:12,230
‫Denn dieser Schritt ist eigentlich

179
00:10:12,230 --> 00:10:15,170
‫wichtig für das, was wir als nächstes tun werden, okay?

180
00:10:15,170 --> 00:10:18,820
‫Also lassen Sie uns diesen Code aus getAllTours kopieren

181
00:10:18,820 --> 00:10:22,000
‫und nicht wirklich kopieren, aber was wir

182
00:10:22,000 --> 00:10:25,133
‫tun werden, ist natürlich ziemlich ähnlich.

183
00:10:26,750 --> 00:10:28,590
‫Also kopiere ich das

184
00:10:28,590 --> 00:10:30,450
‫einfach, aber ohne die API-Funktionen.

185
00:10:30,450 --> 00:10:33,700
‫Das interessiert mich also nicht wirklich, okay?

186
00:10:33,700 --> 00:10:35,500
‫Und so werde ich

187
00:10:35,500 --> 00:10:39,170
‫dieses hier tatsächlich im Benutzer-Controller tun, weil das Abrufen aller Benutzer

188
00:10:39,170 --> 00:10:41,350
‫nichts mit der Authentifizierung zu tun hat.

189
00:10:41,350 --> 00:10:43,570
‫In diesem Fall ist

190
00:10:43,570 --> 00:10:47,020
‫die Benutzersteuerung also der perfekte Ort dafür.

191
00:10:47,020 --> 00:10:49,440
‫Jetzt muss ich natürlich auch

192
00:10:49,440 --> 00:10:51,990
‫noch schnell das Benutzermodell hier importieren, also

193
00:10:51,990 --> 00:10:56,580
‫kopieren wir das auch vom tourController, der nicht gleich aber ähnlich ist.

194
00:10:56,580 --> 00:11:00,550
‫Also lassen Sie uns all dies in

195
00:11:04,200 --> 00:11:06,370
‫unseren Benutzer-Controller packen.

196
00:11:06,370 --> 00:11:09,683
‫Diesen brauchen wir nicht, aber wir müssen auch catchAsync.

197
00:11:10,520 --> 00:11:13,640
‫Okay, Tour wird also user

198
00:11:13,640 --> 00:11:18,400
‫sein, und hier wird es userModel sein, in Ordnung?

199
00:11:18,400 --> 00:11:21,420
‫Dann haben wir hier Touren und hier unten und hier

200
00:11:21,420 --> 00:11:23,790
‫unten, also drücke ich Befehl + D, um

201
00:11:23,790 --> 00:11:26,033
‫alle auszuwählen und in Benutzer zu ändern.

202
00:11:27,190 --> 00:11:32,190
‫Und dann erwarten wir hier natürlich User. finden.

203
00:11:34,870 --> 00:11:36,320
‫Da wir hier

204
00:11:36,320 --> 00:11:41,310
‫ein Async haben, brauchen wir async, dann brauchen wir auch next, und da

205
00:11:41,310 --> 00:11:42,810
‫wir hier ein Async

206
00:11:42,810 --> 00:11:46,580
‫haben, sollten wir das Ganze dann in ein Catch-Async einpacken.

207
00:11:46,580 --> 00:11:47,713
‫Also machen wir das.

208
00:11:50,090 --> 00:11:51,700
‫Okay, und an dieser

209
00:11:51,700 --> 00:11:53,810
‫Stelle ist das für dich nichts

210
00:11:53,810 --> 00:11:58,120
‫Neues mehr, wir sind schon daran gewöhnt, solche Sachen zu machen, oder?

211
00:11:58,120 --> 00:12:00,670
‫Das sollte zu diesem Zeitpunkt bereits funktionieren, also

212
00:12:00,670 --> 00:12:02,470
‫probieren wir es aus.

213
00:12:02,470 --> 00:12:06,460
‫Holen Sie sich also alle Benutzer, und jetzt sehen wir tatsächlich,

214
00:12:06,460 --> 00:12:10,030
‫dass ihr Passwort nicht in der Ausgabe enthalten ist.

215
00:12:10,030 --> 00:12:13,853
‫Und das ist wichtig, denn eigentlich wird im Find, also

216
00:12:15,090 --> 00:12:17,093
‫zurück hier im AuthController,

217
00:12:18,030 --> 00:12:21,490
‫dieser hier nun auch nicht das Passwort enthalten, okay?

218
00:12:21,490 --> 00:12:23,060
‫Und so wird

219
00:12:23,060 --> 00:12:25,920
‫die Ausgabe hier nun auch kein Passwort enthalten.

220
00:12:25,920 --> 00:12:28,890
‫Aber wir brauchen das Passwort, um zu überprüfen,

221
00:12:28,890 --> 00:12:30,810
‫ob es richtig ist, oder?

222
00:12:30,810 --> 00:12:34,500
‫Also müssen wir es auch explizit auswählen.

223
00:12:34,500 --> 00:12:37,460
‫Erinnern Sie sich also daran, wie wir zuvor select

224
00:12:37,460 --> 00:12:40,150
‫verwendet haben, um im Grunde einfach ein paar

225
00:12:40,150 --> 00:12:43,450
‫Felder aus der Datenbank auszuwählen, nur die, die wir brauchten?

226
00:12:43,450 --> 00:12:45,460
‫Wenn wir in diesem Fall das

227
00:12:45,460 --> 00:12:47,640
‫standardmäßig nicht ausgewählte Feld möchten, müssen wir

228
00:12:47,640 --> 00:12:50,853
‫den Benutzer plus und dann den Namen des Felds eingeben.

229
00:12:51,720 --> 00:12:53,610
‫Also Passwort in diesem Fall.

230
00:12:53,610 --> 00:12:58,220
‫Und so wird es wieder in der Ausgabe erscheinen, okay?

231
00:12:58,220 --> 00:13:01,750
‫Natürlich müssen wir diese Abfrage

232
00:13:01,750 --> 00:13:06,260
‫abwarten und dann die Funktion als asynchron markieren.

233
00:13:06,260 --> 00:13:08,140
‫Um diesen

234
00:13:08,140 --> 00:13:12,010
‫hässlichen try-catch-Block zu vermeiden, wickeln Sie diese

235
00:13:12,010 --> 00:13:16,253
‫gesamte Funktion wie zuvor in catchAsync ein.

236
00:13:18,520 --> 00:13:20,163
‫Alles klar, macht Sinn?

237
00:13:22,170 --> 00:13:26,770
‫Lassen Sie uns den Benutzer jetzt schnell an der Konsole anmelden, um zu

238
00:13:26,770 --> 00:13:28,353
‫sehen, ob es funktioniert.

239
00:13:32,220 --> 00:13:34,033
‫Also dieser hier.

240
00:13:35,460 --> 00:13:39,600
‫Wir bekommen unseren Erfolg, und tatsächlich bekommen wir hier den Benutzer.

241
00:13:39,600 --> 00:13:42,650
‫Also mit genau der E-Mail, die ich gerade gepostet

242
00:13:42,650 --> 00:13:45,830
‫habe, und dann ist das Passwort jetzt auch wieder

243
00:13:45,830 --> 00:13:47,890
‫in der Ausgabe enthalten, okay?

244
00:13:47,890 --> 00:13:51,453
‫Das liegt wiederum daran, dass wir es hier explizit ausgewählt haben.

245
00:13:52,490 --> 00:13:54,950
‫Jetzt ist es also an der Zeit, die Passwörter,

246
00:13:54,950 --> 00:13:57,400
‫die wir in der Datenbank haben, mit dem Passwort

247
00:13:57,400 --> 00:13:59,830
‫zu vergleichen, das der Benutzer gerade gepostet hat.

248
00:13:59,830 --> 00:14:01,930
‫Aber wie sollen wir das machen?

249
00:14:01,930 --> 00:14:05,190
‫Denn zum Beispiel könnte das Passwort

250
00:14:05,190 --> 00:14:09,169
‫pass1234 lauten oder ist es in diesem Beispiel, aber

251
00:14:09,169 --> 00:14:13,983
‫das, das wir im Dokument gespeichert haben, sieht so aus.

252
00:14:15,040 --> 00:14:17,220
‫Wie sollen wir das vergleichen?

253
00:14:17,220 --> 00:14:19,960
‫Es gibt nicht wirklich eine Möglichkeit, es zu tun, oder?

254
00:14:19,960 --> 00:14:22,300
‫Aber eigentlich müssen

255
00:14:22,300 --> 00:14:25,890
‫wir nur noch das bcrypt-Paket verwenden, okay?

256
00:14:25,890 --> 00:14:29,400
‫Wir haben also bcrypt verwendet, um dieses gehashte Passwort zu generieren, und

257
00:14:29,400 --> 00:14:31,230
‫wir können das gleiche Paket auch

258
00:14:31,230 --> 00:14:34,930
‫verwenden, um ein Original-Passwort wie dieses hier im Grunde mit dem gehashten

259
00:14:34,930 --> 00:14:36,283
‫Passwort zu vergleichen.

260
00:14:37,230 --> 00:14:40,700
‫Natürlich dieses Passwort hier, da es verschlüsselt ist, gibt

261
00:14:40,700 --> 00:14:43,350
‫es keine Möglichkeit, das alte, also

262
00:14:43,350 --> 00:14:46,680
‫das ursprüngliche Passwort aus dieser Zeichenfolge zurückzubekommen, richtig?

263
00:14:46,680 --> 00:14:48,150
‫Das ist also der

264
00:14:48,150 --> 00:14:50,550
‫springende Punkt beim eigentlichen Verschlüsseln eines Passworts.

265
00:14:50,550 --> 00:14:52,410
‫Die einzige Möglichkeit für

266
00:14:52,410 --> 00:14:54,890
‫dieses Paket für diesen Algorithmus besteht

267
00:14:54,890 --> 00:14:58,100
‫also darin, dieses Passwort auch tatsächlich zu verschlüsseln

268
00:14:58,100 --> 00:15:02,210
‫und es dann mit dem verschlüsselten zu vergleichen, in Ordnung?

269
00:15:02,210 --> 00:15:05,110
‫Lassen Sie uns also eine Funktion implementieren, die

270
00:15:05,110 --> 00:15:08,350
‫das tut, und dafür verwenden wir wieder das bcrypt-Paket.

271
00:15:08,350 --> 00:15:11,280
‫Und das werden wir im Benutzermodell tun.

272
00:15:11,280 --> 00:15:13,767
‫Und Sie könnten sich fragen: "Warum machen wir

273
00:15:13,767 --> 00:15:16,310
‫das in einem Modell" und nicht nur hier", aber

274
00:15:16,310 --> 00:15:19,730
‫das liegt wiederum daran, dass dies wirklich mit den Daten selbst zusammenhängt.

275
00:15:19,730 --> 00:15:22,930
‫Außerdem haben wir dieses Paket bereits drin, und so

276
00:15:22,930 --> 00:15:26,090
‫ist es einfacher, es einfach dort zu machen.

277
00:15:26,090 --> 00:15:28,663
‫Lassen Sie uns diese Zeichenfolge einfach loswerden

278
00:15:30,600 --> 00:15:32,360
‫und erstellen Sie hier

279
00:15:32,360 --> 00:15:34,580
‫eine Funktion, die überprüft, ob das

280
00:15:34,580 --> 00:15:37,473
‫angegebene Passwort mit dem im Dokument gespeicherten übereinstimmt.

281
00:15:38,520 --> 00:15:41,100
‫Also erstellen wir jetzt zum ersten

282
00:15:41,100 --> 00:15:43,000
‫Mal eine sogenannte Instanzmethode.

283
00:15:43,000 --> 00:15:46,120
‫Eine Instanzmethode ist also im Grunde eine Methode,

284
00:15:46,120 --> 00:15:48,500
‫die für alle Dokumente einer bestimmten

285
00:15:48,500 --> 00:15:50,843
‫Sammlung verfügbar sein wird, okay?

286
00:15:51,680 --> 00:15:53,320
‫Und es funktioniert so.

287
00:15:53,320 --> 00:15:56,120
‫Also noch einmal, es ist

288
00:15:56,120 --> 00:16:01,050
‫in einem userSchema definiert, und dann sagen wir Methoden, und in diesem

289
00:16:01,050 --> 00:16:05,273
‫Fall möchten wir jetzt die Funktion correctPassword aufrufen, in Ordnung?

290
00:16:10,340 --> 00:16:12,810
‫Funktion, jetzt akzeptiert diese Funktion ein CandidatePassword,

291
00:16:12,810 --> 00:16:14,470
‫also das Passwort,

292
00:16:17,734 --> 00:16:19,650
‫das der Benutzer im Hauptteil

293
00:16:19,650 --> 00:16:22,347
‫übergibt, und dann auch das userPassword, okay?

294
00:16:26,010 --> 00:16:28,590
‫Da diese instanzierten Methoden

295
00:16:28,590 --> 00:16:31,470
‫im Dokument verfügbar sind, verweist das

296
00:16:31,470 --> 00:16:35,430
‫Schlüsselwort this nun tatsächlich auf das aktuelle Dokument.

297
00:16:35,430 --> 00:16:37,610
‫Aber in diesem Fall haben

298
00:16:37,610 --> 00:16:42,080
‫wir das Passwort auf false gesetzt, also das hier, erinnerst du dich?

299
00:16:42,080 --> 00:16:43,690
‫Okay, und

300
00:16:43,690 --> 00:16:47,920
‫deswegen das hier. Passwort wird nicht verfügbar sein.

301
00:16:47,920 --> 00:16:50,780
‫Idealerweise würden wir es so machen, und

302
00:16:50,780 --> 00:16:52,360
‫auf diese Weise

303
00:16:52,360 --> 00:16:56,130
‫müssten wir nur das CandidatePassword und nicht das userPassword übergeben.

304
00:16:56,130 --> 00:16:58,690
‫Aber auch das ist im Moment

305
00:16:58,690 --> 00:17:02,350
‫nicht möglich, da das Passwort in der Ausgabe nicht verfügbar ist.

306
00:17:02,350 --> 00:17:03,420
‫Und deshalb

307
00:17:03,420 --> 00:17:06,380
‫müssen wir eigentlich auch userPassword eingeben.

308
00:17:06,380 --> 00:17:07,890
‫Das Ziel dieser Funktion

309
00:17:07,890 --> 00:17:11,030
‫besteht also darin, wirklich nur wahr oder falsch zurückzugeben.

310
00:17:11,030 --> 00:17:14,000
‫Also grundsätzlich wahr, wenn die Passwörter gleich sind,

311
00:17:14,000 --> 00:17:15,663
‫und falsch, wenn nicht.

312
00:17:16,560 --> 00:17:21,410
‫Also kehren Sie zurück und dann bcrypt, was wir bereits

313
00:17:21,410 --> 00:17:26,257
‫kennen, und dann werden wir die Vergleichsfunktion verwenden, okay?

314
00:17:26,257 --> 00:17:29,190
‫Und die Vergleichsfunktion ist

315
00:17:29,190 --> 00:17:32,200
‫wirklich einfach, wir müssen nur das

316
00:17:32,200 --> 00:17:37,060
‫CandidatePassword und das userPassword übergeben, nicht userSchema, userPassword, okay?

317
00:17:39,270 --> 00:17:42,090
‫Und genau wie die Hash-Funktion

318
00:17:42,090 --> 00:17:45,383
‫hier oben ist auch diese eine asynchrone Funktion.

319
00:17:46,270 --> 00:17:50,973
‫Und so wie zuvor verwenden wir await und dann hier async.

320
00:17:53,330 --> 00:17:54,940
‫Okay, sinnvoll?

321
00:17:54,940 --> 00:17:57,630
‫Auch hier gibt diese Vergleichsfunktion hier

322
00:17:57,630 --> 00:17:59,800
‫ganz einfach true zurück,

323
00:17:59,800 --> 00:18:04,470
‫wenn diese beiden Passwörter hier gleich sind, und false, wenn nicht.

324
00:18:04,470 --> 00:18:07,030
‫Und wieder können wir sie

325
00:18:07,030 --> 00:18:10,020
‫nicht manuell vergleichen, weil das Kandidatenpasswort nicht

326
00:18:10,020 --> 00:18:12,800
‫gehasht ist, also das ursprüngliche Passwort

327
00:18:12,800 --> 00:18:15,580
‫des Benutzers ist, aber userPassword ist

328
00:18:15,580 --> 00:18:18,230
‫natürlich gehasht, und ohne diese Funktion

329
00:18:18,230 --> 00:18:21,830
‫hier hätten wir keine Möglichkeit, sie zu vergleichen, okay?

330
00:18:21,830 --> 00:18:23,990
‫Hier geben wir also true oder

331
00:18:23,990 --> 00:18:26,893
‫false zurück, jetzt müssen wir diese Funktion nur

332
00:18:26,893 --> 00:18:28,633
‫noch im authController aufrufen.

333
00:18:29,920 --> 00:18:31,873
‫Lassen Sie uns ein paar davon schließen.

334
00:18:34,080 --> 00:18:38,253
‫In Ordnung, das hier war also nur zur Demonstration hier.

335
00:18:41,400 --> 00:18:43,563
‫Nennen wir dies hier einfach richtig und

336
00:18:44,400 --> 00:18:47,110
‫denken Sie daran, dass die Funktion, die wir gerade definiert

337
00:18:47,110 --> 00:18:48,670
‫haben, eine instanzierte Methode ist.

338
00:18:48,670 --> 00:18:52,260
‫Daher ist es in allen Benutzerdokumenten verfügbar.

339
00:18:52,260 --> 00:18:54,780
‫Und diese Variable hier ist jetzt

340
00:18:54,780 --> 00:18:57,050
‫also ein Benutzerdokument, oder?

341
00:18:57,050 --> 00:19:00,270
‫Weil es ein Ergebnis der Abfrage des Benutzermodells ist.

342
00:19:00,270 --> 00:19:03,637
‫Und so können wir jetzt Benutzer sagen. richtigesPasswort.

343
00:19:06,760 --> 00:19:10,650
‫Jetzt müssen wir nur noch das Kandidatenpasswort eingeben, das

344
00:19:10,650 --> 00:19:13,020
‫Passwort ist, denken Sie daran.

345
00:19:13,020 --> 00:19:17,830
‫Also dieses hier und dann das userPassword.

346
00:19:17,830 --> 00:19:22,830
‫Und das ist im Benutzer. Passwort, in Ordnung?

347
00:19:23,450 --> 00:19:26,373
‫Und so wird dies hier nun entweder wahr oder falsch sein.

348
00:19:27,990 --> 00:19:30,810
‫In Ordnung, und jetzt verwenden wir diese beiden

349
00:19:30,810 --> 00:19:33,500
‫Variablen, um herauszufinden, ob der Benutzer existiert und

350
00:19:33,500 --> 00:19:35,200
‫das Passwort korrekt ist.

351
00:19:35,200 --> 00:19:36,710
‫Das haben wir

352
00:19:36,710 --> 00:19:40,390
‫bereits herausgefunden, aber jetzt müssen wir tatsächlich unsere if-Anweisung schreiben.

353
00:19:40,390 --> 00:19:45,390
‫Wenn also kein Benutzer vorhanden ist oder das Passwort falsch ist,

354
00:19:46,160 --> 00:19:49,853
‫ist im Grunde richtig falsch, was dies bedeutet.

355
00:19:50,860 --> 00:19:54,590
‫In diesem Fall möchten wir erneut zurückkehren und

356
00:19:54,590 --> 00:19:58,640
‫mit einem neuen AppError direkt zu unserer nächsten Middleware

357
00:19:58,640 --> 00:19:59,640
‫gehen.

358
00:20:00,980 --> 00:20:05,973
‫Und in diesem Fall sagen Sie falsche E-Mail oder Passwort, okay?

359
00:20:08,990 --> 00:20:11,560
‫Und dann ist der Statuscode

360
00:20:11,560 --> 00:20:14,870
‫401, was bedeutet, nicht autorisiert, in Ordnung?

361
00:20:14,870 --> 00:20:16,910
‫Jetzt hätten wir dies separat tun

362
00:20:16,910 --> 00:20:18,847
‫können, also zuerst nach dem

363
00:20:18,847 --> 00:20:21,440
‫Benutzer und dann nach dem richtigen Passwort suchen.

364
00:20:21,440 --> 00:20:24,600
‫Aber in diesem Fall würden wir dann einem potenziellen

365
00:20:24,600 --> 00:20:28,710
‫Angreifer Auskunft darüber geben, ob die E-Mail oder das Passwort falsch ist.

366
00:20:28,710 --> 00:20:31,550
‫Und hier ist es etwas vage.

367
00:20:31,550 --> 00:20:34,830
‫Wir spezifizieren also nicht wirklich, was hier falsch ist.

368
00:20:34,830 --> 00:20:37,060
‫Also, ob es sich um eine E-Mail oder um das Passwort handelt.

369
00:20:37,060 --> 00:20:38,700
‫Wenn also ein

370
00:20:38,700 --> 00:20:41,150
‫Angreifer versucht, zufällige Daten einzugeben, weiß

371
00:20:41,150 --> 00:20:43,640
‫er nicht, ob die E-Mail tatsächlich existiert

372
00:20:43,640 --> 00:20:47,143
‫oder ob nur das Passwort falsch ist, in Ordnung?

373
00:20:47,990 --> 00:20:50,860
‫Jetzt nur zwei Dinge hier, und das erste

374
00:20:50,860 --> 00:20:53,140
‫ist, dass wir tatsächlich auf

375
00:20:53,140 --> 00:20:55,480
‫diese asynchrone Funktion warten müssen, okay?

376
00:20:55,480 --> 00:20:57,470
‫Denken Sie also daran, dass das richtige

377
00:20:57,470 --> 00:20:59,000
‫Passwort eine asynchrone Funktion

378
00:20:59,000 --> 00:21:01,333
‫ist, und hier müssen wir auch darauf warten.

379
00:21:02,690 --> 00:21:04,530
‫Und dann gibt es

380
00:21:04,530 --> 00:21:06,980
‫noch ein anderes Problem, weil dieser Benutzer

381
00:21:06,980 --> 00:21:10,950
‫hier nicht existiert, dann kann diese nächste Codezeile nicht wirklich laufen, okay?

382
00:21:10,950 --> 00:21:13,550
‫Denn zum Beispiel Benutzer. Passwort wird

383
00:21:13,550 --> 00:21:15,400
‫nicht verfügbar sein.

384
00:21:15,400 --> 00:21:18,800
‫Also müssen wir das alles oder eigentlich nur

385
00:21:18,800 --> 00:21:20,690
‫diesen Code verschieben,

386
00:21:20,690 --> 00:21:24,343
‫wir werden ihn hier in die if else-Anweisung verschieben.

387
00:21:26,740 --> 00:21:29,000
‫In Ordnung, und so, wenn der

388
00:21:29,000 --> 00:21:32,550
‫Benutzer nicht existiert, also wenn dies wahr ist, wird dieser

389
00:21:32,550 --> 00:21:34,900
‫Code hier nicht einmal ausgeführt, und dann

390
00:21:34,900 --> 00:21:37,070
‫wird es kein Problem geben.

391
00:21:37,070 --> 00:21:40,510
‫Aber wenn der Benutzer existiert, dann wird er auch diesen Code

392
00:21:40,510 --> 00:21:43,600
‫ausführen und prüfen, ob das Passwort tatsächlich richtig ist.

393
00:21:43,600 --> 00:21:45,520
‫Wenn also das Passwort

394
00:21:45,520 --> 00:21:50,010
‫korrekt ist, erreichen wir nur in diesem Fall jemals diesen Code hier.

395
00:21:50,010 --> 00:21:52,710
‫Das ist also die ganze Idee dieser Funktion.

396
00:21:52,710 --> 00:21:55,030
‫Im Grunde prüfen wir also auf die Negative.

397
00:21:55,030 --> 00:21:57,270
‫Wenn also keine E-Mail und kein Passwort vorhanden

398
00:21:57,270 --> 00:21:58,880
‫sind, erhalten wir diesen Fehler.

399
00:21:58,880 --> 00:22:01,690
‫Wenn kein Benutzer oder ein falsches Kennwort vorhanden

400
00:22:01,690 --> 00:22:03,540
‫ist, erstellen Sie diesen Fehler.

401
00:22:03,540 --> 00:22:05,610
‫Aber wenn überhaupt kein Fehler aufgetreten

402
00:22:05,610 --> 00:22:09,060
‫ist, dann erreichen wir in diesem Fall diesen Teil des Codes,

403
00:22:09,060 --> 00:22:10,820
‫wo wir nun ein

404
00:22:10,820 --> 00:22:13,490
‫Token generieren und dann an den Benutzer zurücksenden.

405
00:22:13,490 --> 00:22:16,740
‫Das Erstellen dieses Tokens wird jetzt genau das Gleiche sein, wie wir

406
00:22:16,740 --> 00:22:18,500
‫es zuvor hier getan haben.

407
00:22:18,500 --> 00:22:20,780
‫Anstatt also den ganzen Code

408
00:22:20,780 --> 00:22:24,210
‫zu wiederholen, erstellen wir eine Funktion dafür, okay?

409
00:22:24,210 --> 00:22:25,840
‫Also kopiere ich

410
00:22:25,840 --> 00:22:29,427
‫diesen Code, und dann hier ganz schnell

411
00:22:31,900 --> 00:22:36,090
‫const signToken, das als einzige Eingabe die Benutzer-ID erhält.

412
00:22:36,090 --> 00:22:41,090
‫Also ID, und dann wird das Token zurückgegeben, okay?

413
00:22:43,370 --> 00:22:46,793
‫Es wird dies einfach unterschreiben und sofort zurücksenden.

414
00:22:47,700 --> 00:22:50,920
‫In Ordnung, und hier

415
00:22:50,920 --> 00:22:55,920
‫werden wir Token signieren und diese ID übergeben.

416
00:23:04,970 --> 00:23:09,330
‫Und dann müssen wir es natürlich auch hier ändern, okay?

417
00:23:09,330 --> 00:23:11,750
‫Setzen Sie diese ID also auf diese

418
00:23:11,750 --> 00:23:14,893
‫ID, die, wie Sie bereits wissen, mit dieser identisch ist.

419
00:23:15,950 --> 00:23:19,763
‫In Ordnung, und so lasst uns jetzt weitermachen und dasselbe hier tun.

420
00:23:22,547 --> 00:23:26,340
‫signToken, und in diesem Fall ist es user. _Ich würde.

421
00:23:31,300 --> 00:23:33,910
‫Puh, das war ein langer

422
00:23:33,910 --> 00:23:37,090
‫Vortrag, lasst es uns jetzt mal ausprobieren.

423
00:23:37,090 --> 00:23:38,363
‫Also sollte es jetzt funktionieren.

424
00:23:39,250 --> 00:23:43,470
‫Denken Sie also daran, dies ist jetzt ein anderer Benutzer, aber ich weiß, dass

425
00:23:43,470 --> 00:23:46,030
‫dies das Passwort ist, das ich verwendet habe.

426
00:23:46,030 --> 00:23:48,580
‫Also lassen Sie uns für jetzt einen anderen

427
00:23:48,580 --> 00:23:52,003
‫verwenden, also testen wir einfach 12 und sehen wir, was passiert.

428
00:23:53,540 --> 00:23:57,450
‫Warten wir ab, und tatsächlich falsche E-Mail oder Passwort.

429
00:23:57,450 --> 00:24:00,230
‫Und so bekommen wir natürlich auch unsere

430
00:24:00,230 --> 00:24:04,600
‫401, und tatsächlich heißt das, dass unser Code derzeit schon auf

431
00:24:04,600 --> 00:24:05,933
‫das Passwort testet.

432
00:24:06,780 --> 00:24:10,230
‫Wenn wir also jetzt das richtige Passwort wählen, dann sollte

433
00:24:10,230 --> 00:24:12,793
‫es passieren, also warten wir es ab.

434
00:24:13,760 --> 00:24:16,760
‫Aber wir erhalten immer noch diesen Fehler.

435
00:24:16,760 --> 00:24:20,453
‫Also lassen Sie uns einfach alle unsere Benutzer hier loswerden, nur

436
00:24:22,170 --> 00:24:24,420
‫um sicherzustellen, dass es nichts mit

437
00:24:24,420 --> 00:24:28,740
‫den Benutzern zu tun hat, und dann erstellen wir einen neuen, in Ordnung.

438
00:24:33,080 --> 00:24:37,473
‫Also hallo@jonas und pass1234.

439
00:24:38,710 --> 00:24:42,373
‫Machen wir weiter und kopieren es, ich schicke es jetzt.

440
00:24:46,800 --> 00:24:50,070
‫Und so sind diese Anmeldeinformationen jetzt mit Sicherheit korrekt.

441
00:24:50,070 --> 00:24:52,760
‫Wenn es jetzt nicht funktioniert, liegt ein Fehler vor.

442
00:24:52,760 --> 00:24:55,870
‫Aber jetzt hat es tatsächlich funktioniert, super.

443
00:24:55,870 --> 00:25:00,090
‫Hier ist also unser Token, und es sieht genauso aus wie zuvor, sodass wir

444
00:25:00,090 --> 00:25:02,483
‫davon ausgehen können, dass es korrekt ist.

445
00:25:03,570 --> 00:25:06,333
‫Jetzt versuchen wir es noch einmal und löschen das, okay.

446
00:25:07,810 --> 00:25:10,753
‫Also mit dem falschen Passwort geht es nicht.

447
00:25:11,890 --> 00:25:15,423
‫Geben wir jetzt das Passwort richtig und die E-Mail falsch ein, und dann

448
00:25:18,230 --> 00:25:19,730
‫erhalten wir den gleichen Fehler.

449
00:25:19,730 --> 00:25:21,883
‫Also falsche E-Mail oder Passwort.

450
00:25:22,930 --> 00:25:25,560
‫Und wieder, wenn wir alles zurücklegen, dann

451
00:25:25,560 --> 00:25:27,560
‫bekommen wir ein neues Token.

452
00:25:27,560 --> 00:25:30,810
‫Und so sind wir jetzt wirklich in die Anwendung eingeloggt.

453
00:25:30,810 --> 00:25:33,580
‫Und ich weiß, dass dies irgendwie abstrakt aussehen

454
00:25:33,580 --> 00:25:37,340
‫könnte, also bekommen wir nur ein Token, und das bedeutet dann, dass

455
00:25:37,340 --> 00:25:40,020
‫wir bei der Anwendung angemeldet sind, richtig?

456
00:25:40,020 --> 00:25:44,720
‫Aber gut, so funktioniert es bei der zustandslosen Authentifizierung.

457
00:25:44,720 --> 00:25:47,810
‫Später, wenn wir die dynamische Website wirklich erstellen,

458
00:25:47,810 --> 00:25:50,190
‫wird es natürlich viel besser sichtbar

459
00:25:50,190 --> 00:25:53,900
‫sein, wenn der Benutzer entweder eingeloggt oder ausgeloggt ist, oder?

460
00:25:53,900 --> 00:25:55,920
‫Aber es funktioniert immer noch hinter

461
00:25:55,920 --> 00:25:57,670
‫den Kulissen mit demselben Token.

462
00:25:57,670 --> 00:26:01,560
‫Wenn also kein Token vorhanden ist, sieht die Website in eine

463
00:26:01,560 --> 00:26:03,800
‫Richtung aus, und wenn ein Token

464
00:26:03,800 --> 00:26:06,630
‫vorhanden ist, sieht die Website in eine andere

465
00:26:06,630 --> 00:26:11,150
‫Richtung aus, zum Beispiel mit dem Benutzerbild und dem Benutzernamen direkt auf der Website.

466
00:26:11,150 --> 00:26:13,373
‫Jedenfalls war dies ein ziemlich langer Vortrag.

467
00:26:14,370 --> 00:26:17,100
‫Stellen Sie sicher, dass Sie hierher zurückkehren und wirklich

468
00:26:17,100 --> 00:26:20,210
‫versuchen, den gesamten Code, den wir hier haben, zu verstehen, in Ordnung?

469
00:26:20,210 --> 00:26:21,870
‫Weil ich weiß, dass

470
00:26:21,870 --> 00:26:23,660
‫einiges davon etwas verwirrend sein kann.

471
00:26:23,660 --> 00:26:26,963
‫Zum Beispiel diese korrekte Passwort-Funktion hier.

472
00:26:27,850 --> 00:26:30,933
‫Und dann wird für Sie sicher alles Sinn ergeben.

