Dies ist der zweite Teil der Express Sessions Übung.
Wir haben den ersten Teil früher abgeschlossen,
wo wir Unterstützung für Express-Sitzungen hinzugefügt haben,
und verwenden Express Sessions als eine Möglichkeit, die Benutzer auf der Serverseite zu verfolgen
und die eingehenden Anfragen der Benutzer zu erkennen.
In dieser Übung konzentrieren wir uns nicht so sehr auf Express Sessions selbst,
aber wir werden uns eine Möglichkeit ansehen, unseren Express-REST-API-Server zu erweitern, um
ein neues Modell für die Registrierung und Authentifizierung von Benutzern zu unterstützen.
Daher werden wir ein neues Benutzermodell und ein neues Schema in unsere Anwendung einführen.
Wir haben bereits die Slash-User-Route, die
der Express-Generator bereits den Router eines Benutzers montiert hat.
Also, wir werden das nutzen und dann aktualisieren,
um die Registrierung neuer Benutzer zu unterstützen,
einen bestehenden Benutzer zu authentifizieren
und auch einen Benutzer von unserer Serverseite abmelden.
Daher betrachten wir Express Sessions als eine Möglichkeit, die Benutzer zu verfolgen, sobald sich der Benutzer anmeldet,
und wenn sich der Benutzer abmeldet,
wird die Sitzung aus dem System entfernt.
Also, wie machen wir diese Erweiterung in dieser Übung?
Gehen wir und finden es heraus.
Fahren wir mit unserem Express-REST-API-Server fort,
lassen Sie uns nun in die Modelle gehen und eine neue Datei namens user.js hinzufügen.
Dies ist die Datei, in der wir das Benutzerschema und das Modell erstellen.
Wir erstellen ein einfaches Benutzerschema, das den Benutzernamen und das Kennwort verfolgt,
und auch ein Flag, das festgelegt ist, um anzuzeigen,
ob der Benutzer ein Administrator oder ein normaler Benutzer ist.
Dies ist also eine Möglichkeit, zwischen verschiedenen Benutzertypen zu unterscheiden.
Also, in dieser Datei,
lassen Sie uns zuerst Mongoose benötigen, weil wir ein Mongoose-Schema
erstellen, und dann werden wir ein Schema namens Mongoose Schema erstellen,
und dann sagen wir var Benutzer.
Dies ist also das Benutzerschema, das wir erstellen werden,
und wir sagen neues Benutzerschema.
Das Benutzerschema wird definiert, wie ich gerade erwähnt habe,
mit drei Feldern hier namens username,
die offensichtlich vom Typ string sein würde,
und dies ist ein erforderliches Feld,
und dies ist ein eindeutiges Feld.
Sie möchten nicht, dass zwei Benutzer mit dem gleichen Benutzernamen in Ihrem System,
also erstellen wir den Benutzernamen und dann das zweite Feld ist Passwort-Feld.
Nun können Sie
dieses Benutzerschema natürlich erweitern, um dem Benutzer zu ermöglichen, sein gesamtes Profil zu verfolgen,
aber wir werden das in einer der späteren Übungen tun, im Moment
wird ein Benutzer innerhalb des Systems durch einfach den Benutzernamen und das Passwort erkannt.
Das Passwort ist also vom Typ String und wird dann benötigt.
Das dritte Feld, das ich verwenden werde, heißt Admin.
Der Admin ist also vom Typ Boolean,
und wir sagen default false.
Also, standardmäßig, wenn ein Benutzer erstellt wird,
wird ein neuer Benutzer erstellt,
das Admin-Flag wird auf false gesetzt.
Sie können es explizit
in Ihrem Code auf true setzen, um einen Benutzer als Administratorbenutzer zu markieren.
Möglicherweise können Sie einem Administratorbenutzer zusätzliche Berechtigungen bereitstellen
oder Administratorbenutzer erlauben,
bestimmte Vorgänge auszuführen, die normale Benutzer dies nicht tun würden.
Wir werden das in einer der späteren Übungen betrachten, im
Moment ist dies das Benutzerschema, das wir erstellt haben,
lassen Sie uns ein Modul daraus erstellen und aus
diesem Modul ein Mongoose-Modell des Namens Benutzer exportieren.
Dies ist also das Mongoose-Modell und das Schema ist
das Benutzerschema, das wir gerade ein wenig früher definiert haben.
So definieren wir unser Benutzerschema.
Also, jetzt, da wir unser Benutzerschema definiert haben,
gehen wir in den Router, der bereits
von Express-Generator eingerichtet wurde, wenn es diese Express-Anwendung generiert.
Wenn Sie also in den Routenordner gehen,
sehen Sie diese Datei namens users.js.
Also, diese users.js Datei wird erweitert, um den Router zu erstellen.
Also, genau dort, was ich tun werde, ist Bodyy-Parser zu importieren,
und dann werden sie den Express-Router deklarieren,
und dann werden wir sagen, auch
das Benutzerschema und das
Modell von Modellen Benutzer importieren,
und dann für den Express-Router sagen wir,
Router verwenden Body Parser.
Nun, da wir den Body Parser dort deklariert haben, werden
wir diesen Teil als solchen verlassen.
Später werden wir dies ändern, damit der Administrator in der
Lage sein kann,
alle Benutzer abzurufen, die im System registriert sind, aber im Moment werden
wir diese Route als solche verlassen.
Wir werden hier ein paar weitere Routen hinzufügen,
also sagen wir: „Router-Post“.
Daher unterstützen wir den Post-Vorgang auf einer Route namens Anmeldung und wie Sie erwarten,
wird diese Anmelderoute einem Benutzer erlauben, sich auf dem System anzumelden,
so dass dies die Anmeldung des Benutzers unterstützt.
Also sagen wir: „Rec, res, next.“
Und so wäre dies die Router-Post-Anmeldung,
die restlichen Methoden werden auf dem Anmeldeende nicht erlaubt sein.
Also, um darauf zuzugreifen,
da dieser Benutzer Router auf Schrägstrich Benutzer gemountet ist,
würden wir diesen Endpunkt als Schrägstrich Benutzer Schrägstrich Anmeldung angeben,
und dies ist der Endpunkt, der verwendet wird, um neue Benutzer innerhalb des Systems zu registrieren.
Also, zuerst, was wir tun werden, ist
die Benutzermethode zu verwenden und die Erwartung ist, dass für einen Benutzer, um sich
anzumelden, der Benutzername und das Passwort als JSON-Zeichenfolge
innerhalb des Hauptteils der eingehenden Postanforderung zur Verfügung gestellt werden.
Also, aus dem Körper,
da der Körper bereits vom Body Parser analysiert worden wäre,
wird also vom Körper zuerst überprüfen, um sicherzustellen, dass
der Benutzer mit diesem Benutzernamen nicht im System existiert.
Wenn der Benutzer mit diesem Benutzernamen vorhanden ist,
versuchen Sie, einen doppelten Benutzer zu registrieren
, der im System nicht erlaubt sein sollte.
Wir werden also sagen, „Benutzer finden einen“, und dann werden wir versuchen zu finden, ob
es einen Benutzer mit dem Benutzernamen gibt,
der vom Client ausgewählt wurde, der versucht, einen neuen Benutzer zu registrieren.
Wenn der Benutzer bereits existiert,
erlauben Sie dem neuen Benutzer offensichtlich nicht, sich mit demselben Benutzernamen anzumelden.
Also, wir werden sagen: „Dann Benutzer.“
Also, dies wird den Benutzer hier und in diesem Benutzerfeld zurückgeben,
dann werden wir prüfen, ob der Benutzer bereits existiert,
und lassen Sie mich dann den Fehler hier abfangen.
Also sagen wir: „Fehler fangen“ und dann „nächster Fehler“.
Also, wir geben das einfach an den Fehler-Handler dort weiter.
Also, wenn diese Suche nach dem Benutzer das Benutzerfeld zurückgibt,
wenn der Benutzer nicht gleich null ist.
Wenn also der Benutzer, der von dieser Suche zurückgegeben wird,
nicht null ist, bedeutet das, dass der Benutzer mit diesem angegebenen Benutzernamen bereits existiert,
also sollten Sie keine doppelte Anmeldung zulassen.
Also sagen wir: „Var irr neuen Fehler.“
Und wir werden sagen: „Benutzer req. body username.“
Es ist bereits vorhanden. Also im Grunde
verhindern Sie, dass sich ein doppelter Benutzer registriert und dann sagen wir
err.status 403 gegen das Verbotene und beenden Sie dann
den Fehler-Handler aufrufen, nächster Fehler.
Andernfalls bedeutet dies, dass der Benutzer nicht existiert,
daher sollten Sie zulassen, dass der Benutzer abgemeldet wird.
Also, im anderen Teil,
werden wir sagen, user.create () zurückgeben.
Wir erstellen einen neuen Benutzer mit dem Benutzernamen, der auf req.body.username gesetzt ist,
und lassen Sie mich das dann in die nächste Zeile setzen, so dass es Ihnen klarer ist,
und wir sagen password: req.body.password.
Jetzt wissen wir bereits, dass das Admin-Flag standardmäßig auf false gesetzt wird,
also werden wir es als solche verlassen,
und dies wird unseren neuen Benutzer registrieren lassen und wenn der neue Benutzer angemeldet ist,
wird dies ein Versprechen zurückgeben und innerhalb des „dann“ werden wir dieses Versprechen hier behandeln.
Also, dies wird das Versprechen von
diesem „dann“ zurückgeben und dann werden wir es im nächsten „dann“ hier behandeln.
Wird dann sagen, res.StatusCode ist 200,
res.setHeader und wir sagen Content-Typ application/json
und wir werden sagen, res.json (Status: Registrierung erfolgreich),
und wenn Sie möchten,
können wir den Benutzer in
diese Antwortnachricht hier als Eigenschaft in der json laden.
Wird die Registrierung erfolgreich aussagen.
Dann, wenn es einen Fehler in
dieser Operation gibt, wird sagen „next irr“.
Das wird also den Fehler behandeln.
Wenn das Versprechen nicht erfolgreich gelöst
wird, wird dadurch behandelt. Das war's also.
Also hier haben wir eine Möglichkeit für den Benutzer, sich anzumelden.
Damit sich der Benutzer anmelden kann,
wird der Benutzer einen Beitrag auf /users/signup machen und im Hauptteil der Nachricht
enthält der Client eine JSON-Zeichenfolge
mit Benutzername und Kennwort Eigenschaften in dieser JSON-Zeichenfolge.
So melden Sie sich für einen neuen Benutzer an.
Nun, lassen Sie uns sehen, wie wir den Benutzer einloggen werden.
Jetzt werden wir weiterhin die Express-Sitzungen verwenden, die wir zuvor durchgeführt haben, um den Benutzer zu verfolgen.
Also, zum Protokollieren eines Benutzers wird „router.post“ auf dem Endpunkt/Login sagen.
Also auf dem /login Endpunkt,
werden wir einen router.post.
Wir werden offensichtlich, anstatt Funktion zu sagen,
können Sie die Pfeilfunktion hier für den router.post verwenden,
ich werde das Gleiche hier tun.
Ich habe Pfeilfunktionen geliebt.
Also, wir werden hier eine Pfeilfunktion machen.
Also für den Login, wie geht der Login vor?
Also für die Anmeldung,
was wir tun werden, ist, dass wir zur Datei app.js gehen und dann innerhalb dieser Auth
haben wir diese Anmeldung für den Benutzer dort gemacht.
Also, was ich tun werde, ist, dass ich die
ganze Sache kopieren werde, weil ich das sowieso nicht tun würde.
Also, lassen Sie mich lieber den ganzen Weg von diesem Punkt an bis zum req.session.user kopieren.
Also, der if Teil von req.session.user werde ich kopieren,
und dann zu der users.js und für die Anmeldung kommen.
Es ist genau, wie ich die Authentifizierung machen werde.
Also sagen wir, wenn nicht req.session.user.
Das bedeutet, dass sich der Benutzer noch nicht authentifiziert hat.
Dann erwarten Sie, dass die Standardauthentifizierung
als Mechanismus für die Authentifizierung verwendet wird.
Also sagen wir var AuthHeader if! AuthHeader dann werden wir den Fehler auslösen,
sonst werden wir den Benutzernamen und das Passwort aus dem Header abrufen.
Nun, hier haben wir getan, wenn Benutzername gleich admin und Passwort gleich Passwort ist.
Aber jetzt, was wir tun werden, ist, dass wir in
der Datenbank suchen, um zu sehen, ob dieser bestimmte Benutzer existiert.
Also, anstatt dies hier zu tun,
anstatt dies zu tun, wenn Benutzername und Passwort,
werden wir sagen, User.Findone
und wir werden sagen, Benutzername ist Benutzername.
Also diese Eigenschaft ist gleich diesem Benutzernamen, den wir gerade abgerufen haben
und dann sagen wir dann Benutzer.
Also in diesem „dann“.
Also werde ich diesen Code innerhalb dieses „Dann“ verschieben,
denn jetzt werde ich überprüfen, nachdem ich den Benutzer abgerufen habe.
Ich muss überprüfen, ob dieser Benutzer genau das ist, was ich suche.
Also an diesem Punkt
werden wir zuerst überprüfen, um sicherzustellen, dass der Benutzer nicht null ist.
Also werden wir sagen, wenn der Benutzer null ist.
Also, wenn der Benutzer null ist,
was bedeutet, dass wir keinen Benutzer mit diesem bestimmten Benutzernamen finden konnten.
Sie müssen also hier einen Fehler zurückgeben.
Also lassen Sie mich einfach diesen Teil kopieren und dann fügen Sie ihn
hier ein und dann werden wir sagen var new Error sagen
und wir werden sagen, dass der
Benutzername
nicht existiert.
In diesem Fall
existiert dieser Benutzer nicht, also werde ich nur diesen Teil entfernen und
dann wäre der entsprechende Fehlerstatus hier 403.
Das ist also der erste Teil.
Wenn der Benutzer null ist, dann werden wir offensichtlich sagen, dass der Benutzer nicht existiert.
Der zweite Teil, den wir überprüfen werden, ist Else, wenn Benutzerpasswort.
Das bedeutet also, dass der Benutzer an dieser Stelle existiert.
Also, die zweite Überprüfung, die wir tun werden, ist, dass das Benutzerpasswort nicht
gleich Passwort ist dann.
Wir müssen wieder den Fehler dort anzeigen.
Der Fehler würde also sagen,
in diesem Fall sagen wir
„Ihr Passwort ist falsch“.
Das ist also der zweite Teil hier.
So ist Ihr Passwort falsch und dann der letzte Teil.
Wir werden „sonst“ sagen.
Also lassen Sie mich diesen Code einrücken.
Also, wenn user.username
Benutzername ist, was offensichtlich in diesem Fall wahr sein sollte.
Dann
ist der zweite Teil user.password gleich Passwort, das auch offensichtlich an dieser Stelle korrekt sein sollte.
Aber auf jeden Fall
werde ich hier nach diesem Problem suchen und das sonst wird in diesem Fall überhaupt nicht auftreten.
Also, wenn Sie diesen Punkt erreichen,
sollte der Benutzername der
gleiche sein wie der Benutzername und das Passwort sollte das gleiche wie ein Passwort sein,
aber in jedem Fall habe ich an dieser Stelle einen doppelten Check eingelegt, nur um doppelt sicher zu sein.
Dann
sagen wir in diesem Fall, dass req.session.user authentifiziert ist.
Also, wir werden dies auf authentifiziert setzen
und auch diese, wir werden sagen
res.StatusCode ist 200.
So konnten wir den Benutzer erfolgreich authentifizieren.
Also, wir sagen res.StatusCode ist 200 und dann sagen wir res.setHeader
Content-Type Text plain und
res.end wir werden einfach eine Nachricht senden, die sagt „Sie sind authentifiziert“.
Das war's. Dies deckt also den dann Teil des Benutzers FindOnE ab.
Also zuerst überprüfen wir, dass, wenn der Benutzer null ist,
das bedeutet, dass wir den Benutzer nicht finden konnten,
also geben wir offensichtlich einen Fehler zurück, der besagt, dass der Benutzername nicht existiert.
Wenn das Passwort des Benutzers nicht mit dem Passwort übereinstimmt,
also an diesem Punkt,
der Benutzer existiert, aber das Passwort stimmt nicht überein, also sagen wir:
„Ihr Passwort ist falsch“, und dann, schließlich,
wir erreichen diesen Punkt dann der Benutzername und das Passwort korrekt identifiziert werden.
Obwohl ich diese Überprüfung nicht brauche, aber ich habe sie einfach dort platziert und dann an dieser Stelle
werde ich den req.session.user so einstellen, dass
er ihn authentifiziert und dann den Statuscode auf 200 gesetzt, was bedeutet, dass Sie
den Benutzer erfolgreich authentifizieren konnten und dann an diesem Punkt fertig werden können.
Da dies ein dann ist,
werde ich an diesem Punkt einen Haken setzen,
also sagen wir catch-Fehler und wenn der Fehler auftritt,
dann werde ich den Fehler einfach an den
nächsten übergeben, so
dass der Fehler-Handler in der Lage sein wird, den Fehler angemessen zu behandeln.
Das beendet diesen Benutzer FindOnE.
Dies ist nun der Fall, wenn die req.session.user nicht gesetzt ist.
Wenn das bereits gesetzt ist,
bedeutet das, dass der Benutzer bereits angemeldet ist.
In diesem Fall
befasst sich der andere Teil hier mit der Situation, die besagt, dass wir
den StatusCode auf 200
und den Content-Type auf text/plain setzen und dann sagen wir:
„Sie sind bereits authentifiziert.“
Also, wenn Sie diesen anderen Teil erreichen,
würden Sie hierher kommen, weil der req.session.user bereits nicht null ist,
was bedeutet, dass der Benutzer bereits authentifiziert wurde,
also wenn Sie diesen Punkt erreichen,
hat sich der Benutzer bereits früher angemeldet,
so dass Sie nicht überprüfen müssen.
Sie werden also einfach sagen:
„Sie sind bereits authentifiziert“ und dann an dieser Stelle beenden.
Ok. Jetzt ist die letzte Methode, die wir implementieren werden, um den Benutzer abzumelden.
Also, wir werden einen router.get on /logout.
Sie müssen sich fragen, warum tun wir ein get auf
der Abmeldung anstatt einen Beitrag, den wir auf Login getan haben?
Bei der Anmeldung müssen Sie den Benutzernamen und das Passwort einreichen.
Für die Abmeldung melden Sie sich einfach selbst vom System ab,
so dass Sie keine weiteren Informationen angeben müssen, da
der Server Sie bereits basierend auf
Ihrer Sitzungs-ID und in diesem Sitzungs-Cookie hier verfolgt.
Deshalb
müssen wir nicht explizit weitere Informationen im Nachrichtentext senden.
Also sagen wir, wenn req.session so was bedeutet, dass die Sitzung existieren muss
, andernfalls versuchen Sie, einen Benutzer abzumelden, der sich nicht angemeldet hat.
Es ergibt also keinen Sinn.
Nun stellt die Sitzung selbst diese Methode
namens destroy bereit, und wenn Sie die Destroy-Methode aufrufen,
wird die Sitzung zerstört und die Informationen werden
von der Serverseite entfernt, die sich auf diese Sitzung bezieht.
Wenn also der Client versucht, die
Sitzungsinformationen, die in Form
eines signierten Cookies auf der Clientseite gespeichert sind, erneut zu senden, ist
dies ungültig.
Daher benötigen wir eine Methode zum Löschen des Cookies, das auf der Client-Seite gespeichert wird.
Mit diesem Vorgang werden nun
die Sitzungsinformationen von der Serverseite entfernt, so dass die Sitzung nicht mehr gültig ist.
Also, an dieser Stelle
werden wir sagen req.session.destroy und dann sagen wir, res.clearCookie.
Das ClearCookie ist also eine Möglichkeit, den Client zu bitten,
das Cookie zu entfernen und der Cookie-Name ist die Sitzungs-ID.
In der vorherigen Übung
haben wir gesehen, dass das Cookie mit dem Namen der Sitzungs-ID auf der Clientseite gespeichert wurde.
Also bitten wir den Client, dieses Cookie von
der Client-Seite in der Antwortnachricht zu löschen und dann sagen wir,
res.redirect und wir werden es auf die Homepage hier umleiten.
Dies ist also eine Möglichkeit, den Benutzer zu leiten, um seine Standardseite einzugeben,
also zum Beispiel die Homepage Ihrer Anwendung.
Also, so würden Sie die Abmeldung des Systems behandeln.
Wenn die req.session nicht existiert,
bedeutet das, dass Sie nicht angemeldet sind,
daher müssen wir einen Fehler generieren.
Also sagen wir var err,
new Error, „Sie sind nicht angemeldet“,
und wir setzen den Fehlerstatus auf 403,
dies ist eine verbotene Operation und
generieren dann den Fehler an den Fehler-Handler, das war's.
Jetzt sehen Sie, dass wir den Router des Benutzers erweitert haben, um drei neue Endpunkte zu unterstützen, den
Anmeldeendpunkt, der es einem Benutzer ermöglicht, sich
anzumelden, den Anmeldeendpunkt, der es einem angemeldeten Benutzer ermöglicht, sich anzumelden,
und dann den Abmeldeendpunkt, der es einem angemeldeten Benutzer ermöglicht, sich vom System abzumelden. Wenn Sie
sich abmelden,
zerstören Sie die Sitzung auf der Serverseite,
löschen Sie auch das Cookie auf der Clientseite,
so dass der Client nicht in abgelaufener Sitzung verwendet werden kann, um zu versuchen, diesen Server zu kontaktieren.
Eine kleine Korrektur in users.js,
dies sollte var Benutzer erfordern.. /models/user,
erinnern Sie sich daran, dass sich die Datei users.js im Ordner routes befindet und
sich dann die Datei user.js im
Ordner models befindet, der sich auf einer Ebene befindet und dann in den Ordner models.
Also, das sollte sein.. /models/user,
also machen Sie diese kleine Korrektur, das ist es.
Wir haben die Datei users.js geändert,
jetzt ist das letzte, was wir tun müssen, gehen und reparieren Sie die Datei app.js.
In der App app.js Datei,
wenn Sie in die Datei app.js navigieren,
würden Sie sehen, dass wir
diesen Schrägstrich Index hier und Schrägstrich Benutzer hier nach der Authentifizierung.
Nun, das wird für uns nicht funktionieren, denn wenn Sie sich anmelden müssen,
würde sich der Benutzer anmelden und sich anmelden, bevor die Autorisierung bestätigt wird,
trotzdem wenn die Anmeldung und Anmeldung für den Prozess der Anmeldung ist,
also werde ich diese vor dem Authentifizierungsschritt hier nach oben verschieben.
Also, wir werden das hier in diesen Ort bringen.
So kann ein eingehender Benutzer auf die Indexdatei
am Schrägstrich zugreifen und auch auf den Endpunkt des Benutzers zugreifen, ohne authentifiziert zu werden,
aber jeder andere Endpunkt,
der Benutzer muss authentifiziert werden,
so dass ist die Art und Weise, wie wir dies einrichten.
Innerhalb der Funktion Authentifizierung, werden wir sagen,
„Wenn nicht req.session.user,“ dann bemerken, dass dieser Ort,
würden wir nicht zulassen, dass der Benutzer hier kommen, ohne dass der Benutzer angemeldet ist.
Also, wenn nicht req.session.user,
dann würden wir einfach sagen, dass Sie nicht authentifiziert sind.
Diese Authentifizierung muss mit der Anmeldemethode hier durchgeführt werden.
Also, ich werde diesen ganzen Teil hier entfernen.
Also, wir werden sagen, wenn nicht req.session.user,
wir werden sagen, dass Sie nicht authentifiziert sind und so müssen wir ein Foto drei hier senden,
was bedeutet, dass Sie nie zu diesem Punkt kommen sollten,
ohne dass sich der Benutzer einloggt.
Also, wir sagen, dass Sie nicht authentifiziert sind. Denken Sie
daran, dass Sie sich authentifizieren müssen, indem Sie einen POST für
den Schrägstrich Benutzer Anmelde-Endpunkt.
Wir werden also sagen, dass Sie nicht authentifiziert sind, andernfalls,
wenn req.session.user gleich ist,
erinnern Sie sich, dass
wir in der Login-Funktion in der users.js den nächsten Sitzungsbenutzer auf die Zeichenfolge authentifiziert gesetzt haben.
Das ist es, worauf wir prüfen werden.
Wir werden sagen, wenn req.session.user authentifiziert ist,
sagen wir als nächstes, sonst werden Sie nicht erneut authentifiziert.
Dann senden wir eine verbotene Nachricht zurück. Das ist es.
Also, mit diesem Update
ist meine Datei app.js auch bereit.
Nachdem wir diese Updates durchgeführt haben,
lassen Sie uns jetzt überprüfen, wie unsere Anwendung funktioniert.
Gehen Sie zum Terminal,
wenn Ihr Server läuft, stoppen Sie ihn und starten Sie den Server neu.
Mein Server läuft im Moment nicht,
also werde ich npm start sagen,
und mein Server sollte betriebsbereit sein.
Lassen Sie uns jetzt sehen, wie wir auf den Server zugreifen.
Gehen Sie zum Postman, lassen Sie mich ein GET auf
localhost machen: 3000/Gerichte und dann werden Sie sofort sehen
, dass es sich beschwert, dass Sie nicht authentifiziert sind.
Offensichtlich bin ich hier nicht authentifiziert.
Lassen Sie mich versuchen, nur den localhost zuzugreifen: 3000 und Sie werden sehen, dass,
dass root für uns verfügbar ist.
Nun möchten wir natürlich zuerst einen Benutzer registrieren und sich dann
als Benutzer anmelden und danach Zugriff auf die restlichen REST-API-Endpunkte erhalten.
Lassen Sie mich zunächst einen Benutzer registrieren.
Um den Benutzer zu registrieren,
muss ich einen POST an den localhost: 3000/users/signup machen.
Für diese POST-Nachricht
muss ich im Nachrichtentext
eine JSON-Zeichenfolge mit dem Benutzernamen in den Nachrichtentext einfügen.
Also, lassen Sie mich selbst einloggen und
dann verwende ich einfach das Passwort als Passwort.
Dies ist eine gültige Registrierung.
Wenn ich mich also als Benutzer mit
diesen Informationen in Form einer JSON-Zeichenfolge anmelde, die im Nachrichtentext enthalten ist,
lassen Sie mich sehen, dass der Header jetzt Inhaltstypanwendung enthält,
JSON, weil ich das JSON im
Nachrichtentext eingerichtet und dann den POST an die Anmeldung gesendet habe.
Wenn ich dann den POST an die Anmeldung sende,
sehen Sie sofort, was vom Server hier zurückgegeben wird.
Also, Sie sehen, dass der Server zurückgegeben hat sagen,
„Registrierung erfolgreich“ und sich selbst,
es gibt mir die Details des Benutzers hier.
Also, dies ist ein Datensatz, der in meiner MongoDB existiert und
beachten Sie, dass der Modelltyp der Benutzermodelltyp ist, den wir eingerichtet hatten.
Also, wir haben den Benutzernamen und das Passwort und
das Admin-Flag, wie Sie sehen können, ist standardmäßig auf false gesetzt.
Sobald wir den Benutzer registriert haben,
ist dieser Benutzer jetzt ein gültiger Benutzer.
Also, lassen Sie mich versuchen, den gleichen Benutzer erneut zu POSTEN und sehen, was passiert.
Also, wenn ich den gleichen Benutzer offensichtlich
von der Serverseite POST,
antwortet es, dass dieser Benutzer bereits existiert.
Sie können also sehen, dass wir unsere Anmeldeprozedur eingerichtet haben, um dem
Benutzer nicht zu erlauben, die Registrierung mit der gleichen Benutzer-ID zu duplizieren.
Ok. Also, das ist der zweite Teil.
Lassen Sie uns nun einen Login des Benutzers machen.
Um eine Anmeldung des Benutzers zu machen,
lassen Sie mich den Inhaltstyp entfernen und dann werde ich auch
den Körper entfernen, weil für die Anmeldung, das ist nicht erforderlich.
Also, ich fülle nichts in
der Kopfzeile ein und versuche dann, mich anzumelden und als ich versucht habe, mich anzumelden,
antwortet es zurück, dass Sie nicht authentifiziert sind.
Sie sind nicht autorisiert.
Jetzt muss ich mich einloggen.
Also, hier kann ich die grundlegende Authentifizierung verwenden.
Also, in der Grundauthentifizierung,
werde ich nur meinen Benutzernamen und mein
Passwort eingeben, die ich gerade im vorherigen Schritt registriert habe, und dann meine Anfrage aktualisieren
und dann einen POST für die Anmeldung durchführen.
Wenn ich also einen POST für die Anmeldung mache,
sehen Sie, dass der Server antwortet: „Sie sind authentifiziert“.
An dieser Stelle
kann ich die GET-,
PUT-, POST- und DELETE-Anforderungen auf allen anderen Endpunkten ausführen.
Also, an diesem Punkt, wenn ich ein GET auf dem Geschirr Endpunkt mache,
würden Sie sehen, dass dies
das leere Feld zurückgibt, da meine Datenbank momentan leer ist.
Lassen Sie mich die Autorisierung löschen und entfernen Sie auch aus dem Header
die Autorisierung und machen Sie dann das GET und seine Toolbox gut.
Sie können also sehen, dass ich jetzt
auf die Endpunkte zugreifen kann, weil ich mich angemeldet habe.
Also, lassen Sie mich jetzt eine Abmeldung des Benutzers machen.
Also, wir werden sagen, localhost: 3000 und logout.
Beachten Sie auch, dass in den Cookies
ein Cookie an der Sitzungs-ID direkt dort eingerichtet wurde.
Also, dieses Cookie existiert auf meiner Client-Website.
Also, lassen Sie mich jetzt abmelden, indem Sie GET localhost sagen: 3000/users/logout.
Also, wenn ich mich vom Benutzer abmelde,
werden Sie sofort sehen, dass ich zu diesem
localhost: 3000-Endpunkt umgeleitet werde und auch bemerken, dass das Cookie verschwunden ist.
Also, wenn ich Cookies anschaue,
sehen Sie, dass der localhost,
das Cookie weg ist, weil von meiner Serverseite, wenn ich die Abmeldung mache,
es sendet einen Rest Clear Cookie an die Client-Seite zurück und so ist das Cookie weg.
Wenn ich nun versuche, ein GET
auf dem localhost: 3000/Gerichte Endpunkt zu machen,
wird dies nicht funktionieren, weil ich nicht authentifiziert bin.
Dies zeigt Ihnen, wie Sie Ihren Express-Server erweitern können,
damit Benutzer sich registrieren können und dann dem Benutzer erlauben, sich beim System anzumelden
und sich dann auch vom System abmelden können.
Auf der Serverseite verfolgen Sie einen angemeldeten Benutzer, indem Sie die Sitzung verwenden und
das Cookie auf der Client-Seite verwenden und wenn sich der Benutzer
abmeldet, wird das Cookie auf der Clientseite zerstört.
Damit schließen wir diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit zu machen,
mit der Nachricht, Express-Sitzungen Teil zwei.