In der vorherigen Übung
haben wir gesehen, wie einfach es für uns war,
einen Empfängerserver mit dem LoopBack-Framework zu konfigurieren und dann zu gerüsten.
Wir sehen, dass dieses LoopBack-Framework ein ganzes Spektrum
der Empfängerendpunkte und
alle Operationen der Empfängerendpunkte automatisch für uns unterstützt,
wenn wir unsere Anwendung aufbauen.
In dieser Übung werden wir untersuchen, wie wir
unseren LoopBack-Server mit einer Back-End-Datenbank
oder MongoDB in dieser Instanz verbinden können,
und wir werden auch sehen, wie wir verschiedene Zugriffskontrollen auf den Empfängerendpunkten einrichten können.
Mit den Zugriffskontrollen
können wir also angeben, welche Art von Operationen an den Empfängerendpunkten durchgeführt
werden können und wer diese Operationen ausführen darf.
So kann beispielsweise ein nicht authentifizierter Benutzer oder ein Gast nur auf
Informationen zugreifen oder eine Get-Operation auf den Empfängerendpunkten durchführen,
ein authentifizierter Benutzer könnte dies auch tun,
aber nur ein Administrator würde in der Lage sein, Daten in meinen Server zu schreiben.
Daher können alle Put-, Post- und Löschvorgänge nur von einem Administrator ausgeführt werden.
Auf dem Weg werden wir auch sehen, wie wir ein Admin-Konto in unserem LoopBack-Server einrichten können,
und konfigurieren Sie es dann so, dass
nur der Admin-Benutzer kann diese Operationen ausführen.
Dies ist also, wo LoopBack uns erlaubt, etwas
namens Rollen mit verschiedenen Benutzern zugeordnet zu definieren.
So kann jedem Benutzer eine Rolle zugewiesen werden.
Als Beispiel können Sie über einen gewöhnlichen Benutzer,
einen Administrator, einen Superadministrator und so weiter sprechen.
So können Sie Ihre Gruppe von Benutzern in verschiedene Gruppen unterteilen
und ihnen dann verschiedene Rollen zuweisen.
Außerdem werden wir uns ansehen, wie das integrierte Benutzermodell
innerhalb unserer LoopBack-Anwendung weiter angepasst werden
kann und wie wir ein anderes Modell auf dem Benutzermodell erstellen
und dann das Benutzermodell als Basisklasse verwenden
und ein höheres Modell namens Customer Model entwickeln können,
das ermöglicht es uns, zusätzliche Informationen für jeden
der Kunden zu speichern, der sich auf unserer Website anmelden wird.
Lassen Sie uns also einige dieser Funktionen von LoopBack in dieser Übung untersuchen.
Um mit dieser Übung zu beginnen,
ist das erste, was ich möchte, dass Sie tun, Ihren MongoDB-Server starten.
Also hier bin ich in einem anderen Terminal Tab in meinem MongoDB-Ordner,
wo ich meinen MongoDB-Server früher konfiguriert habe
, der von meinem Express Plus MongoDB-Server in den vorherigen Übungen verwendet wurde.
Lassen Sie mich also den MongoDB-Server starten, indem Sie
MonGod minus D-B Teiledaten
in diesem Ordner eingeben und dann meinen MongoDB-Server starten.
Jetzt werde ich meinen LoopBack-Server mit meinem MongoDB-Server verbinden.
Also, wenn ich hier in meinen LoopBack-Serverordner gehe,
muss ich den Typ L-B Datenquelle auffordern.
Dies ermöglicht es uns, die Datenquelle für unseren LoopBack Server zu konfigurieren.
LoopBack selbst kann gleichzeitig eine Verbindung zu mehreren Datenquellen herstellen, wenn Sie dies wünschen,
und es unterstützt verschiedene Arten.
Es unterstützt My Cycle-Datenbanken, es unterstützt MongoDB,
es unterstützt Cloudant, die auch eine andere Dokumentdatenbank ist,
es unterstützt Oracle und viele andere Arten von Datenbanken.
So können Sie das einfach konfigurieren.
In diesem Beispiel werde ich meinen LoopBack-Server so konfigurieren,
dass er mit meiner MongoDB im Back-End spricht.
Wenn wir also die Datenquelle L-B eingeben,
werden wir zur Information auffordern.
Also zuerst, was es uns fragen wird, ist nach dem Namen der Datenquelle,
und dann werde ich diesen Datenquellennamen als MongoDB konfigurieren,
und dann wird es mich auffordern, den Connector auszuwählen.
LoopBack verwendet Konnektoren, um hinter den Kulissen eine Verbindung zu verschiedenen Datenbanken herzustellen.
Wie Sie sehen können, die In-Memory-DB, die
sie gerade in der vorherigen Übung verwendet haben,
aber natürlich bedeutet die In-Memory-DB, dass, sobald Sie Ihren Server herunterfahren,
alle Werte verschwunden sind,
und das ist kein persistenter Datenspeicher.
Hier sehen Sie also die verschiedenen Arten von Datenbanken, die StrongLoop hier unterstützt.
So können Sie die lange Liste der verschiedenen Datenbanken sehen, die unterstützt werden.
So können Sie sehen, dass es Cassandra, Redis unterstützt,
wir hatten kurz darauf hingewiesen, als wir über NoSQL-Datenbanken, MongoDB,
My SQL, PostGres, Oracle
und sogar direkt zu anderen Rest API-Servern zu SOAP-Servern,
Coachbase und so weiter sprachen.
So sehen Sie, dass es uns mit
einer langen Liste von verschiedenen Arten von Datenquellen von dort,
unser LoopBack-Server kann in Informationen lesen.
In meinem Fall werde ich den MongoDB-Server verwenden, also
werde ich den MongoDB-Connector einrichten.
Wenn ich das mache,
wird LoopBack automatisch den MongoDB-Connector für uns installieren,
und wenn er nach der Verbindungszeichenfolgen-URL fragt,
lassen wir dies einfach leer, da wir
es erlauben, die Standardmethode der Konfiguration zu verwenden.
Wenn es nach dem Host fragt, sagen wir
localhost, weil wir unsere MongoDB auf dem gleichen Computer laufen.
Andernfalls geben Sie
den Hostnamen des Computers an, auf dem MongoDB ausgeführt wird.
Dann ist die nächste die Portnummer und wir
verwenden unsere Standard-MongoDB-Port-Nummer 27017,
und es wird auch nach dem Benutzernamen und Passwort fragen, wenn erforderlich,
und gerade jetzt läuft meine MongoDB
ohne Authentifizierung tun zu müssen, also lasse ich den Benutzernamen und das Passwort leer,
und den Datenbanknamen.
Der Datenbankname auf dem MongoDB-Server, der hinter den Kulissen läuft,
der Datenbankname gibt es Verwirrung.
Wenn Sie sich erinnern, ist dies der Datenbankname, den sie auf unserem MongoDB-Server eingerichtet haben.
Und dann wird es uns fragen, ob es den LoopBack-Connector installieren soll,
und ich werde ja sagen
und tatsächlich das NPM-Modul installieren, das auf
den LoopBack-Connector zur MongoDB-Datenbank zugreift.
Und sobald das erledigt ist,
ist mein Loopback-Connector hier installiert, damit Sie sehen können, dass dies Version 1.18.1 ist
und mein LoopBack-Server bereit ist, mit meiner MongoDB zu sprechen.
Bevor ich jetzt fortfahre,
konfiguriere ich in der vorherigen Übung einige Modelle nicht wirklich
und dann gebe ich sie an, um in der DB gespeichert
zu werden, muss ich sie aktualisieren, um ihre Daten in meiner MongoDB zu speichern.
Also, lassen Sie uns gehen und schnell unseren Code für den LoopBack-Server zurücksetzen.
Dies bietet uns auch die Möglichkeit zu sehen,
was mein Loopback-Server selbst in diesem Ordner konfiguriert hat. Wenn Sie
den LoopBack-Ordner in unserem Editor öffnen,
können Sie sehen, dass Loopback bereits
eine ganze Reihe von Dateien in diesen Ordner gerüstet hat.
Die package.json enthält natürlich
alle zugehörigen NPM-Module, die hier konfiguriert wurden,
und hier können Sie sehen, dass LoopBack selbst das LoopBack NPM-Modul konfiguriert hat,
das LoopBack-Boot-Modul und
insbesondere lassen Sie mich Ihre Aufmerksamkeit auf die LoopBack MongoDB lenken Connector,
dass wir gerade vor kurzem installiert hatten, und viele andere.
Insbesondere die Konfiguration für den Loopback-Server wird
hier größtenteils in Json-Dateien gespeichert,
mit zusätzlichem Javascriptcore, wenn nötig.
Wir werden die JavaScript-Code-Anpassung ein wenig später nachschlagen.
Lassen Sie mich Ihre Aufmerksamkeit auf diesen Ordner lenken, der als üblich bezeichnet wird.
In diesem gemeinsamen Ordner
sehen Sie alle Modelle, die wir zuvor konfiguriert haben.
Sie werden also sehen, dass wir die Dishes.json-Dateien haben.
Wenn Sie also die Datei dishes.json öffnen, sehen Sie, wie LoopBack
alle Informationen über das Geschirr Modell speichert, das Sie gerade erstellt haben,
so dass es den Namen, die Basis
und einige andere Werte hier enthält, die es erfordert.
Und dann schauen Sie sich die Eigenschaften an und wie alle Eigenschaften hier gespeichert sind.
Sie sehen also einige Dinge, die sehr leicht zu
erkennen sind, dass sie sich in der Datei dishes.json befinden.
In ähnlicher Weise sind die leaders.json und die promotions.json.
Die Datei dishes.js ist groß,
wir können einige zusätzliche Anpassungscode für die Gerichte hinzufügen,
aber im Moment werden wir das nicht tun,
und so lassen wir es einfach wie es ist.
Hier können Sie zusätzlichen Code hinzufügen, der möglicherweise
ausgeführt werden muss, wenn Sie auf den Endpunkt des Schrägschrägschüssels zugreifen.
Aber im Moment werden wir es für den Moment leer lassen.
Sehen wir uns nun auch den Serverordner an.
Und der Serverordner,
insbesondere lassen Sie mich Ihre Aufmerksamkeit auf die datasources.json-Datei hier lenken.
In der Datei data sources.json
werden hier alle verschiedenen Datenquellen konfiguriert.
Im Moment haben wir nur die DB, die
die In-Memory-DB-Datenbank ist, die LoopBack standardmäßig konfiguriert,
und dann
absorbiert die MongoDB, die wir gerade konfiguriert haben, nur die Information, dass die Eingabe
in diese Datenquellen gespeichert wurde, json-Datei.
So werden Sie sehen, dass LoopBack selbst arbeitet, indem Sie alle diese Dateien konfigurieren
, die das LoopBack-Framework selbst verwendet, wenn es
den Loopback-basierten Rest API-Server startet.
Lassen Sie uns hier in das Modell config.json Datei gehen.
Das Modell config.json Datei selbst
speichert eine Menge Informationen hier, was für uns nützlich ist,
aber hier, lassen Sie uns gehen und ein paar Dinge ändern.
Also in diesem, werden wir sehen, dass es wieder für die Gerichte,
Aktionen und Führer, die Datenquelle wurde als DB konfiguriert.
Also werden wir das hier zu MongoDB ändern.
Nicht nur für diese,
sie werden auch ändern, dass für Promotions, und auch Führer,
was bedeutet, dass alle diese drei ihre Daten von der MongoDB ableiten.
Auch für die Rolle, die hier definiert ist.
Wir werden auch in MongoDB speichern.
Wir werden ziemlich bald sehen, wie wir die Rolle
und auch das RoleMapping hier nutzen werden.
Wir werden den Grund für diese beiden in kurzer Zeit verstehen.
Und dann, ACL, die Access Control Lists,
diese werden auch in MongoDB gespeichert werden.
Und dann, der Benutzer, auch,
werden wir es in MongoDB speichern,
und dann werden sie es dort lassen.
Dies sind also die Änderungen, die Sie an
der Datei model-config.json vornehmen und dann die Änderungen speichern sollten.
Wie bereits erwähnt,
unterstützt Loopback standardmäßig dieses Modell namens „user“,
das zur Unterstützung der Benutzerauthentifizierung verwendet wird.
Das Benutzermodell selbst speichert nur drei verschiedene Eigenschaften.
Der Benutzername, die E-Mail-Adresse
und die kennwortbezogenen Informationen.
Nun, wenn sie
eine aufwendigere Möglichkeit haben möchten, zusätzliche Informationen über Benutzer zu speichern.
Dann können sie dieses Benutzer-Basismodell
unterklassifizieren und dann davon Gebrauch machen.
In diesem nächsten Schritt
werde ich ein anderes Modell namens Kundenmodell erstellen,
das den Benutzer als Basismodell für seine Funktion verwendet.
Und das Kundenmodell selbst speichert zusätzliche Informationen über Benutzer.
Also, im Kundenmodell,
werde ich die Dinge wie den Vornamen,
den Nachnamen und das Bild für den Benutzer speichern und so weiter.
So wird der Kunde genau wie das Benutzermodell handeln,
das bereits mit einem eigenen Satz der Methoden kommt.
Und so wird das Benutzermodell für die Benutzerauthentifizierung verwendet,
so dass Sie den Benutzernamen und das Kennwort eingeben
und sich anmelden und abmelden können.
Wenn wir also dieses Kundenmodell basierend auf der Basisklasse des Benutzermodells erstellt haben,
unterstützt das Kundenmodell auch die Anmelde- und
Abmeldevorgänge mit diesem Kundenmodell.
So können wir den Benutzer einloggen und den Benutzer abmelden und so weiter.
So kommt die Benutzerauthentifizierung automatisch für das Richtige.
Also, um das Kundenmodell zu erstellen, geben Sie an der
Eingabeaufforderung lb model ein und für den Modellnamen
geben wir Kunde ein.
Und die DataSource, Ich werde es als MongoDB wählen.
Und dann, wenn es darum bittet, die Basisklasse
des Modells auszuwählen, anstatt das PersistedModel zu verwenden,
werden wir nach unten gehen
und dann den Benutzer als Basisklasse auswählen.
Auf diese Weise werden alle Eigenschaften
der Basisbenutzerklasse abgeleitet, die bereits in Loopback integriert ist.
Und dann werden wir dies mit der REST-API
und dem benutzerdefinierten Plural MT verfügbar machen.
Und dann wäre das im gemeinsamen Ordner.
Und dafür sind die drei Eigenschaften, die wir hinzufügen werden,
Vorname, die wir die Typen String haben würden.
Und dies ist nicht erforderlich oder hat keinen Default-Wert.
Und dann, Nachname wieder als Typ Zeichenfolge,
nicht erforderlich, und kein Default-Wert.
Und dann Bild vom Typ String,
nicht erforderlich und kein Default-Wert.
Sie sehen also, dass die Kundenklasse selbst
zusätzliche Eigenschaften zusätzlich zur Benutzerklasse trägt.
die Benutzerklasse unterstützt bereits den Benutzernamen,
die E-Mail und die kennwortbezogenen Informationen dort.
Also, die Kundenklasse,
da Unterklasse die Basisklasse ist,
erhalten wir den Benutzernamen und die E-Mail automatisch von der Benutzerklasse.
Und jetzt, wenn Sie zur Datei model-config.jason gehen,
werden Sie sehen, dass das Kundenmodell bereits dort hinzugefügt wurde.
Und dann in den gängigen Modellen
sehen Sie nun die Datei customer.json
mit diesen drei zusätzlichen Eigenschaften hinzugefügt, die wir dem Kundenmodell hinzugefügt haben.
Beachten Sie jedoch, dass es hier die Basis als Benutzerklasse für das Kundenmodell angibt. Auf
diese Weise können Sie mit Loopback
eine Basismodellklasse aufnehmen und diese dann in die Modellklasse unterklassen.
Sie werden also sehen, wie Loopback es uns ermöglicht, die Benutzerauthentifizierung mithilfe
der Benutzerklasse automatisch zu unterstützen und dann sogar zusätzliche Unterklasse
zu definieren, die zusätzliche Informationen im Zusammenhang mit der Benutzer-Basisklasse speichert.
Als nächstes werden wir Access Control für
die verschiedenen Modelle einrichten, die wir bereits in unserem Loopback-Server eingerichtet haben.
Also, um die Zugriffssteuerung einzurichten,
oder die Zugriffssteuerungslisten in Lookback.
Loopback verwendet diese Zugriffssteuerungslisten, um anzugeben, welche Art von
Operationen auf
den verschiedenen REST-API-Endpunkten ausgeführt werden können, die den verschiedenen Modellen entsprechen.
Also, um dies zu tun, geben wir an der Eingabeaufforderung lb acl,
ACL steht für Access Control Lists.
Und dann, wenn das vorbei ist, werden wir sagen, auf
welches Modell wir diese Zugriffssteuerungsliste anwenden möchten.
Und dann werden wir sagen, alle vorhandenen Modelle.
Und wir werden sagen,, Alle Metriken und Eigenschaften.
Und wir werden sagen,
Alle Arten von Operationen.
Und dann, wir werden sagen,, Alle Benutzer.
Und dann werden wir sagen, explizit den Zugriff verweigern.
Also, wir schließen zuerst alle Modelle für alles ab,
dann werden wir langsam öffnen,
unabhängig von Operationen, die von verschiedenen Benutzern ausgeführt werden können.
Also, ersten Schritt, wir haben
alle Arten von Operationen auf allen Modellen, die wir derzeit haben, geschlossen.
Dann werden wir langsam beginnen, jede einzelne Operation Schritt für Schritt zu öffnen.
Nun, der nächste Schritt,
was wir tun werden, ist wieder die nächste Zugriffskontrollliste einrichten.
In der zweiten Zugriffssteuerungsliste, sagen wir,
für alle vorhandenen Modelle und wir sagen,
Alle Metriken und Eigenschaften.
Und dann, werden wir sagen, nur Lesezugriff. Das
heißt, wenn der Benutzer die GET-Operationen an diesen Endports ausführen kann.
Und diese GET-Operationen können von allen Benutzern ausgeführt werden.
So können Benutzer Informationen abrufen.
Und dafür gewähren wir explizit den Zugriff.
Das bedeutet, dass GET-Operationen auf dem REST-API-Endpunkt-Knoten erlaubt sind.
Zuerst haben wir alles geschlossen,
dann haben wir nur die GET-Operationen für die Benutzer geöffnet.
Nun, schließlich, werden sie zu jedem der Modelle gehen
und dann schließen und zulassen, dass bestimmte Operationen nur
von bestimmten Arten von Benutzern ausgeführt werden.
Um dies zu tun, ist
die nächste ACL, die wir einrichten werden, für ein bestimmtes Modell.
Also, wir werden das für Geschirr einrichten.
Und wir werden sagen, eine einzige Methode.
Und dann ist der Methodenname, erstellen.
Also, was bedeutet, dass die Schaffung dieser wird nur durch erlaubt.
Also, wieder, wenn es sagt, wählen Sie die Rolle,
dann für die Rolle, sagen wir, andere.
Und dann wäre der Rollenname admin.
Also, was wir mit dieser Operation tun ist, dass
wir sagen, dass nur ein Admin-Benutzer neue Gerichte erstellen oder bestehende Gerichte aktualisieren kann.
Also, das ist ein bisschen nah dran, die verbleibenden Operationen.
Also, lasst uns dasselbe für Führer tun.
Und eine einzige Methode und dann,
die erstellen und wir werden sagen,
nur der Administrator kann dies tun.
Und dann endlich auch für Promotions.
Für Werbeaktionen.
Die Methode create wird
nur von Benutzern erlaubt, die über die angegebene Rolle als Administrator verfügen.
Wir werden sehen, wie wir Benutzer mit einer bestimmten Rolle im nächsten Schritt erstellen. Zugriff
explizit gewähren.
Beachten Sie nun, dass ich Kunden für Erstellungsvorgänge nicht geschlossen habe.
Wenn ich Kunden abschließe,
kann sich niemand im System registrieren.
Deshalb werde ich das offen lassen.
Denn der Kunde sollte in der Lage sein, sich im System zu registrieren.
So können Sie sich für neue Konten auf dem System registrieren.
Benutzerkonten auf dem System.
Also, das wird offen bleiben für die Menschen zu tun.
Also, um das für die Kunden zu ermöglichen, sagen wir, Kunden,
Eine einzige Methode, erstellen Sie alle Benutzer.
So können Kunden von allen Benutzern erstellt werden, da sich
dadurch Personen bei ihrem Konto anmelden können.
Schließlich werden wir sehen, wie wir unseren Server so konfigurieren können, dass
ein einzelner Admin-Benutzer automatisch in unseren Loopback-Server konfiguriert wird.
Um dies zu tun,
in unserem Loopback-Server,
im Server-Ordner haben wir diesen Boot-Unterordner hier.
Was auch immer Code, den wir in den Boot-Unterordner legen,
wird beim Start unseres LoopBack-Servers ausgeführt.
Also, hier werden Sie sehen, dass wir bereits diese authentication.js haben,
die bereits eingerichtet ist,
ein Loopback, der die Benutzerauthentifizierung für uns einrichten wird.
Und dann haben wir die root.js, die
einige zusätzliche Informationen für unseren RAM Loopback Server einrichten wird.
Und wir können hier zusätzliche Dateien hinzufügen.
Also, ich werde dort in den Boot-Ordner gehen
und dann in dieser Datei namens script.js hinzufügen.
Und in dieser script.js
werde ich den Code einrichten, um standardmäßig einen Admin-Benutzer zu erstellen.
Also, in der script.js,
die nichts anderes als ein dateibasiertes NPM-Modul sein wird,
werden wir beginnen, indem wir sagen,
module.exports = Funktion (app).
Die App ist die Loopback-App,
die als Parameter für diese Funktion für uns bereitgestellt wird.
Und so können wir es in unserem Code hier nutzen.
Also, hier, werden wir zuerst einen Admin-Benutzer einrichten.
Also, um das zu tun, werden wir sagen,
var Kunde = App.Models.Customer.
Dies gibt uns also Zugriff auf das Kundenmodell.
Dann werden wir sagen, Kunden.Findone.
Also, wir werden zuerst überprüfen, ob ein Benutzer mit
dem Benutzernamen als admin bereits im System konfiguriert ist oder nicht.
Wenn nicht, dann werde ich einen Admin-Benutzer erstellen.
Und das versorgt mich mit einer Callback-Funktion mit zwei Parametern, Err und Benutzern.
Und in diesem- Also werden wir zuerst versuchen zu
sehen, ob ein Benutzer mit seinem Namen admin bereits existiert.
Wenn der Benutzer nicht existiert,
werden wir den Benutzer erstellen.
Also, um den Benutzer zu erstellen,
sagen wir hier, wenn nicht Benutzer.
Also, wenn die Benutzer nicht null sind oder wenn der Benutzer null sagt,
dann bedeutet das, dass es keinen Admin-Benutzer gibt, also muss ich hier einen Admin-Benutzer erstellen.
Also in diesem Fall werden wir sagen, customer.create.
Und diese Erstellung nimmt ein Array von Objekten, wenn Sie möchten.
Und dieses Array von Objekten ermöglicht es uns, anzugeben, welche Benutzerkonten wir erstellen möchten.
Das erste Benutzerkonto, das ich erstellen möchte oder
das einzige Benutzerkonto, das ich erstellen möchte, ist der „Admin“.
Dies wird also der Standard-Administrator für
meinen Loopback-Server sein und dann kann ich die E-Mail konfigurieren.
Also erinnern Sie sich, dass das Benutzermodell diese Eigenschaften unterstützt,
confusion.net und dann Passwort, das
ich als Passwort konfigurieren werde.
Sie können dabei auch
den Vornamen und den Nachnamen
für den Admin-Benutzer angeben.
Aber ich werde es als solche lassen,
als leer, weil diese für den Admin-Benutzer nicht benötigt werden.
Also werde ich es dort lassen.
Dieser Befehl wird also am Ende einen neuen Kunden mit dem Namen „Admin“ erstellen.
Wenn also dieser Benutzer oder der Name „Admin“ nicht existiert,
dann werden wir einen erstellen.
Und dann haben wir hier die Callback-Funktion.
Also irren Sie Benutzer.
Jetzt werde ich sagen,
wenn äh, wir wissen nicht, was es zu tun versucht, also werfen wir einfach den Fehler.
Aber normalerweise erwarten wir nicht, dass dies geschieht.
Wie bezeichnen Sie diesen Benutzer nun als Administratorbenutzer?
Also jetzt, wenn ich mich hier anmelde,
melde ich nur einen normalen Benutzer hier an,
aber wir wollen diesem Benutzer eine besondere Rolle geben.
Daher unterstützt Loopback eine Möglichkeit zum Angeben von Rollen für Benutzer.
Also, um eine Rolle anzugeben,
wir werden var Rolle = App.Models.role.
So kann ich
hier eine Rolle erstellen, einen neuen Rollenaufruf admin.
So können wir verschiedene Drohnen verschiedenen Benutzern zuweisen, wenn Sie möchten.
Und dazu
muss ich hier auch ein Rolemapapping erstellen.
Also sagen wir, App.Models.Rolemapping.
Und wenn es so ist, dass die Datenbank bereits ein
Rolemapping enthält, das bereits existiert,
dann werde ich all diese zerstören, wenn ich meinen Server starte.
Und dann lassen Sie mich versuchen
zu sehen, ob eine Rolle mit
diesem Namen admin bereits
im System existiert.
Ok.
Und in diesem dauert,
wie Sie erwarten würden,
eine Callback-Funktion und im Inneren werden wir sagen, Rolle.Findone.
Wenn also bereits eine Rolle mit dem Namen admin
existiert, muss ich keine erstellen.
Andernfalls, wenn das nicht existiert,
muss ich die Rolle erstellen.
Also werden wir sagen, Rolle.Create.
So werden wir Admin-Rolle hier erstellen.
Und dann führt uns dies zu Parametern irr,
Rolle hier, in der Callback-Funktion.
Nun, hier, um den Fehler zu behandeln,
kopieren wir einfach dieses 'if err' und fügen es dann dort ein.
Ähnlich hier auch, wenn der Fehler auftritt,
dann muss ich damit umgehen.
Also „wenn Fehler“, dann „werfen Sie den Fehler“.
Andernfalls haben wir die Rolle erstellt.
Jetzt muss ich diese Rolle diesem bestimmten Benutzer zuordnen, den ich gerade erstellt habe.
Dieser Benutzer, den ich gerade hier erstellt habe.
Dieser Benutzer. Ich möchte diesem Benutzer die Rolle des Administrators geben.
Also, da ich diese Rolle durch den Namen admin erstellt habe,
so sagen wir, role.principals.create.
So erstellen Sie hier eine Zuordnung zwischen der Rolle und einem bestimmten Benutzer.
Also sagen wir, role.principals.create.
Das ist also die Syntax dort.
Wir werden sagen, PrincipalType: RolleMapping.User
hier und Sie werden
eine Prinzipal-ID nehmen, die die Benutzer ist.
Worauf bezieht sich dieser Benutzer?
Dieser Benutzer bezieht sich auf diese, die gerade kam.
Also, wenn wir diese Benutzer erstellt,
dann muss der Kunde eine erfolgreiche Rückkehr zu uns hier erstellen.
Das ist also, was ich hier benutzen werde.
Wir werden sagen, Benutzer [0].
Dies wäre also ein Array von Benutzern, die erstellt wurden und nur einen von ihnen enthalten.
Deshalb sage ich Benutzer [0].
Und dann werden wir die ID dieses Benutzers hier zuweisen.
So erstellen wir also ein RoleMapping zwischen der Rolle, die wir gerade erstellt haben,
dieser Rolle, und ordnen es dann dem Kunden zu, den wir gerade erstellt haben.
Nun führt uns dies auch zu Parametern, der Callback-Funktion.
Und in dieser Callback-Funktion werden wir einfach sagen,
wenn (err) throw (err).
Sonst sind wir nicht wirklich daran interessiert zu wissen, was dort noch passiert ist.
Das war's. Das ist also, wie.
Wenn also die Rolle „admin“ nicht existiert,
erstellen wir diese Rolle.
Wenn nicht- Also das ist der 'else'
Teil, in dem ich noch dieses Mapping machen muss.
Also lassen Sie mich diesen Code kopieren und dann werde ich genau das hier tun.
Also role.principals.create und mappe dies dann für den Benutzer dort ab.
Wenn also die Administratorrolle bereits vorhanden
ist, müssen sie nur die Zuordnung durchführen.
Dies wird also im RoleMapping-Modell in unserer Datenbank gespeichert. Das ist es.
Also wird dieser Code, den wir in die Datei script.js einfügen, zuerst versuchen zu
finden, ob ein Admin-Benutzer existiert und dieser Benutzer durch den Namen admin identifiziert wird.
Wenn nicht, wird der Benutzer erstellt und erstellt dann auch die Rolle für den Benutzer.
Wir erstellen eine Rolle mit dem Namen admin.
Wenn diese Rolle existiert,
werden wir sie einfach verwenden.
Andernfalls erstellen wir die Rolle.
Und danach werden wir diese Zuordnung zwischen der Rolle und dem Benutzer erstellen.
So Loopback ermöglicht es uns, das RoleMapping zu tun.
Also zu sagen, dass dieser Benutzer nicht für diese Rolle ist.
Diese Zuordnung wird also mit dieser Anweisung durchgeführt.
Damit ist das Setup unserer Server abgeschlossen.
Damit ein Admin-Benutzer erstellt wird und dieser Admin-Benutzer
automatisch die Rolle des Admins erhält, wie hier konfiguriert.
Das war's. Lassen Sie uns die Änderungen in script.js speichern.
Und jetzt sollten unsere Loopback-Server bereit sein.
Also werden wir jetzt gehen und unseren Go Back-Server starten und dann überprüfen, was wir damit machen können.
Gehen wir zu den Terminals,
starten wir den Loopback-Server.
Also sagen wir, npm start und dann sollte unser Server betriebsbereit sein.
Gehen wir zum Explorer und durchsuchen Sie dann die Informationen dort.
Und dieser Loopback-Server wird sich automatisch
mit meinem MongoDP verbunden haben, weil ich die Verbindung eingerichtet habe.
Gehen Sie zu meinem Browser,
lassen Sie mich das neu laden.
Und wenn ich das neu lade,
werden Sie jetzt sehen, dass wir einen neuen Kunden haben, der hier erstellt wurde.
Der Benutzer war bereits früher vorhanden.
Die Gerichte, Führer und Aktionen sind alle da.
Lassen Sie uns ein Get auf dem Geschirr durchführen.
Nun, da dies mit dem Mund MongoDB verbunden ist, hat
meine MongoDB bereits einige Gerichte drin.
Wenn Ihre MongoDB leer ist,
können Sie einige Gerichte mit dem Beitrag hier posten.
Also lasst es uns ausprobieren.
Wenn ich eine get Operation auf den Schrägstrich Gerichte,
Sie werden sehen, dass in der Antwort Körper -
Alle Gerichte, die in meiner Datenbank existieren, wurden alle geholt.
In ähnlicher Weise kann ich ein GET auf
Promotions machen und ich sollte die Promotion sehen, die bereits in meiner Datenbank existiert.
So können Sie sehen, dass die Werbeaktion dort bereits existiert.
Das zeigt uns also, wie wir Informationen abrufen können.
Versuchen wir nun, ein neues Gericht zu posten.
Also, um ein neues Gericht zu posten,
gehen wir hier zum POST.
Lassen Sie mich das einfach kopieren.
Offensichtlich,
in diesem Moment, denn da ich nicht ein eingeloggt bin,
werde ich nicht erlaubt, das Gericht so zu posten,
aber ich
werde zeigen, dass Sie nur kopieren und fügen Sie diese Informationen hier, und wir werden versuchen, dieses Gericht zu posten,
und dann, wenn ich versuche, das Gericht zu posten,
mein Server antwortet sofort mit diesem Fehler, der sagt, AUTHORIZATION_REQUED.
Sie sind nicht berechtigt, diesen Vorgang auszuführen.
Deshalb sind Sie nicht berechtigt, diesen Vorgang durchzuführen.
Wie autorisierst du dich selbst?
Also, um sich selbst zu autorisieren,
erinnern Sie sich jetzt, dass wir bereits einen Benutzer mit dem Namen admin erstellt haben,
und dieser Admin-Benutzer existiert bereits als Kunde hier.
Wenn Sie also in die REST-API-Endpunkte des Kunden scrollen
, sehen Sie hier unten die Anmeldung dieses Kunden.
Also, wenn Sie einen POST auf die Anmeldung des Kunden tun.
Also, für die Anmeldung des Kunden,
scrollen Sie hier nach oben und dann fragt es nach den Anmeldeinformationen.
Also, in den Anmeldeinformationen,
können wir Benutzernamen in doppelte Anführungszeichen eingeben, und wir sagen,
Admin, und dann Passwort,
sagen wir, Passwort, und dann werden wir dies veröffentlichen.
Und dann, wenn Sie es posten,
werden Sie feststellen, dass
LoopBack in der Antwort mir diese Informationen zurücksendet.
Nun, innerhalb dieser Informationen
ist diese bestimmte ID, die sie zurücksendet, der AccessToken für meinen LoopBack-Server.
Also, ich kann diesen AccessToken einfach hier kopieren,
und dann rechts oben hier
können Sie sehen, dass dies Token Not Set ist, hier.
Es steht Token Not Set.
Und hier können Sie diesen AccessToken eingeben
und dann sagen, Zugriffstoken festlegen.
Und dann wird Ihr AccessToken gesetzt,
und dann werden alle nachfolgenden Operationen, die Sie ausführen, automatisch
diesen AccessToken in der Kopfzeile meiner Anforderungsnachricht tragen.
Also, auf diese Weise wird mein Admin jetzt erlaubt, Beiträge von Artikeln dort zu machen.
Nun, da ich mich als Admin angemeldet habe,
lassen Sie mich zu Promotions gehen,
und dann werde ich eine Promotion dort posten
und Ihnen zeigen, dass ich tatsächlich Werbeaktionen posten kann.
Also, lassen Sie uns zu einem POST gehen,
und dann werden wir einfach kopieren, und dann in den Daten,
und dann für den Namen, den wir sagen, Test-Förderung,
und Bild werden wir es einfach als solche lassen, Beschreibung, Testbeschreibung.
Und ich kann es dort veröffentlichen,
und Sie werden sehen,
dass ich diese ID nicht hier einfügen sollte, weil ich
LoopBack automatisch die ID zuweisen lassen habe.
Lassen Sie mich dies posten und dann würden Sie sehen, dass im Antwortkörper
die Testförderung hier veröffentlicht wurde.
Und ich habe gerade bemerkt, dass ich
die Flagge für meine Aktionen und meine Führungskräfte nicht enthalten habe.
Also, ich werde in gehen und fügen Sie die Featured Flag als
einen der Teile meiner Promotions dort.
Wenn ich nun ein GET für die Werbeaktionen mache,
werden Sie sehen, dass in dieser Antwortnachricht die
alte Werbeaktion angezeigt wird, die bereits in meiner Datenbank war,
und dann die neue Werbeaktion, die ich gerade in meiner Datenbank gepostet habe, die bereits hier enthalten ist.
Also, Ich habe gerade bemerkt, dass ich die Featured Flag setzen muss,
Ich werde Ihnen zeigen, wie das in einem zu tun.
So, diese Art von zeigt Ihnen, wie Sie sich anmelden und erkunden Sie Ihren LoopBack-Server.
Lassen Sie mich dieses Token zerstören,
also entfernen wir einfach das Token
und klicken Sie dann darauf,
damit das Zugriffstoken im Wesentlichen an eine
leere Zeichenfolge gesendet wird und mein Token nicht mehr verarbeitet wird,
so dass jetzt mein Benutzer nicht mehr angemeldet ist.
Lassen Sie mich einen neuen Kunden erstellen.
Also, um einen neuen Kunden zu erstellen, werde ich sagen, POST-Kunden.
Und dann kopiere ich das einfach von hier.
Ich erstelle mir hier ein neues Konto.
Und so, hier,
werde ich entfernen die Realm,
ich brauche das nicht, ich brauche nicht die ID.
Also, für den Vornamen
und die EmailVerified sollte automatisch vom System gesetzt werden.
Also, lassen Sie mich als dieser Benutzer anmelden.
Also, ich werde nur meinen Vornamen, Nachnamen
und das Bild einreichen,
ich werde nur eine leere Zeichenfolge dort setzen, Benutzername und E-Mail.
Und dann werden wir es ausprobieren,
und dann kommt es wieder zu sagen,
Details: 'Passwort' kann nicht leer sein.
Also, Sie werden feststellen,
dass ich hier auch zusammen mit dem Benutzernamen,
Passwort und dann, lassen Sie uns dies posten.
Also, wenn Sie es posten, kommt es mit
dem Antwortkörper zurück, der sagt, dass Sie jetzt Teil des Systems sind.
Also, Ihr Vorname,
Ihr Nachname und Ihr Benutzername, Ihre E-Mail-ID
und die ID, die LoopBack Ihnen zuweist, werden an Sie zurückgesendet.
Also, das ist nichts anderes als die MongoDB-ID, wie Sie hier sehen können.
Nun, da ich mich als Kunde angemeldet habe,
sollte ich in der Lage sein, mich als Kunde anzumelden,
damit ich zum POST-Login hier gehe,
und dann
werde ich mich hier anstelle des Admins als der neue Benutzer anmelden, den ich angemeldet habe.
Also, dann klicke ich auf, um es auszuprobieren,
du wirst sehen, dass es mit der ID zurückkehrt,
also gibt es mir das Token für diesen Admin-Benutzer hier.
Damit haben wir die Untersuchung des LoopBack-Servers abgeschlossen, den wir gerade erstellt haben.
Und wie ich gerade erwähnt,
bemerkte ich, dass die Aktionen und die Führer nicht Flag gekennzeichnet haben, also
werde ich in den Code gehen.
Angenommen, Sie vergessen so etwas,
dann können Sie einfach eingehen und den Json-Code bearbeiten, wenn Sie möchten.
Also, ich gehe in meinen Code,
gehe zum Code,
ich gehe zuerst in Commons und dann gehe ich in die dishes.json.
Und dann in der dishes.json,
sehe ich diese vorgestellte Eigenschaft dort.
Ich werde diese vorgestellte Eigenschaft kopieren,
und dann gehe ich in leaders.json,
und dann füge ich diese Feature-Eigenschaft in eine leaders.json
und auch mit promotions.json ein.
Ich habe vergessen, dies einzubeziehen, als ich diese Modelle erstellt habe.
Ich hätte dies tun sollen, als ich das Modell selbst erstellt habe.
Wenn Sie so etwas vergessen,
dann ist dies eine andere Möglichkeit, Ihr Modell zu bearbeiten
und dann sicherzustellen, dass Ihr Modell korrekt eingerichtet ist.
Also, das war's.
Also, jetzt werden meine Promotionen und Führer auch die vorgestellte Flagge dort gesetzt haben.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir gesehen, wie wir
ein neues Modell einrichten können, indem wir eine Basismodellklasse erweitern, die bereits in LoopBack ist.
Wir haben auch gesehen, wie wir Zugriffskontrollen mithilfe
der Zugriffskontrolllisten einrichten konnten, die von LoopBack unterstützt werden.
Damit schließen wir diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie zu tun, eine mit
der Nachricht LoopBack-Datenquellen und Zugriffskontrolle abgedeckt.