1
00:00:03,710 --> 00:00:10,135
Dies ist der zweite Teil der Express Sessions Übung.

2
00:00:10,135 --> 00:00:12,320
Wir haben den ersten Teil früher abgeschlossen,

3
00:00:12,320 --> 00:00:15,310
wo wir Unterstützung für Express-Sitzungen hinzugefügt haben,

4
00:00:15,310 --> 00:00:20,340
und verwenden Express Sessions als eine Möglichkeit, die Benutzer auf der Serverseite zu verfolgen

5
00:00:20,340 --> 00:00:24,160
und die eingehenden Anfragen der Benutzer zu erkennen.

6
00:00:24,160 --> 00:00:30,930
In dieser Übung konzentrieren wir uns nicht so sehr auf Express Sessions selbst,

7
00:00:30,930 --> 00:00:36,605
aber wir werden uns eine Möglichkeit ansehen, unseren Express-REST-API-Server zu erweitern, um

8
00:00:36,605 --> 00:00:42,435
ein neues Modell für die Registrierung und Authentifizierung von Benutzern zu unterstützen.

9
00:00:42,435 --> 00:00:48,635
Daher werden wir ein neues Benutzermodell und ein neues Schema in unsere Anwendung einführen.

10
00:00:48,635 --> 00:00:52,295
Wir haben bereits die Slash-User-Route, die

11
00:00:52,295 --> 00:00:57,290
der Express-Generator bereits den Router eines Benutzers montiert hat.

12
00:00:57,290 --> 00:01:00,035
Also, wir werden das nutzen und dann aktualisieren,

13
00:01:00,035 --> 00:01:03,205
um die Registrierung neuer Benutzer zu unterstützen,

14
00:01:03,205 --> 00:01:05,390
einen bestehenden Benutzer zu authentifizieren

15
00:01:05,390 --> 00:01:11,695
und auch einen Benutzer von unserer Serverseite abmelden.

16
00:01:11,695 --> 00:01:17,915
Daher betrachten wir Express Sessions als eine Möglichkeit, die Benutzer zu verfolgen, sobald sich der Benutzer anmeldet,

17
00:01:17,915 --> 00:01:19,820
und wenn sich der Benutzer abmeldet,

18
00:01:19,820 --> 00:01:22,680
wird die Sitzung aus dem System entfernt.

19
00:01:22,680 --> 00:01:27,480
Also, wie machen wir diese Erweiterung in dieser Übung?

20
00:01:27,480 --> 00:01:29,700
Gehen wir und finden es heraus.

21
00:01:29,800 --> 00:01:35,485
Fahren wir mit unserem Express-REST-API-Server fort,

22
00:01:35,485 --> 00:01:41,835
lassen Sie uns nun in die Modelle gehen und eine neue Datei namens user.js hinzufügen.

23
00:01:41,835 --> 00:01:46,440
Dies ist die Datei, in der wir das Benutzerschema und das Modell erstellen.

24
00:01:46,440 --> 00:01:51,405
Wir erstellen ein einfaches Benutzerschema, das den Benutzernamen und das Kennwort verfolgt,

25
00:01:51,405 --> 00:01:55,520
und auch ein Flag, das festgelegt ist, um anzuzeigen,

26
00:01:55,520 --> 00:01:59,540
ob der Benutzer ein Administrator oder ein normaler Benutzer ist.

27
00:01:59,540 --> 00:02:03,660
Dies ist also eine Möglichkeit, zwischen verschiedenen Benutzertypen zu unterscheiden.

28
00:02:03,660 --> 00:02:07,210
Also, in dieser Datei,

29
00:02:07,210 --> 00:02:16,510
lassen Sie uns zuerst Mongoose benötigen, weil wir ein Mongoose-Schema

30
00:02:16,510 --> 00:02:26,710
erstellen, und dann werden wir ein Schema namens Mongoose Schema erstellen,

31
00:02:26,710 --> 00:02:29,720
und dann sagen wir var Benutzer.

32
00:02:29,720 --> 00:02:32,870
Dies ist also das Benutzerschema, das wir erstellen werden,

33
00:02:32,870 --> 00:02:38,150
und wir sagen neues Benutzerschema.

34
00:02:38,150 --> 00:02:42,740
Das Benutzerschema wird definiert, wie ich gerade erwähnt habe,

35
00:02:42,740 --> 00:02:47,705
mit drei Feldern hier namens username,

36
00:02:47,705 --> 00:02:55,755
die offensichtlich vom Typ string sein würde,

37
00:02:55,755 --> 00:02:59,290
und dies ist ein erforderliches Feld,

38
00:02:59,290 --> 00:03:03,975
und dies ist ein eindeutiges Feld.

39
00:03:03,975 --> 00:03:07,580
Sie möchten nicht, dass zwei Benutzer mit dem gleichen Benutzernamen in Ihrem System,

40
00:03:07,580 --> 00:03:12,810
also erstellen wir den Benutzernamen und dann das zweite Feld ist Passwort-Feld.

41
00:03:12,810 --> 00:03:15,259
Nun können Sie

42
00:03:15,259 --> 00:03:19,820
dieses Benutzerschema natürlich erweitern, um dem Benutzer zu ermöglichen, sein gesamtes Profil zu verfolgen,

43
00:03:19,820 --> 00:03:23,985
aber wir werden das in einer der späteren Übungen tun, im Moment

44
00:03:23,985 --> 00:03:30,604
wird ein Benutzer innerhalb des Systems durch einfach den Benutzernamen und das Passwort erkannt.

45
00:03:30,604 --> 00:03:36,290
Das Passwort ist also vom Typ String und wird dann benötigt.

46
00:03:37,300 --> 00:03:44,320
Das dritte Feld, das ich verwenden werde, heißt Admin.

47
00:03:44,320 --> 00:03:48,025
Der Admin ist also vom Typ Boolean,

48
00:03:48,025 --> 00:03:58,270
und wir sagen default false.

49
00:03:58,270 --> 00:04:02,905
Also, standardmäßig, wenn ein Benutzer erstellt wird,

50
00:04:02,905 --> 00:04:04,830
wird ein neuer Benutzer erstellt,

51
00:04:04,830 --> 00:04:06,855
das Admin-Flag wird auf false gesetzt.

52
00:04:06,855 --> 00:04:09,925
Sie können es explizit

53
00:04:09,925 --> 00:04:14,605
in Ihrem Code auf true setzen, um einen Benutzer als Administratorbenutzer zu markieren.

54
00:04:14,605 --> 00:04:18,460
Möglicherweise können Sie einem Administratorbenutzer zusätzliche Berechtigungen bereitstellen

55
00:04:18,460 --> 00:04:21,230
oder Administratorbenutzer erlauben,

56
00:04:21,230 --> 00:04:24,810
bestimmte Vorgänge auszuführen, die normale Benutzer dies nicht tun würden.

57
00:04:24,810 --> 00:04:27,760
Wir werden das in einer der späteren Übungen betrachten, im

58
00:04:27,760 --> 00:04:31,500
Moment ist dies das Benutzerschema, das wir erstellt haben,

59
00:04:31,500 --> 00:04:38,150
lassen Sie uns ein Modul daraus erstellen und aus

60
00:04:38,150 --> 00:04:47,075
diesem Modul ein Mongoose-Modell des Namens Benutzer exportieren.

61
00:04:47,075 --> 00:04:51,115
Dies ist also das Mongoose-Modell und das Schema ist

62
00:04:51,115 --> 00:04:55,840
das Benutzerschema, das wir gerade ein wenig früher definiert haben.

63
00:04:55,840 --> 00:05:00,615
So definieren wir unser Benutzerschema.

64
00:05:00,615 --> 00:05:03,770
Also, jetzt, da wir unser Benutzerschema definiert haben,

65
00:05:03,770 --> 00:05:08,660
gehen wir in den Router, der bereits

66
00:05:08,660 --> 00:05:15,610
von Express-Generator eingerichtet wurde, wenn es diese Express-Anwendung generiert.

67
00:05:15,610 --> 00:05:17,775
Wenn Sie also in den Routenordner gehen,

68
00:05:17,775 --> 00:05:20,890
sehen Sie diese Datei namens users.js.

69
00:05:20,890 --> 00:05:26,780
Also, diese users.js Datei wird erweitert, um den Router zu erstellen.

70
00:05:26,780 --> 00:05:36,720
Also, genau dort, was ich tun werde, ist Bodyy-Parser zu importieren,

71
00:05:41,510 --> 00:05:46,395
und dann werden sie den Express-Router deklarieren,

72
00:05:46,395 --> 00:05:50,145
und dann werden wir sagen, auch

73
00:05:50,145 --> 00:05:57,100
das Benutzerschema und das

74
00:05:57,100 --> 00:06:03,420
Modell von Modellen Benutzer importieren,

75
00:06:03,950 --> 00:06:09,220
und dann für den Express-Router sagen wir,

76
00:06:09,220 --> 00:06:13,380
Router verwenden Body Parser.

77
00:06:16,190 --> 00:06:20,690
Nun, da wir den Body Parser dort deklariert haben, werden

78
00:06:20,690 --> 00:06:23,650
wir diesen Teil als solchen verlassen.

79
00:06:23,650 --> 00:06:28,040
Später werden wir dies ändern, damit der Administrator in der

80
00:06:28,040 --> 00:06:30,470
Lage sein kann,

81
00:06:30,470 --> 00:06:33,750
alle Benutzer abzurufen, die im System registriert sind, aber im Moment werden

82
00:06:33,750 --> 00:06:37,705
wir diese Route als solche verlassen.

83
00:06:37,705 --> 00:06:40,500
Wir werden hier ein paar weitere Routen hinzufügen,

84
00:06:40,500 --> 00:06:42,965
also sagen wir: „Router-Post“.

85
00:06:42,965 --> 00:06:49,970
Daher unterstützen wir den Post-Vorgang auf einer Route namens Anmeldung und wie Sie erwarten,

86
00:06:49,970 --> 00:06:55,790
wird diese Anmelderoute einem Benutzer erlauben, sich auf dem System anzumelden,

87
00:06:55,790 --> 00:07:04,920
so dass dies die Anmeldung des Benutzers unterstützt.

88
00:07:04,920 --> 00:07:08,355
Also sagen wir: „Rec, res, next.“

89
00:07:08,355 --> 00:07:16,090
Und so wäre dies die Router-Post-Anmeldung,

90
00:07:16,590 --> 00:07:23,410
die restlichen Methoden werden auf dem Anmeldeende nicht erlaubt sein.

91
00:07:23,410 --> 00:07:25,865
Also, um darauf zuzugreifen,

92
00:07:25,865 --> 00:07:31,420
da dieser Benutzer Router auf Schrägstrich Benutzer gemountet ist,

93
00:07:31,420 --> 00:07:35,645
würden wir diesen Endpunkt als Schrägstrich Benutzer Schrägstrich Anmeldung angeben,

94
00:07:35,645 --> 00:07:41,765
und dies ist der Endpunkt, der verwendet wird, um neue Benutzer innerhalb des Systems zu registrieren.

95
00:07:41,765 --> 00:07:45,080
Also, zuerst, was wir tun werden, ist

96
00:07:45,080 --> 00:07:53,300
die Benutzermethode zu verwenden und die Erwartung ist, dass für einen Benutzer, um sich

97
00:07:53,300 --> 00:07:58,145
anzumelden, der Benutzername und das Passwort als JSON-Zeichenfolge

98
00:07:58,145 --> 00:08:03,185
innerhalb des Hauptteils der eingehenden Postanforderung zur Verfügung gestellt werden.

99
00:08:03,185 --> 00:08:05,160
Also, aus dem Körper,

100
00:08:05,160 --> 00:08:10,370
da der Körper bereits vom Body Parser analysiert worden wäre,

101
00:08:10,370 --> 00:08:13,920
wird also vom Körper zuerst überprüfen, um sicherzustellen, dass

102
00:08:13,920 --> 00:08:22,130
der Benutzer mit diesem Benutzernamen nicht im System existiert.

103
00:08:22,130 --> 00:08:24,380
Wenn der Benutzer mit diesem Benutzernamen vorhanden ist,

104
00:08:24,380 --> 00:08:26,900
versuchen Sie, einen doppelten Benutzer zu registrieren

105
00:08:26,900 --> 00:08:29,715
, der im System nicht erlaubt sein sollte.

106
00:08:29,715 --> 00:08:37,340
Wir werden also sagen, „Benutzer finden einen“, und dann werden wir versuchen zu finden, ob

107
00:08:37,340 --> 00:08:41,090
es einen Benutzer mit dem Benutzernamen gibt,

108
00:08:41,090 --> 00:08:45,405
der vom Client ausgewählt wurde, der versucht, einen neuen Benutzer zu registrieren.

109
00:08:45,405 --> 00:08:47,020
Wenn der Benutzer bereits existiert,

110
00:08:47,020 --> 00:08:51,850
erlauben Sie dem neuen Benutzer offensichtlich nicht, sich mit demselben Benutzernamen anzumelden.

111
00:08:51,850 --> 00:08:55,665
Also, wir werden sagen: „Dann Benutzer.“

112
00:08:55,665 --> 00:09:03,295
Also, dies wird den Benutzer hier und in diesem Benutzerfeld zurückgeben,

113
00:09:03,295 --> 00:09:09,080
dann werden wir prüfen, ob der Benutzer bereits existiert,

114
00:09:09,080 --> 00:09:12,350
und lassen Sie mich dann den Fehler hier abfangen.

115
00:09:12,350 --> 00:09:19,140
Also sagen wir: „Fehler fangen“ und dann „nächster Fehler“.

116
00:09:19,140 --> 00:09:26,160
Also, wir geben das einfach an den Fehler-Handler dort weiter.

117
00:09:26,160 --> 00:09:33,345
Also, wenn diese Suche nach dem Benutzer das Benutzerfeld zurückgibt,

118
00:09:33,345 --> 00:09:40,460
wenn der Benutzer nicht gleich null ist.

119
00:09:40,460 --> 00:09:45,170
Wenn also der Benutzer, der von dieser Suche zurückgegeben wird,

120
00:09:45,170 --> 00:09:50,510
nicht null ist, bedeutet das, dass der Benutzer mit diesem angegebenen Benutzernamen bereits existiert,

121
00:09:50,510 --> 00:09:53,420
also sollten Sie keine doppelte Anmeldung zulassen.

122
00:09:53,420 --> 00:09:58,765
Also sagen wir: „Var irr neuen Fehler.“

123
00:09:58,765 --> 00:10:09,075
Und wir werden sagen: „Benutzer req. body username.“

124
00:10:09,075 --> 00:10:15,410
Es ist bereits vorhanden. Also im Grunde

125
00:10:15,410 --> 00:10:20,565
verhindern Sie, dass sich ein doppelter Benutzer registriert und dann sagen wir

126
00:10:20,565 --> 00:10:29,280
err.status 403 gegen das Verbotene und beenden Sie dann

127
00:10:29,280 --> 00:10:33,735
den Fehler-Handler aufrufen, nächster Fehler.

128
00:10:33,735 --> 00:10:36,880
Andernfalls bedeutet dies, dass der Benutzer nicht existiert,

129
00:10:36,880 --> 00:10:39,670
daher sollten Sie zulassen, dass der Benutzer abgemeldet wird.

130
00:10:39,670 --> 00:10:41,950
Also, im anderen Teil,

131
00:10:41,950 --> 00:10:46,150
werden wir sagen, user.create () zurückgeben.

132
00:10:47,200 --> 00:10:56,165
Wir erstellen einen neuen Benutzer mit dem Benutzernamen, der auf req.body.username gesetzt ist,

133
00:10:56,165 --> 00:11:02,555
und lassen Sie mich das dann in die nächste Zeile setzen, so dass es Ihnen klarer ist,

134
00:11:02,555 --> 00:11:09,620
und wir sagen password: req.body.password.

135
00:11:09,620 --> 00:11:14,550
Jetzt wissen wir bereits, dass das Admin-Flag standardmäßig auf false gesetzt wird,

136
00:11:14,550 --> 00:11:17,700
also werden wir es als solche verlassen,

137
00:11:17,730 --> 00:11:28,175
und dies wird unseren neuen Benutzer registrieren lassen und wenn der neue Benutzer angemeldet ist,

138
00:11:28,175 --> 00:11:37,880
wird dies ein Versprechen zurückgeben und innerhalb des „dann“ werden wir dieses Versprechen hier behandeln.

139
00:11:37,880 --> 00:11:41,460
Also, dies wird das Versprechen von

140
00:11:41,460 --> 00:11:45,625
diesem „dann“ zurückgeben und dann werden wir es im nächsten „dann“ hier behandeln.

141
00:11:45,625 --> 00:12:02,120
Wird dann sagen, res.StatusCode ist 200,

142
00:12:02,120 --> 00:12:10,640
res.setHeader und wir sagen Content-Typ application/json

143
00:12:19,830 --> 00:12:38,000
und wir werden sagen, res.json (Status: Registrierung erfolgreich),

144
00:12:42,960 --> 00:12:45,760
und wenn Sie möchten,

145
00:12:45,760 --> 00:12:49,659
können wir den Benutzer in

146
00:12:49,659 --> 00:12:58,270
diese Antwortnachricht hier als Eigenschaft in der json laden.

147
00:13:02,790 --> 00:13:06,890
Wird die Registrierung erfolgreich aussagen.

148
00:13:07,830 --> 00:13:14,950
Dann, wenn es einen Fehler in

149
00:13:14,950 --> 00:13:22,790
dieser Operation gibt, wird sagen „next irr“.

150
00:13:22,790 --> 00:13:25,200
Das wird also den Fehler behandeln.

151
00:13:25,440 --> 00:13:29,220
Wenn das Versprechen nicht erfolgreich gelöst

152
00:13:29,220 --> 00:13:32,020
wird, wird dadurch behandelt. Das war's also.

153
00:13:32,020 --> 00:13:36,150
Also hier haben wir eine Möglichkeit für den Benutzer, sich anzumelden.

154
00:13:36,150 --> 00:13:38,280
Damit sich der Benutzer anmelden kann,

155
00:13:38,280 --> 00:13:46,570
wird der Benutzer einen Beitrag auf /users/signup machen und im Hauptteil der Nachricht

156
00:13:46,570 --> 00:13:51,810
enthält der Client eine JSON-Zeichenfolge

157
00:13:51,810 --> 00:13:57,760
mit Benutzername und Kennwort Eigenschaften in dieser JSON-Zeichenfolge.

158
00:13:57,760 --> 00:14:01,200
So melden Sie sich für einen neuen Benutzer an.

159
00:14:01,200 --> 00:14:06,135
Nun, lassen Sie uns sehen, wie wir den Benutzer einloggen werden.

160
00:14:06,135 --> 00:14:14,605
Jetzt werden wir weiterhin die Express-Sitzungen verwenden, die wir zuvor durchgeführt haben, um den Benutzer zu verfolgen.

161
00:14:14,605 --> 00:14:24,270
Also, zum Protokollieren eines Benutzers wird „router.post“ auf dem Endpunkt/Login sagen.

162
00:14:24,820 --> 00:14:29,370
Also auf dem /login Endpunkt,

163
00:14:32,280 --> 00:14:35,800
werden wir einen router.post.

164
00:14:35,800 --> 00:14:42,460
Wir werden offensichtlich, anstatt Funktion zu sagen,

165
00:14:42,460 --> 00:14:48,575
können Sie die Pfeilfunktion hier für den router.post verwenden,

166
00:14:48,575 --> 00:14:50,780
ich werde das Gleiche hier tun.

167
00:14:50,780 --> 00:14:53,930
Ich habe Pfeilfunktionen geliebt.

168
00:14:53,930 --> 00:14:57,125
Also, wir werden hier eine Pfeilfunktion machen.

169
00:14:57,125 --> 00:15:00,080
Also für den Login, wie geht der Login vor?

170
00:15:00,080 --> 00:15:01,880
Also für die Anmeldung,

171
00:15:01,880 --> 00:15:10,850
was wir tun werden, ist, dass wir zur Datei app.js gehen und dann innerhalb dieser Auth

172
00:15:11,760 --> 00:15:17,050
haben wir diese Anmeldung für den Benutzer dort gemacht.

173
00:15:17,050 --> 00:15:20,315
Also, was ich tun werde, ist, dass ich die

174
00:15:20,315 --> 00:15:25,730
ganze Sache kopieren werde, weil ich das sowieso nicht tun würde.

175
00:15:25,730 --> 00:15:32,970
Also, lassen Sie mich lieber den ganzen Weg von diesem Punkt an bis zum req.session.user kopieren.

176
00:15:32,970 --> 00:15:36,925
Also, der if Teil von req.session.user werde ich kopieren,

177
00:15:36,925 --> 00:15:44,120
und dann zu der users.js und für die Anmeldung kommen.

178
00:15:44,120 --> 00:15:47,305
Es ist genau, wie ich die Authentifizierung machen werde.

179
00:15:47,305 --> 00:15:51,025
Also sagen wir, wenn nicht req.session.user.

180
00:15:51,025 --> 00:15:55,965
Das bedeutet, dass sich der Benutzer noch nicht authentifiziert hat.

181
00:15:55,965 --> 00:15:59,420
Dann erwarten Sie, dass die Standardauthentifizierung

182
00:15:59,420 --> 00:16:02,780
als Mechanismus für die Authentifizierung verwendet wird.

183
00:16:02,780 --> 00:16:07,890
Also sagen wir var AuthHeader if! AuthHeader dann werden wir den Fehler auslösen,

184
00:16:07,890 --> 00:16:17,760
sonst werden wir den Benutzernamen und das Passwort aus dem Header abrufen.

185
00:16:17,760 --> 00:16:25,235
Nun, hier haben wir getan, wenn Benutzername gleich admin und Passwort gleich Passwort ist.

186
00:16:25,235 --> 00:16:30,535
Aber jetzt, was wir tun werden, ist, dass wir in

187
00:16:30,535 --> 00:16:36,695
der Datenbank suchen, um zu sehen, ob dieser bestimmte Benutzer existiert.

188
00:16:36,695 --> 00:16:39,595
Also, anstatt dies hier zu tun,

189
00:16:39,595 --> 00:16:42,995
anstatt dies zu tun, wenn Benutzername und Passwort,

190
00:16:42,995 --> 00:16:48,380
werden wir sagen, User.Findone

191
00:16:49,650 --> 00:16:56,020
und wir werden sagen, Benutzername ist Benutzername.

192
00:16:56,020 --> 00:17:00,730
Also diese Eigenschaft ist gleich diesem Benutzernamen, den wir gerade abgerufen haben

193
00:17:00,730 --> 00:17:06,820
und dann sagen wir dann Benutzer.

194
00:17:09,770 --> 00:17:18,600
Also in diesem „dann“.

195
00:17:18,600 --> 00:17:23,110
Also werde ich diesen Code innerhalb dieses „Dann“ verschieben,

196
00:17:23,110 --> 00:17:28,395
denn jetzt werde ich überprüfen, nachdem ich den Benutzer abgerufen habe.

197
00:17:28,395 --> 00:17:35,625
Ich muss überprüfen, ob dieser Benutzer genau das ist, was ich suche.

198
00:17:35,625 --> 00:17:37,405
Also an diesem Punkt

199
00:17:37,405 --> 00:17:42,485
werden wir zuerst überprüfen, um sicherzustellen, dass der Benutzer nicht null ist.

200
00:17:42,485 --> 00:17:49,915
Also werden wir sagen, wenn der Benutzer null ist.

201
00:17:49,915 --> 00:17:51,390
Also, wenn der Benutzer null ist,

202
00:17:51,390 --> 00:17:55,930
was bedeutet, dass wir keinen Benutzer mit diesem bestimmten Benutzernamen finden konnten.

203
00:17:55,930 --> 00:17:59,860
Sie müssen also hier einen Fehler zurückgeben.

204
00:17:59,860 --> 00:18:04,540
Also lassen Sie mich einfach diesen Teil kopieren und dann fügen Sie ihn

205
00:18:04,540 --> 00:18:09,840
hier ein und dann werden wir sagen var new Error sagen

206
00:18:09,840 --> 00:18:14,575
und wir werden sagen, dass der

207
00:18:14,575 --> 00:18:23,120
Benutzername

208
00:18:23,580 --> 00:18:28,750
nicht existiert.

209
00:18:28,750 --> 00:18:30,600
In diesem Fall

210
00:18:30,600 --> 00:18:35,230
existiert dieser Benutzer nicht, also werde ich nur diesen Teil entfernen und

211
00:18:35,230 --> 00:18:41,840
dann wäre der entsprechende Fehlerstatus hier 403.

212
00:18:42,450 --> 00:18:44,960
Das ist also der erste Teil.

213
00:18:44,960 --> 00:18:55,000
Wenn der Benutzer null ist, dann werden wir offensichtlich sagen, dass der Benutzer nicht existiert.

214
00:18:55,000 --> 00:19:03,780
Der zweite Teil, den wir überprüfen werden, ist Else, wenn Benutzerpasswort.

215
00:19:03,780 --> 00:19:06,800
Das bedeutet also, dass der Benutzer an dieser Stelle existiert.

216
00:19:06,800 --> 00:19:12,420
Also, die zweite Überprüfung, die wir tun werden, ist, dass das Benutzerpasswort nicht

217
00:19:12,420 --> 00:19:22,330
gleich Passwort ist dann.

218
00:19:22,330 --> 00:19:25,090
Wir müssen wieder den Fehler dort anzeigen.

219
00:19:25,090 --> 00:19:28,820
Der Fehler würde also sagen,

220
00:19:29,790 --> 00:19:34,570
in diesem Fall sagen wir

221
00:19:34,570 --> 00:19:41,390
„Ihr Passwort ist falsch“.

222
00:19:41,390 --> 00:19:44,085
Das ist also der zweite Teil hier.

223
00:19:44,085 --> 00:19:49,650
So ist Ihr Passwort falsch und dann der letzte Teil.

224
00:19:49,650 --> 00:19:52,515
Wir werden „sonst“ sagen.

225
00:19:52,515 --> 00:19:59,755
Also lassen Sie mich diesen Code einrücken.

226
00:19:59,755 --> 00:20:05,775
Also, wenn user.username

227
00:20:05,775 --> 00:20:15,815
Benutzername ist, was offensichtlich in diesem Fall wahr sein sollte.

228
00:20:15,815 --> 00:20:17,990
Dann

229
00:20:17,990 --> 00:20:27,620
ist der zweite Teil user.password gleich Passwort, das auch offensichtlich an dieser Stelle korrekt sein sollte.

230
00:20:27,620 --> 00:20:29,720
Aber auf jeden Fall

231
00:20:29,720 --> 00:20:38,885
werde ich hier nach diesem Problem suchen und das sonst wird in diesem Fall überhaupt nicht auftreten.

232
00:20:38,885 --> 00:20:41,695
Also, wenn Sie diesen Punkt erreichen,

233
00:20:41,695 --> 00:20:45,410
sollte der Benutzername der

234
00:20:45,410 --> 00:20:48,980
gleiche sein wie der Benutzername und das Passwort sollte das gleiche wie ein Passwort sein,

235
00:20:48,980 --> 00:20:55,240
aber in jedem Fall habe ich an dieser Stelle einen doppelten Check eingelegt, nur um doppelt sicher zu sein.

236
00:20:55,240 --> 00:20:56,590
Dann

237
00:20:56,590 --> 00:21:02,765
sagen wir in diesem Fall, dass req.session.user authentifiziert ist.

238
00:21:02,765 --> 00:21:05,440
Also, wir werden dies auf authentifiziert setzen

239
00:21:05,440 --> 00:21:16,480
und auch diese, wir werden sagen

240
00:21:16,480 --> 00:21:18,660
res.StatusCode ist 200.

241
00:21:18,660 --> 00:21:21,870
So konnten wir den Benutzer erfolgreich authentifizieren.

242
00:21:21,870 --> 00:21:29,030
Also, wir sagen res.StatusCode ist 200 und dann sagen wir res.setHeader

243
00:21:30,540 --> 00:21:43,690
Content-Type Text plain und

244
00:21:43,690 --> 00:21:51,500
res.end wir werden einfach eine Nachricht senden, die sagt „Sie sind authentifiziert“.

245
00:21:53,700 --> 00:22:00,825
Das war's. Dies deckt also den dann Teil des Benutzers FindOnE ab.

246
00:22:00,825 --> 00:22:05,360
Also zuerst überprüfen wir, dass, wenn der Benutzer null ist,

247
00:22:05,360 --> 00:22:07,410
das bedeutet, dass wir den Benutzer nicht finden konnten,

248
00:22:07,410 --> 00:22:12,025
also geben wir offensichtlich einen Fehler zurück, der besagt, dass der Benutzername nicht existiert.

249
00:22:12,025 --> 00:22:15,195
Wenn das Passwort des Benutzers nicht mit dem Passwort übereinstimmt,

250
00:22:15,195 --> 00:22:16,450
also an diesem Punkt,

251
00:22:16,450 --> 00:22:19,150
der Benutzer existiert, aber das Passwort stimmt nicht überein, also sagen wir:

252
00:22:19,150 --> 00:22:22,640
„Ihr Passwort ist falsch“, und dann, schließlich,

253
00:22:22,640 --> 00:22:29,050
wir erreichen diesen Punkt dann der Benutzername und das Passwort korrekt identifiziert werden.

254
00:22:29,330 --> 00:22:35,780
Obwohl ich diese Überprüfung nicht brauche, aber ich habe sie einfach dort platziert und dann an dieser Stelle

255
00:22:35,780 --> 00:22:38,680
werde ich den req.session.user so einstellen, dass

256
00:22:38,680 --> 00:22:41,830
er ihn authentifiziert und dann den Statuscode auf 200 gesetzt, was bedeutet, dass Sie

257
00:22:41,830 --> 00:22:48,880
den Benutzer erfolgreich authentifizieren konnten und dann an diesem Punkt fertig werden können.

258
00:22:48,880 --> 00:22:51,490
Da dies ein dann ist,

259
00:22:51,490 --> 00:22:54,685
werde ich an diesem Punkt einen Haken setzen,

260
00:22:54,685 --> 00:23:03,845
also sagen wir catch-Fehler und wenn der Fehler auftritt,

261
00:23:03,845 --> 00:23:09,130
dann werde ich den Fehler einfach an den

262
00:23:09,130 --> 00:23:14,560
nächsten übergeben, so

263
00:23:14,560 --> 00:23:20,090
dass der Fehler-Handler in der Lage sein wird, den Fehler angemessen zu behandeln.

264
00:23:20,090 --> 00:23:24,415
Das beendet diesen Benutzer FindOnE.

265
00:23:24,415 --> 00:23:31,020
Dies ist nun der Fall, wenn die req.session.user nicht gesetzt ist.

266
00:23:31,020 --> 00:23:32,905
Wenn das bereits gesetzt ist,

267
00:23:32,905 --> 00:23:38,095
bedeutet das, dass der Benutzer bereits angemeldet ist.

268
00:23:38,095 --> 00:23:40,630
In diesem Fall

269
00:23:40,630 --> 00:23:50,650
befasst sich der andere Teil hier mit der Situation, die besagt, dass wir

270
00:23:50,650 --> 00:23:52,660
den StatusCode auf 200

271
00:23:52,660 --> 00:24:12,205
und den Content-Type auf text/plain setzen und dann sagen wir:

272
00:24:12,205 --> 00:24:17,680
„Sie sind bereits authentifiziert.“

273
00:24:17,680 --> 00:24:21,910
Also, wenn Sie diesen anderen Teil erreichen,

274
00:24:22,690 --> 00:24:29,060
würden Sie hierher kommen, weil der req.session.user bereits nicht null ist,

275
00:24:29,060 --> 00:24:32,150
was bedeutet, dass der Benutzer bereits authentifiziert wurde,

276
00:24:32,150 --> 00:24:34,995
also wenn Sie diesen Punkt erreichen,

277
00:24:34,995 --> 00:24:38,200
hat sich der Benutzer bereits früher angemeldet,

278
00:24:38,200 --> 00:24:41,100
so dass Sie nicht überprüfen müssen.

279
00:24:41,100 --> 00:24:42,220
Sie werden also einfach sagen:

280
00:24:42,220 --> 00:24:46,270
„Sie sind bereits authentifiziert“ und dann an dieser Stelle beenden.

281
00:24:46,270 --> 00:24:54,975
Ok. Jetzt ist die letzte Methode, die wir implementieren werden, um den Benutzer abzumelden.

282
00:24:54,975 --> 00:24:59,180
Also, wir werden einen router.get on /logout.

283
00:24:59,180 --> 00:25:02,170
Sie müssen sich fragen, warum tun wir ein get auf

284
00:25:02,170 --> 00:25:07,000
der Abmeldung anstatt einen Beitrag, den wir auf Login getan haben?

285
00:25:07,000 --> 00:25:11,090
Bei der Anmeldung müssen Sie den Benutzernamen und das Passwort einreichen.

286
00:25:11,090 --> 00:25:14,900
Für die Abmeldung melden Sie sich einfach selbst vom System ab,

287
00:25:14,900 --> 00:25:17,590
so dass Sie keine weiteren Informationen angeben müssen, da

288
00:25:17,590 --> 00:25:20,910
der Server Sie bereits basierend auf

289
00:25:20,910 --> 00:25:30,665
Ihrer Sitzungs-ID und in diesem Sitzungs-Cookie hier verfolgt.

290
00:25:30,665 --> 00:25:32,620
Deshalb

291
00:25:32,620 --> 00:25:38,890
müssen wir nicht explizit weitere Informationen im Nachrichtentext senden.

292
00:25:38,890 --> 00:25:46,120
Also sagen wir, wenn req.session so was bedeutet, dass die Sitzung existieren muss

293
00:25:46,120 --> 00:25:50,070
, andernfalls versuchen Sie, einen Benutzer abzumelden, der sich nicht angemeldet hat.

294
00:25:50,070 --> 00:25:52,280
Es ergibt also keinen Sinn.

295
00:25:52,280 --> 00:25:57,490
Nun stellt die Sitzung selbst diese Methode

296
00:25:57,490 --> 00:26:03,415
namens destroy bereit, und wenn Sie die Destroy-Methode aufrufen,

297
00:26:03,415 --> 00:26:07,520
wird die Sitzung zerstört und die Informationen werden

298
00:26:07,520 --> 00:26:12,945
von der Serverseite entfernt, die sich auf diese Sitzung bezieht.

299
00:26:12,945 --> 00:26:16,970
Wenn also der Client versucht, die

300
00:26:16,970 --> 00:26:19,190
Sitzungsinformationen, die in Form

301
00:26:19,190 --> 00:26:21,430
eines signierten Cookies auf der Clientseite gespeichert sind, erneut zu senden, ist

302
00:26:21,430 --> 00:26:22,640
dies ungültig.

303
00:26:22,640 --> 00:26:27,870
Daher benötigen wir eine Methode zum Löschen des Cookies, das auf der Client-Seite gespeichert wird.

304
00:26:27,870 --> 00:26:31,110
Mit diesem Vorgang werden nun

305
00:26:31,110 --> 00:26:36,805
die Sitzungsinformationen von der Serverseite entfernt, so dass die Sitzung nicht mehr gültig ist.

306
00:26:36,805 --> 00:26:38,060
Also, an dieser Stelle

307
00:26:38,060 --> 00:26:45,115
werden wir sagen req.session.destroy und dann sagen wir, res.clearCookie.

308
00:26:45,115 --> 00:26:49,640
Das ClearCookie ist also eine Möglichkeit, den Client zu bitten,

309
00:26:49,640 --> 00:26:54,875
das Cookie zu entfernen und der Cookie-Name ist die Sitzungs-ID.

310
00:26:54,875 --> 00:26:56,630
In der vorherigen Übung

311
00:26:56,630 --> 00:27:00,910
haben wir gesehen, dass das Cookie mit dem Namen der Sitzungs-ID auf der Clientseite gespeichert wurde.

312
00:27:00,910 --> 00:27:05,430
Also bitten wir den Client, dieses Cookie von

313
00:27:05,430 --> 00:27:10,935
der Client-Seite in der Antwortnachricht zu löschen und dann sagen wir,

314
00:27:10,935 --> 00:27:16,835
res.redirect und wir werden es auf die Homepage hier umleiten.

315
00:27:16,835 --> 00:27:21,540
Dies ist also eine Möglichkeit, den Benutzer zu leiten, um seine Standardseite einzugeben,

316
00:27:21,540 --> 00:27:24,790
also zum Beispiel die Homepage Ihrer Anwendung.

317
00:27:24,790 --> 00:27:31,090
Also, so würden Sie die Abmeldung des Systems behandeln.

318
00:27:31,090 --> 00:27:33,200
Wenn die req.session nicht existiert,

319
00:27:33,200 --> 00:27:35,380
bedeutet das, dass Sie nicht angemeldet sind,

320
00:27:35,380 --> 00:27:37,310
daher müssen wir einen Fehler generieren.

321
00:27:37,310 --> 00:27:38,945
Also sagen wir var err,

322
00:27:38,945 --> 00:27:46,370
new Error, „Sie sind nicht angemeldet“,

323
00:27:47,100 --> 00:27:52,615
und wir setzen den Fehlerstatus auf 403,

324
00:27:52,615 --> 00:27:54,760
dies ist eine verbotene Operation und

325
00:27:54,760 --> 00:28:01,060
generieren dann den Fehler an den Fehler-Handler, das war's.

326
00:28:01,060 --> 00:28:08,830
Jetzt sehen Sie, dass wir den Router des Benutzers erweitert haben, um drei neue Endpunkte zu unterstützen, den

327
00:28:08,830 --> 00:28:13,330
Anmeldeendpunkt, der es einem Benutzer ermöglicht, sich

328
00:28:13,330 --> 00:28:17,785
anzumelden, den Anmeldeendpunkt, der es einem angemeldeten Benutzer ermöglicht, sich anzumelden,

329
00:28:17,785 --> 00:28:24,730
und dann den Abmeldeendpunkt, der es einem angemeldeten Benutzer ermöglicht, sich vom System abzumelden. Wenn Sie

330
00:28:24,730 --> 00:28:26,970
sich abmelden,

331
00:28:26,970 --> 00:28:29,340
zerstören Sie die Sitzung auf der Serverseite,

332
00:28:29,340 --> 00:28:31,890
löschen Sie auch das Cookie auf der Clientseite,

333
00:28:31,890 --> 00:28:40,350
so dass der Client nicht in abgelaufener Sitzung verwendet werden kann, um zu versuchen, diesen Server zu kontaktieren.

334
00:28:40,350 --> 00:28:43,480
Eine kleine Korrektur in users.js,

335
00:28:43,480 --> 00:28:49,225
dies sollte var Benutzer erfordern.. /models/user,

336
00:28:49,225 --> 00:28:58,095
erinnern Sie sich daran, dass sich die Datei users.js im Ordner routes befindet und

337
00:28:58,095 --> 00:29:01,130
sich dann die Datei user.js im

338
00:29:01,130 --> 00:29:07,440
Ordner models befindet, der sich auf einer Ebene befindet und dann in den Ordner models.

339
00:29:07,440 --> 00:29:11,620
Also, das sollte sein.. /models/user,

340
00:29:11,620 --> 00:29:15,655
also machen Sie diese kleine Korrektur, das ist es.

341
00:29:15,655 --> 00:29:19,040
Wir haben die Datei users.js geändert,

342
00:29:19,040 --> 00:29:23,690
jetzt ist das letzte, was wir tun müssen, gehen und reparieren Sie die Datei app.js.

343
00:29:23,690 --> 00:29:25,965
In der App app.js Datei,

344
00:29:25,965 --> 00:29:29,520
wenn Sie in die Datei app.js navigieren,

345
00:29:29,520 --> 00:29:31,160
würden Sie sehen, dass wir

346
00:29:31,160 --> 00:29:37,240
diesen Schrägstrich Index hier und Schrägstrich Benutzer hier nach der Authentifizierung.

347
00:29:37,240 --> 00:29:43,360
Nun, das wird für uns nicht funktionieren, denn wenn Sie sich anmelden müssen,

348
00:29:43,360 --> 00:29:49,140
würde sich der Benutzer anmelden und sich anmelden, bevor die Autorisierung bestätigt wird,

349
00:29:49,140 --> 00:29:54,910
trotzdem wenn die Anmeldung und Anmeldung für den Prozess der Anmeldung ist,

350
00:29:54,910 --> 00:30:04,295
also werde ich diese vor dem Authentifizierungsschritt hier nach oben verschieben.

351
00:30:04,295 --> 00:30:09,280
Also, wir werden das hier in diesen Ort bringen.

352
00:30:09,280 --> 00:30:15,430
So kann ein eingehender Benutzer auf die Indexdatei

353
00:30:15,430 --> 00:30:21,589
am Schrägstrich zugreifen und auch auf den Endpunkt des Benutzers zugreifen, ohne authentifiziert zu werden,

354
00:30:21,589 --> 00:30:23,205
aber jeder andere Endpunkt,

355
00:30:23,205 --> 00:30:25,400
der Benutzer muss authentifiziert werden,

356
00:30:25,400 --> 00:30:28,665
so dass ist die Art und Weise, wie wir dies einrichten.

357
00:30:28,665 --> 00:30:32,375
Innerhalb der Funktion Authentifizierung, werden wir sagen,

358
00:30:32,375 --> 00:30:40,695
„Wenn nicht req.session.user,“ dann bemerken, dass dieser Ort,

359
00:30:40,695 --> 00:30:47,980
würden wir nicht zulassen, dass der Benutzer hier kommen, ohne dass der Benutzer angemeldet ist.

360
00:30:47,980 --> 00:30:50,450
Also, wenn nicht req.session.user,

361
00:30:50,450 --> 00:30:55,170
dann würden wir einfach sagen, dass Sie nicht authentifiziert sind.

362
00:31:03,600 --> 00:31:09,330
Diese Authentifizierung muss mit der Anmeldemethode hier durchgeführt werden.

363
00:31:09,330 --> 00:31:13,510
Also, ich werde diesen ganzen Teil hier entfernen.

364
00:31:17,340 --> 00:31:22,285
Also, wir werden sagen, wenn nicht req.session.user,

365
00:31:22,285 --> 00:31:28,670
wir werden sagen, dass Sie nicht authentifiziert sind und so müssen wir ein Foto drei hier senden,

366
00:31:28,670 --> 00:31:31,560
was bedeutet, dass Sie nie zu diesem Punkt kommen sollten,

367
00:31:31,560 --> 00:31:34,785
ohne dass sich der Benutzer einloggt.

368
00:31:34,785 --> 00:31:37,575
Also, wir sagen, dass Sie nicht authentifiziert sind. Denken Sie

369
00:31:37,575 --> 00:31:41,990
daran, dass Sie sich authentifizieren müssen, indem Sie einen POST für

370
00:31:41,990 --> 00:31:47,120
den Schrägstrich Benutzer Anmelde-Endpunkt.

371
00:31:47,120 --> 00:31:50,930
Wir werden also sagen, dass Sie nicht authentifiziert sind, andernfalls,

372
00:31:50,930 --> 00:31:56,175
wenn req.session.user gleich ist,

373
00:31:56,175 --> 00:32:01,720
erinnern Sie sich, dass

374
00:32:01,720 --> 00:32:07,780
wir in der Login-Funktion in der users.js den nächsten Sitzungsbenutzer auf die Zeichenfolge authentifiziert gesetzt haben.

375
00:32:07,780 --> 00:32:10,055
Das ist es, worauf wir prüfen werden.

376
00:32:10,055 --> 00:32:14,355
Wir werden sagen, wenn req.session.user authentifiziert ist,

377
00:32:14,355 --> 00:32:21,955
sagen wir als nächstes, sonst werden Sie nicht erneut authentifiziert.

378
00:32:21,955 --> 00:32:31,990
Dann senden wir eine verbotene Nachricht zurück. Das ist es.

379
00:32:31,990 --> 00:32:33,995
Also, mit diesem Update

380
00:32:33,995 --> 00:32:36,375
ist meine Datei app.js auch bereit.

381
00:32:36,375 --> 00:32:38,590
Nachdem wir diese Updates durchgeführt haben,

382
00:32:38,590 --> 00:32:42,470
lassen Sie uns jetzt überprüfen, wie unsere Anwendung funktioniert.

383
00:32:42,470 --> 00:32:44,350
Gehen Sie zum Terminal,

384
00:32:44,350 --> 00:32:49,655
wenn Ihr Server läuft, stoppen Sie ihn und starten Sie den Server neu.

385
00:32:49,655 --> 00:32:51,600
Mein Server läuft im Moment nicht,

386
00:32:51,600 --> 00:32:53,405
also werde ich npm start sagen,

387
00:32:53,405 --> 00:32:56,440
und mein Server sollte betriebsbereit sein.

388
00:32:56,440 --> 00:33:00,540
Lassen Sie uns jetzt sehen, wie wir auf den Server zugreifen.

389
00:33:00,540 --> 00:33:04,150
Gehen Sie zum Postman, lassen Sie mich ein GET auf

390
00:33:04,150 --> 00:33:07,290
localhost machen: 3000/Gerichte und dann werden Sie sofort sehen

391
00:33:07,290 --> 00:33:10,375
, dass es sich beschwert, dass Sie nicht authentifiziert sind.

392
00:33:10,375 --> 00:33:13,095
Offensichtlich bin ich hier nicht authentifiziert.

393
00:33:13,095 --> 00:33:19,560
Lassen Sie mich versuchen, nur den localhost zuzugreifen: 3000 und Sie werden sehen, dass,

394
00:33:19,560 --> 00:33:22,625
dass root für uns verfügbar ist.

395
00:33:22,625 --> 00:33:29,850
Nun möchten wir natürlich zuerst einen Benutzer registrieren und sich dann

396
00:33:29,850 --> 00:33:37,745
als Benutzer anmelden und danach Zugriff auf die restlichen REST-API-Endpunkte erhalten.

397
00:33:37,745 --> 00:33:40,480
Lassen Sie mich zunächst einen Benutzer registrieren.

398
00:33:40,480 --> 00:33:41,925
Um den Benutzer zu registrieren,

399
00:33:41,925 --> 00:33:51,410
muss ich einen POST an den localhost: 3000/users/signup machen.

400
00:33:53,700 --> 00:34:01,635
Für diese POST-Nachricht

401
00:34:01,635 --> 00:34:07,860
muss ich im Nachrichtentext

402
00:34:07,860 --> 00:34:15,080
eine JSON-Zeichenfolge mit dem Benutzernamen in den Nachrichtentext einfügen.

403
00:34:15,080 --> 00:34:19,390
Also, lassen Sie mich selbst einloggen und

404
00:34:19,390 --> 00:34:27,770
dann verwende ich einfach das Passwort als Passwort.

405
00:34:28,810 --> 00:34:31,835
Dies ist eine gültige Registrierung.

406
00:34:31,835 --> 00:34:35,505
Wenn ich mich also als Benutzer mit

407
00:34:35,505 --> 00:34:42,150
diesen Informationen in Form einer JSON-Zeichenfolge anmelde, die im Nachrichtentext enthalten ist,

408
00:34:42,150 --> 00:34:47,590
lassen Sie mich sehen, dass der Header jetzt Inhaltstypanwendung enthält,

409
00:34:47,590 --> 00:34:50,440
JSON, weil ich das JSON im

410
00:34:50,440 --> 00:34:54,660
Nachrichtentext eingerichtet und dann den POST an die Anmeldung gesendet habe.

411
00:34:54,660 --> 00:34:57,175
Wenn ich dann den POST an die Anmeldung sende,

412
00:34:57,175 --> 00:35:02,460
sehen Sie sofort, was vom Server hier zurückgegeben wird.

413
00:35:02,460 --> 00:35:05,630
Also, Sie sehen, dass der Server zurückgegeben hat sagen,

414
00:35:05,630 --> 00:35:10,205
„Registrierung erfolgreich“ und sich selbst,

415
00:35:10,205 --> 00:35:13,485
es gibt mir die Details des Benutzers hier.

416
00:35:13,485 --> 00:35:19,340
Also, dies ist ein Datensatz, der in meiner MongoDB existiert und

417
00:35:19,340 --> 00:35:25,090
beachten Sie, dass der Modelltyp der Benutzermodelltyp ist, den wir eingerichtet hatten.

418
00:35:25,090 --> 00:35:28,300
Also, wir haben den Benutzernamen und das Passwort und

419
00:35:28,300 --> 00:35:33,535
das Admin-Flag, wie Sie sehen können, ist standardmäßig auf false gesetzt.

420
00:35:33,535 --> 00:35:37,285
Sobald wir den Benutzer registriert haben,

421
00:35:37,285 --> 00:35:40,370
ist dieser Benutzer jetzt ein gültiger Benutzer.

422
00:35:40,370 --> 00:35:45,640
Also, lassen Sie mich versuchen, den gleichen Benutzer erneut zu POSTEN und sehen, was passiert.

423
00:35:45,640 --> 00:35:48,935
Also, wenn ich den gleichen Benutzer offensichtlich

424
00:35:48,935 --> 00:35:50,385
von der Serverseite POST,

425
00:35:50,385 --> 00:35:52,840
antwortet es, dass dieser Benutzer bereits existiert.

426
00:35:52,840 --> 00:35:58,480
Sie können also sehen, dass wir unsere Anmeldeprozedur eingerichtet haben, um dem

427
00:35:58,480 --> 00:36:04,580
Benutzer nicht zu erlauben, die Registrierung mit der gleichen Benutzer-ID zu duplizieren.

428
00:36:04,580 --> 00:36:07,135
Ok. Also, das ist der zweite Teil.

429
00:36:07,135 --> 00:36:13,570
Lassen Sie uns nun einen Login des Benutzers machen.

430
00:36:13,570 --> 00:36:15,770
Um eine Anmeldung des Benutzers zu machen,

431
00:36:15,770 --> 00:36:20,400
lassen Sie mich den Inhaltstyp entfernen und dann werde ich auch

432
00:36:20,400 --> 00:36:25,440
den Körper entfernen, weil für die Anmeldung, das ist nicht erforderlich.

433
00:36:25,440 --> 00:36:28,200
Also, ich fülle nichts in

434
00:36:28,200 --> 00:36:31,790
der Kopfzeile ein und versuche dann, mich anzumelden und als ich versucht habe, mich anzumelden,

435
00:36:31,790 --> 00:36:34,805
antwortet es zurück, dass Sie nicht authentifiziert sind.

436
00:36:34,805 --> 00:36:36,175
Sie sind nicht autorisiert.

437
00:36:36,175 --> 00:36:39,595
Jetzt muss ich mich einloggen.

438
00:36:39,595 --> 00:36:42,940
Also, hier kann ich die grundlegende Authentifizierung verwenden.

439
00:36:42,940 --> 00:36:46,240
Also, in der Grundauthentifizierung,

440
00:36:46,240 --> 00:36:51,170
werde ich nur meinen Benutzernamen und mein

441
00:36:51,170 --> 00:36:56,575
Passwort eingeben, die ich gerade im vorherigen Schritt registriert habe, und dann meine Anfrage aktualisieren

442
00:36:56,575 --> 00:37:00,060
und dann einen POST für die Anmeldung durchführen.

443
00:37:00,060 --> 00:37:02,400
Wenn ich also einen POST für die Anmeldung mache,

444
00:37:02,400 --> 00:37:06,935
sehen Sie, dass der Server antwortet: „Sie sind authentifiziert“.

445
00:37:06,935 --> 00:37:08,740
An dieser Stelle

446
00:37:08,740 --> 00:37:11,400
kann ich die GET-,

447
00:37:11,400 --> 00:37:16,115
PUT-, POST- und DELETE-Anforderungen auf allen anderen Endpunkten ausführen.

448
00:37:16,115 --> 00:37:26,370
Also, an diesem Punkt, wenn ich ein GET auf dem Geschirr Endpunkt mache,

449
00:37:28,760 --> 00:37:32,675
würden Sie sehen, dass dies

450
00:37:32,675 --> 00:37:39,160
das leere Feld zurückgibt, da meine Datenbank momentan leer ist.

451
00:37:39,160 --> 00:37:44,370
Lassen Sie mich die Autorisierung löschen und entfernen Sie auch aus dem Header

452
00:37:44,370 --> 00:37:49,575
die Autorisierung und machen Sie dann das GET und seine Toolbox gut.

453
00:37:49,575 --> 00:37:52,480
Sie können also sehen, dass ich jetzt

454
00:37:52,480 --> 00:37:56,065
auf die Endpunkte zugreifen kann, weil ich mich angemeldet habe.

455
00:37:56,065 --> 00:38:00,040
Also, lassen Sie mich jetzt eine Abmeldung des Benutzers machen.

456
00:38:00,040 --> 00:38:05,910
Also, wir werden sagen, localhost: 3000 und logout.

457
00:38:05,910 --> 00:38:08,875
Beachten Sie auch, dass in den Cookies

458
00:38:08,875 --> 00:38:12,290
ein Cookie an der Sitzungs-ID direkt dort eingerichtet wurde.

459
00:38:12,290 --> 00:38:17,080
Also, dieses Cookie existiert auf meiner Client-Website.

460
00:38:17,080 --> 00:38:22,715
Also, lassen Sie mich jetzt abmelden, indem Sie GET localhost sagen: 3000/users/logout.

461
00:38:22,715 --> 00:38:26,580
Also, wenn ich mich vom Benutzer abmelde,

462
00:38:26,580 --> 00:38:29,765
werden Sie sofort sehen, dass ich zu diesem

463
00:38:29,765 --> 00:38:37,830
localhost: 3000-Endpunkt umgeleitet werde und auch bemerken, dass das Cookie verschwunden ist.

464
00:38:37,830 --> 00:38:40,140
Also, wenn ich Cookies anschaue,

465
00:38:40,140 --> 00:38:42,040
sehen Sie, dass der localhost,

466
00:38:42,040 --> 00:38:46,470
das Cookie weg ist, weil von meiner Serverseite, wenn ich die Abmeldung mache,

467
00:38:46,470 --> 00:38:51,495
es sendet einen Rest Clear Cookie an die Client-Seite zurück und so ist das Cookie weg.

468
00:38:51,495 --> 00:38:54,555
Wenn ich nun versuche, ein GET

469
00:38:54,555 --> 00:39:02,480
auf dem localhost: 3000/Gerichte Endpunkt zu machen,

470
00:39:02,480 --> 00:39:05,899
wird dies nicht funktionieren, weil ich nicht authentifiziert bin.

471
00:39:05,899 --> 00:39:11,610
Dies zeigt Ihnen, wie Sie Ihren Express-Server erweitern können,

472
00:39:11,610 --> 00:39:17,190
damit Benutzer sich registrieren können und dann dem Benutzer erlauben, sich beim System anzumelden

473
00:39:17,190 --> 00:39:19,860
und sich dann auch vom System abmelden können.

474
00:39:19,860 --> 00:39:25,520
Auf der Serverseite verfolgen Sie einen angemeldeten Benutzer, indem Sie die Sitzung verwenden und

475
00:39:25,520 --> 00:39:28,260
das Cookie auf der Client-Seite verwenden und wenn sich der Benutzer

476
00:39:28,260 --> 00:39:31,375
abmeldet, wird das Cookie auf der Clientseite zerstört.

477
00:39:31,375 --> 00:39:34,540
Damit schließen wir diese Übung ab.

478
00:39:34,540 --> 00:39:37,390
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit zu machen,

479
00:39:37,390 --> 00:39:42,420
mit der Nachricht, Express-Sitzungen Teil zwei.