parse dashboard
6.0.0
Parse Dashboard ist ein eigenständiges Dashboard zum Verwalten Ihrer Parse Server -Apps.
Installieren Sie das Dashboard von npm .
npm install -g parse-dashboard
Sie können das Dashboard für eine App mit einem einzelnen Befehl starten, indem Sie eine App -ID, einen Master -Schlüssel, eine URL und einen Namen angeben:
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --appName optionalName
Sie können den Host-, Port- und Mount-Pfad festlegen, indem Sie die Optionen --host , --port und --mountPath Optionen zur Analyse von Dasscharben versorgen. Sie können alles, was Sie wollen, als App -Name verwenden oder es herauslassen. In diesem Fall wird die App -ID verwendet.
Der Parameter --dev deaktiviert die Produktionssicherheitsfunktionen. Dieser Parameter ist nützlich, wenn das Parse Dashboard auf Docker ausgeführt wird. Mit diesem Parameter wird:
allowInsecureHTTPmasterKey ohne Verschlüsselung in ClearText übertragen
Euen Verwenden Sie diesen Parameter bei der Bereitstellung von Parse Dashboard in einer Produktionsumgebung nicht.
Nach dem Start des Dashboard können Sie http: // localhost: 4040 in Ihrem Browser besuchen:
Parse Dashboard ist mit den folgenden Parse -Server -Versionen kompatibel.
| Das Dashboard -Version analysieren | Serverversion analysieren | Kompatibel |
|---|---|---|
| > = 1.0 | > = 2.1.4 | ✅ Ja |
Parse Dashboard wird kontinuierlich mit den neuesten Releases von Node.js getestet, um die Kompatibilität sicherzustellen. Wir folgen dem Langzeitunterstützungsplan von Node.js und testen nur gegen Versionen, die offiziell unterstützt werden und ihr Datum am Ende des Lebens nicht erreicht haben.
| Version | Neueste Version | Lebensende | Kompatibel |
|---|---|---|---|
| Node.js 18 | 18.20.4 | Mai 2025 | ✅ Ja |
| Node.js 20 | 20.18.0 | April 2026 | ✅ Ja |
| Node.js 22 | 22.9.0 | April 2027 | ✅ Ja |
| Parameter | Typ | Optional | Standard | Beispiel | Beschreibung |
|---|---|---|---|---|---|
apps | Array <Objekt> | NEIN | - - | [{ ... }, { ... }] | Die Apps, die für das Dashboard konfiguriert sind. |
infoPanel | Array <Objekt> | Ja | - - | [{ ... }, { ... }] | Die Info -Panel -Konfiguration. |
infoPanel[*].title | Saite | NEIN | - - | User Details | Der Panel -Titel. |
infoPanel[*].classes | Array <string> | NEIN | - - | ["_User"] | Die Klassen, für die das Info -Panel angezeigt werden sollte. |
infoPanel[*].cloudCodeFunction | Saite | NEIN | - - | getUserDetails | Die Cloud -Code -Funktion, die das ausgewählte Objekt im Datenbrowser empfangen und die Antwort zurückgibt, die im Info -Bereich angezeigt werden soll. |
apps.scripts | Array <Objekt> | Ja | [] | [{ ... }, { ... }] | Die Skripte, die für diese App ausgeführt werden können. |
apps.scripts.title | Saite | NEIN | - - | 'Delete User' | Der Titel, der im Datenbrowser -Kontextmenü und im Dialogfeld "Datenbrowser" angezeigt wird. |
apps.scripts.classes | Array <string> | NEIN | - - | ['_User'] | Die Klassen von Parse -Objekten, für die die Skripte ausgeführt werden können. |
apps.scripts.cloudCodeFunction | Saite | NEIN | - - | 'deleteUser' | Der Name der ausführenden Parse -Cloud -Funktion. |
apps.scripts.showConfirmationDialog | Bool | Ja | false | true | Ist true , wenn ein Bestätigungsdialog angezeigt werden sollte, bevor das Skript ausgeführt wird, false , wenn das Skript sofort ausgeführt werden sollte. |
apps.scripts.confirmationDialogStyle | Saite | Ja | info | critical | Der Stil des Bestätigungsdialogs. Gültige Werte: info (blauer Stil), critical (roter Stil). |
apps.cloudConfigHistoryLimit | Ganze Zahl | Ja | 100 | 100 | Die Anzahl der historischen Werte, die in der Cloud -Konfigurationsänderungsverlauf gespeichert werden sollten. Gültige Werte: 0 ... Number.MAX_SAFE_INTEGER . |
Sie können das Dashboard auch mit einer Konfigurationsdatei aus der Befehlszeile starten. Erstellen Sie dazu eine neue Datei namens parse-dashboard-config.json in Ihrer lokalen Parse Dashboard-Verzeichnis-Hierarchie. Die Datei sollte mit dem folgenden Format übereinstimmen:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " MyApp "
}
]
} Sie können dann das Dashboard mit parse-dashboard --config parse-dashboard-config.json starten.
Dies funktioniert nur beim Starten der App mit dem Befehl
parse-dashboard
Es gibt auch zwei Methoden, mit denen Sie das Dashboard mithilfe von Umgebungsvariablen konfigurieren können.
Geben Sie die gesamte JSON -Konfiguration in PARSE_DASHBOARD_CONFIG an und sie wird genau wie die Konfigurationsdatei analysiert.
Sie können auch jede Konfigurationsoption einzeln definieren.
HOST: "0.0.0.0"
PORT: "4040"
MOUNT_PATH: "/"
PARSE_DASHBOARD_TRUST_PROXY: undefined // Or "1" to trust connection info from a proxy's X-Forwarded-* headers
PARSE_DASHBOARD_SERVER_URL: "http://localhost:1337/parse"
PARSE_DASHBOARD_MASTER_KEY: "myMasterKey"
PARSE_DASHBOARD_APP_ID: "myAppId"
PARSE_DASHBOARD_APP_NAME: "MyApp"
PARSE_DASHBOARD_USER_ID: "user1"
PARSE_DASHBOARD_USER_PASSWORD: "pass"
PARSE_DASHBOARD_SSL_KEY: "sslKey"
PARSE_DASHBOARD_SSL_CERT: "sslCert"
PARSE_DASHBOARD_CONFIG: undefined // Only for reference, it must not exist
PARSE_DASHBOARD_COOKIE_SESSION_SECRET: undefined // set the cookie session secret, defaults to a random string. Use this option if you want sessions to work across multiple servers, or across restarts
Das Verwalten mehrerer Apps aus demselben Dashboard ist ebenfalls möglich. Fügen Sie einfach zusätzliche Einträge in das "apps" -Array der parse-dashboard-config.json Datei hinzu:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " , // Self-hosted Parse Server
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App "
},
{
"serverURL" : " http://localhost:1337/parse2 " , // Self-hosted Parse Server
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App 2 "
}
]
}Parse Dashboard verfügt über einen integrierten GraphQL-Spielplatz, um mit der automatisch generierten Parse GraphQL-API zu spielen.
Sie können den GraphQL-Spielplatz einrichten, indem Sie die Option --graphQLServerURL an die parse-dashboard -CLI übergeben:
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --graphQLServerURL "https://example.com/graphql" --appName optionalName
Die Option graphQLServerURL ist auch über eine Umgebungsvariable mit dem Namen PARSE_DASHBOARD_GRAPHQL_SERVER_URL verfügbar:
HOST: "0.0.0.0"
PORT: "4040"
MOUNT_PATH: "/"
PARSE_DASHBOARD_SERVER_URL: "http://localhost:1337/parse"
PARSE_DASHBOARD_GRAPHQL_SERVER_URL: "http://localhost:1337/graphql"
PARSE_DASHBOARD_MASTER_KEY: "myMasterKey"
PARSE_DASHBOARD_APP_ID: "myAppId"
PARSE_DASHBOARD_APP_NAME: "MyApp"
Sie können den GraphQL-Spielplatz auch in Ihrer parse-dashboard-config.json Datei einrichten:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"graphQLServerURL" : " http://localhost:1337/graphql " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App "
},
{
"serverURL" : " http://localhost:1337/parse2 " ,
"graphQLServerURL" : " http://localhost:1337/graphql2 " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App 2 "
}
]
}Nach dem Start des Dashboard können Sie http://0.0.0.0:4040/apps/mytestapp/api_console/graphql in Ihrem Browser:
Parse Dashboard unterstützt das Hinzufügen eines optionalen Symbols für jede App, sodass Sie diese in der Liste einfacher identifizieren können. Dazu müssen Sie die Konfigurationsdatei verwenden, einen iconsFolder -darin definieren und den iconName -Parameter für jede App (einschließlich der Erweiterung) definieren. Der Pfad des iconsFolder ist relativ zur Konfigurationsdatei. Wenn Sie ParseDashboard weltweit installiert haben, müssen Sie den vollständigen Pfad als Wert für den iconsFolder verwenden. Um zu visualisieren, was es bedeutet, befindet sich in den folgenden icons ein Verzeichnis, das sich im selben Verzeichnis wie die Konfigurationsdatei befindet:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
}
],
"iconsFolder" : " icons "
} Parse Dashboard unterstützt das Hinzufügen einer optionalen Hintergrundfarbe für jede App, sodass Sie sie in der Liste einfacher identifizieren können. Dazu müssen Sie die Konfigurationsdatei verwenden, ein primaryBackgroundColor und secondaryBackgroundColor -Parameter für jede App definieren. Es ist CSS style . So visualisieren Sie, was es bedeutet, im folgenden Beispiel finden Sie eine backgroundColor :
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"primaryBackgroundColor" : " #FFA500 " , // Orange
"secondaryBackgroundColor" : " #FF4500 " // OrangeRed
},
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App [2] " ,
"primaryBackgroundColor" : " rgb(255, 0, 0) " , // Red
"secondaryBackgroundColor" : " rgb(204, 0, 0) " // DarkRed
}
]
} Sie können appNameForURL für jede App festlegen, um die URL Ihrer App im Dashboard zu steuern. Dies kann es einfacher machen, Lesezeichen oder Links in Ihrem Dashboard zu verwenden.
Um die App in Produktion zu ändern, setzen Sie production einfach in Ihre Konfigurationsdatei auf true fest. Der Standardwert ist falsch, wenn nicht angegeben.
Sie können verhindern, dass einige Spalten sortierbar sind, indem Sie in jeder App -Konfiguration zu Spaltenpreferenzoptionen preventSort
"apps" : [
{
"appId" : " local_app_id " ,
"columnPreference" : {
"_User" : [
{
"name" : " createdAt " ,
"visible" : true ,
"preventSort" : true
},
{
"name" : " updatedAt " ,
"visible" : true ,
"preventSort" : false
},
]
}
}
] Wenn Sie Klassen mit vielen Spalten haben und diese häufig mit denselben Spalten filtern, können Sie diese nach oben sortieren, indem Sie die columnPreference mit der Option filterSortToTop erweitern:
"apps" : [
{
"columnPreference" : {
"_User" : [
{
"name" : " objectId " ,
"filterSortToTop" : true
},
{
"name" : " email " ,
"filterSortToTop" : true
}
]
}
}
] Die Filter, die Sie im Datenbrowser von Parse Dashboard speichern, sind nur für den aktuellen Dashboard -Benutzer in der aktuellen Browsersitzung verfügbar. Um Filter für alle Dashboard -Benutzer einer App dauerhaft verfügbar zu machen, können Sie Filter in der classPreference definieren.
Zum Beispiel:
"apps" : [{
"classPreference" : {
"_Role" : {
"filters" : [{
"name" : " Filter Name " ,
"filter" : [
{
"field" : " objectId " ,
"constraint" : " exists "
}
]
}]
}
}
}]Sie können bequem eine Filterdefinition erstellen, ohne sie per Hand schreiben zu müssen, indem Sie zuerst einen Filter im Datenbrowser speichern und dann die Filterdefinition unter App -Einstellungen> Exportklasseneinstellungen exportieren.
Sie können Skripte angeben, um Cloud -Funktionen mit der Option scripts auszuführen:
"apps" : [
{
"scripts" : [
{
"title" : " Delete Account " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " deleteAccount " ,
"showConfirmationDialog" : true ,
"confirmationDialogStyle" : " critical "
}
]
}
] Sie können auch benutzerdefinierte Felder mit der Option scrips angeben:
"apps" : [
{
"scripts" : [
{
"title" : " Delete account " ,
"classes" : [
{
"name" : " _User " ,
"fields" : [
{ "name" : " createdAt " , "validator" : " value => value > new Date( " 2025 " ) " }
]
}
],
"cloudCodeFunction" : " deleteAccount "
}
]
}
]
Definieren Sie als nächstes die Cloud -Funktion im Parse Server, die aufgerufen wird. Das im Datenbrowser ausgewählte Objekt wird als Anforderungsparameter verfügbar gemacht:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ; Auf das Feld, auf das das Skript aufgerufen wurde, kann von selectedField zugegriffen werden:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
if ( req . params . selectedField !== 'objectId' ) {
throw new Parse . Error ( Parse . Error . SCRIPT_FAILED , 'Deleting accounts is only available on the objectId field.' ) ;
}
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ;Parse.Object Ihrer Parse -Server -Version true Sie möglicherweise die Parse Server -Option encodeParseObjectInCloudFunction . Wenn die Option nicht festgelegt ist, auf false festgelegt ist oder Sie eine ältere Version von Parse Server verwenden, wird das Objekt als einfaches JavaScript -Objekt verfügbar und muss von einem JSON -Objekt in eine Parse.Object -Instanz mit req.params.object = Parse.Object.fromJSON(req.params.object); Bevor Sie alle Eigenschaften und Methoden auf Parse.Object aufrufen können.
Für ältere Versionen von Parse Server:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
req . params . object = Parse . Object . fromJSON ( req . params . object ) ;
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ; Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
if ( ! req . master || ! req . params . object ) {
throw 'Unauthorized' ;
}
req . params . object = Parse . Object . fromJSON ( req . params . object ) ;
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} ) ;Anstatt das Dashboard mit der CLI zu beginnen, können Sie es auch als Express Middleware ausführen.
var express = require ( 'express' ) ;
var ParseDashboard = require ( 'parse-dashboard' ) ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
}
]
} ) ;
var app = express ( ) ;
// make the Parse Dashboard available at /dashboard
app . use ( '/dashboard' , dashboard ) ;
var httpServer = require ( 'http' ) . createServer ( app ) ;
httpServer . listen ( 4040 ) ;Wenn Sie sowohl Parse Server als auch Parse Dashboard auf demselben Server/Port ausführen möchten, können Sie beide als Express Middleware ausführen:
var express = require ( 'express' ) ;
var ParseServer = require ( 'parse-server' ) . ParseServer ;
var ParseDashboard = require ( 'parse-dashboard' ) ;
var api = new ParseServer ( {
// Parse Server settings
} ) ;
var options = { allowInsecureHTTP : false } ;
var dashboard = new ParseDashboard ( {
// Parse Dashboard settings
} , options ) ;
var app = express ( ) ;
// make the Parse Server available at /parse
app . use ( '/parse' , api ) ;
// make the Parse Dashboard available at /dashboard
app . use ( '/dashboard' , dashboard ) ;
var httpServer = require ( 'http' ) . createServer ( app ) ;
httpServer . listen ( 4040 ) ; Stellen Sie sicher, dass die Server -URLs für Ihre Apps von Ihrem Browser zugegriffen werden können. Wenn Sie das Dashboard einsetzen, funktioniert localhost -URLs nicht.
Um das Dashboard sicher bereitzustellen, ohne Ihren Apps -Master -Schlüssel zu veröffentlichen, müssen Sie HTTPS und grundlegende Authentifizierung verwenden.
Das bereitgestellte Dashboard erkennt, ob Sie eine sichere Verbindung verwenden. Wenn Sie das Dashboard hinter einem Last-Balancer oder einem Front-Proxy bereitstellen, kann die App nicht feststellen, dass die Verbindung sicher ist. In diesem Fall können Sie das Dashboard mit der Option --trustProxy=1 starten (oder die PARSE_DASHBOARD_TREST_PROXY-Konfiguration auf 1 festlegen) auf die X-Forward-* -Header für die Verbindungssicherheit des Clients. Dies ist nützlich, um Dienste wie Heroku zu hosten, bei denen Sie den bereitgestellten Proxy -Headern vertrauen können, um korrekt zu bestimmen, ob Sie HTTP oder HTTPS verwenden. Sie können diese Einstellung auch einschalten, wenn Sie das Dashboard als Express Middleware verwenden:
var trustProxy = true ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
}
] ,
"trustProxy" : 1
} ) ; Sie können den Sicherheitsstatus Ihres Parse -Servers anzeigen, indem Sie die Option Dashboard -Option aktivieren, enableSecurityChecks und APP -Einstellungen> Sicherheit besuchen.
const dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
"enableSecurityChecks" : true
}
] ,
} ) ; Sie können Ihr Dashboard für die grundlegende Authentifizierung konfigurieren, indem Sie Benutzernamen und Kennwörter Ihre parse-dashboard-config.json Konfigurationsdatei hinzufügen:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass "
},
{
"user" : " user2 " ,
"pass" : " pass "
}
],
"useEncryptedPasswords" : true | false
} Sie können das Passwort entweder im plain text oder in bcrypt -Formaten speichern. Um das bcrypt -Format zu verwenden, müssen Sie den Parameter config useEncryptedPasswords auf true festlegen. Sie können verschlüsselte Kennwörter mithilfe von parse-dashboard --createUser und das Einfügen des Ergebnisses Ihrer Benutzerkonfiguration generieren.
Sie können eine zusätzliche Sicherheitsebene für ein Benutzerkonto hinzufügen, indem Sie eine Multi-Faktor-Authentifizierung (MFA) benötigen, damit sich der Benutzer anmelden kann.
Bei aktiviertem MFA muss ein Benutzer zusätzlich zu seinem Anmeldekennwort ein einmaliges Kennwort angeben, das normalerweise an ein physisches Gerät gebunden ist. Dies bedeutet, dass der Benutzer zusätzlich zum Kennen des Anmeldekennworts einen physischen Zugriff auf ein Gerät haben muss, um das einmalige Kennwort zu generieren. Dieses einmalige Passwort ist zeitbasiert (TOTP) und nur für kurze Zeit, in der Regel 30 Sekunden, bis es abläuft.
Der Benutzer benötigt eine Authenticator-App, um das einmalige Passwort zu generieren. Diese Apps werden von vielen Dritten und meist kostenlos bereitgestellt.
Wenn Sie einen neuen Benutzer erstellen, indem Sie parse-dashboard --createUser , werden Sie gefragt, ob Sie MFA für den neuen Benutzer aktivieren möchten. Um MFA für einen vorhandenen Benutzer zu aktivieren, führen Sie parse-dashboard --createMFA um ein mfa Geheimnis zu generieren, das Sie dann zur vorhandenen Benutzerkonfiguration hinzufügen, z. B.:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass " ,
"mfa" : " lmvmOIZGMTQklhOIhveqkumss "
}
]
} Parse Dashboard folgt dem Branchenstandard und unterstützt standardmäßig den gemeinsamen OTP-Algorithmus SHA-1 , um mit den meisten Authentikatoren-Apps kompatibel zu sein. Wenn Sie spezifische Sicherheitsanforderungen bezüglich der TOTP -Eigenschaften (Algorithmus, Ziffernlänge, Zeitraum) haben, können Sie diese mit der oben genannten geführten Konfiguration anpassen.
Wenn Sie Ihr Dashboard für die Verwaltung mehrerer Anwendungen konfiguriert haben, können Sie die Verwaltung von Apps basierend auf der Benutzeridentität einschränken.
Aktualisieren Sie dazu Ihre Konfigurationsdatei mit parse-dashboard-config.json so, dass sie mit dem folgenden Format übereinstimmt:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass1 " ,
"apps" : [{ "appId" : " myAppId1 " }, { "appId" : " myAppId2 " }]
},
{
"user" : " user2 " ,
"pass" : " pass2 " ,
"apps" : [{ "appId" : " myAppId1 " }]
} ]
}Der Effekt einer solchen Konfiguration ist wie folgt:
Wenn sich user1 anmeldet, kann er/sie myAppId1 und myAppId2 aus dem Dashboard verwalten.
Wenn sich user2 anmeldet, kann er/sie nur myAppId1 aus dem Dashboard verwalten.
Mit dem Starten von Parse-Server 2.6.5 ist es möglich, einen readOnlyMasterKey für Parse-Server bereitzustellen, um Mutationen an Objekten eines Kunden zu verhindern. Wenn Sie Ihr Dashboard mit dieser Funktion schützen möchten, verwenden Sie einfach den readOnlyMasterKey anstelle des masterKey . Alle Schreibanrufe scheitern.
Starten Sie Ihren parse-server mit
{
"masterKey" : " YOUR_MASTER_KEY_HERE " ,
"readOnlyMasterKey" : " YOUR_READ_ONLY_MASTER_KEY " ,
}Dann in Ihrer Dashboard -Konfiguration:
var trustProxy = true ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "YOUR_READ_ONLY_MASTER_KEY" ,
"appName" : "MyApp"
}
] ,
"trustProxy" : 1
} ) ; Stellen Sie sicher, dass Sie den readOnlyMasterKey für die Apps angeben, die Sie in "Apps" -Konfiguration nur schreibgeschützt verwenden möchten. Sie können einen Benutzer als nur schreibgeschütztes Benutzer markieren:
{
"apps" : [
{
"appId" : " myAppId1 " ,
"masterKey" : " myMasterKey1 " ,
"readOnlyMasterKey" : " myReadOnlyMasterKey1 " ,
"serverURL" : " myURL1 " ,
"port" : 4040 ,
"production" : true
},
{
"appId" : " myAppId2 " ,
"masterKey" : " myMasterKey2 " ,
"readOnlyMasterKey" : " myReadOnlyMasterKey2 " ,
"serverURL" : " myURL2 " ,
"port" : 4041 ,
"production" : true
}
],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass1 " ,
"readOnly" : true ,
"apps" : [{ "appId" : " myAppId1 " }, { "appId" : " myAppId2 " }]
},
{
"user" : " user2 " ,
"pass" : " pass2 " ,
"apps" : [{ "appId" : " myAppId1 " }]
}
]
} Auf diese Weise hat user1 einen readonly -Zugriff auf myAppId1 und myAppId2
Stellen Sie sicher, dass Sie den readOnlyMasterKey für die Apps angeben, die Sie in "Apps" -Konfiguration nur schreibgeschützt verwenden möchten. Sie können einen Benutzer auf einer Basis pro App nur auf den Benutzer zugreifen:
{
"apps" : [
{
"appId" : " myAppId1 " ,
"masterKey" : " myMasterKey1 " ,
"readOnlyMasterKey" : " myReadOnlyMasterKey1 " ,
"serverURL" : " myURL " ,
"port" : 4040 ,
"production" : true
},
{ "..." : " ... " }
],
"users" : [
{
"user" : " user " ,
"pass" : " pass " ,
"apps" : [{ "appId" : " myAppId " , "readOnly" : true }, { "appId" : " myAppId2 " }]
}
]
} Mit dieser Konfiguration hat User1 nur Zugriff auf myAppId1 und Lese-/Schreibzugriff auf myAppId2 .
Mit der neuesten Version des Dashboards ist es möglich, lokalisierte Nachrichten für Push -Benachrichtigungen zu senden. Sie können eine Liste von Orten oder Sprachen bereitstellen, die Sie für Ihre Dashboard -Benutzer unterstützen möchten.
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
"supportedPushLocales" : [ " en " , " ru " , " fr " ]
}
],
"iconsFolder" : " icons "
}Das offizielle Docker -Bild wird auf Docker Hub veröffentlicht
Führen Sie das Bild mit Ihrer config.json aus, die als Volumen montiert ist
docker run -d -p 8080:4040 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parseplatform/parse-dashboard --dev
Sie können auch die Appid, MasterKey und Serverurl als Argumente übergeben:
docker run -d -p 4040:4040 parseplatform/parse-dashboard --dev --appId $APP_ID --masterKey $MASTER_KEY --serverURL $SERVER_URL
Standardmäßig startet der Container die App an Port 4040 im Container. Sie können jedoch auch den benutzerdefinierten Befehl ausführen (siehe Deploying in production für benutzerdefiniertes Setup).
In diesem Beispiel möchten wir die Anwendung im Produktionsmodus in Port 80 des Host -Computers ausführen.
docker run -d -p 80:8080 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parse-dashboard --port 8080 --dev
Wenn Sie mit Docker nicht vertraut sind, wird --port 8080 als Argument an den Einstiegspunkt übergeben, um den vollständigen Befehl npm start -- --port 8080 . Die Anwendung startet in Port 8080 im Container und Port 8080 wird auf Port 80 auf Ihrem Host -Computer montiert.
(Das Folgende ist keine vollständige Liste der Funktionen, sondern eine Arbeit, um eine umfassende Funktionsliste zu erstellen.)
Mit dem Dialogfeld Filter können relationale Filterbedingungen basierend auf anderen Klassen hinzugefügt, die einen Zeiger auf die aktuelle Klasse haben.
Zum Beispiel können Benutzer in der _User -Klasse:
Purchase mit einem _User -ZeigerfeldPayment mit einem _User -ZeigerfeldMit einem relationalen Filter können Sie alle Benutzer filtern, die:
Purchase )Payment ) Um einen solchen Filter anzuwenden, gehen Sie einfach zur _User -Klasse und fügen Sie die beiden erforderlichen Filterbedingungen mit den Purchase und Payment hinzu.
Der Datenbrowser bietet ein Info -Panel an, das Informationen zum aktuell ausgewählten Objekt in der Tabelle Datenbrowser anzeigen kann. Das Info -Panel wird sichtbar, indem Sie auf das Menüschalter in der oberen rechten Ecke klicken, wenn Sie eine Klasse durchsuchen, für die das Info -Feld in den Dashboard -Optionen konfiguriert ist.
Die folgende Beispiel -Dashboard -Konfiguration zeigt ein Info -Panel für die _User -Klasse mit den User Details , indem die Cloud -Code -Funktion getUserDetails aufgerufen und die zurückgegebene Antwort angezeigt wird.
"apps" : [
{
"infoPanel" : [
{
"title" : " User Details " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " getUserDetails "
}
]
}
]Die Cloud -Code -Funktion empfängt das ausgewählte Objekt in der Nutzlast und gibt eine Antwort zurück, die verschiedene Elemente enthalten kann.
Das Info -Panel kann mehrere Segmente enthalten, um verschiedene Informationsgruppen anzuzeigen.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
segments | Array | NEIN | Eine geordnete Reihe von Segmenten, bei denen jedes Segment eine bestimmte Gruppe von Elementen darstellt, die angezeigt werden müssen. |
segments[i].title | Saite | NEIN | Der Titel des Segments, das angezeigt wird. |
segments[i].items | Array | NEIN | Eine geordnete Reihe von Elementen innerhalb des Segments. Jedes Element kann unterschiedliche Typen wie Text, Schlüsselwertpaare, Tabellen, Bilder usw. sein. |
Beispiel:
{
"panel" : {
"segments" : [
{
"title" : " Purchases " ,
"items" : [
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}
]
}
]
}
}Das Element-Array kann verschiedene Arten von Inhalten wie Text, Schlüsselwertpaare, Tabellen, Bilder, Videos, Audios und Schaltflächen enthalten. Jeder Typ bietet eine andere Möglichkeit, Informationen innerhalb des Info -Feldes anzuzeigen und eine anpassbare und reichhaltige Benutzererfahrung zu ermöglichen. Unten finden Sie eine detaillierte Erklärung für jeden Typ.
Ein einfaches Textfeld.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "text" sein. |
text | Saite | NEIN | Der zu angezeigte Text. |
Beispiel:
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}Ein Textelement, der aus einem Schlüssel und einem Wert besteht. Der Wert kann optional mit einer URL verknüpft werden.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "keyValue" sein. |
key | Saite | NEIN | Der zu angezeigte Schlüsseltext. |
value | Saite | NEIN | Der zu angezeigte Werttext. |
url | Saite | Ja | Die URL, die beim Klicken auf den Werttext auf einer neuen Browser -Registerkarte geöffnet wird. |
Beispiele:
{
"type" : " keyValue " ,
"key" : " Lifetime purchase value " ,
"value" : " $10k "
}{
"type" : " keyValue " ,
"key" : " Last purchase ID " ,
"value" : " 123 " ,
"url" : " https://example.com/purchaseDetails?purchaseId=012345 "
}Eine Tabelle mit Spalten und Zeilen, um Daten in einem strukturierten Format anzuzeigen.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "table" sein. |
columns | Array | NEIN | Die Spaltendefinitionen, einschließlich Namen und Typen. |
columns[*].name | Saite | NEIN | Der Name der zu angezeigten Spalte. |
columns[*].type | Saite | NEIN | Der Typ des Spaltenwerts (z. B. "string" , "number" ). |
rows | Array | NEIN | Die Datenzeilen, wobei jede Zeile ein Objekt ist, das Werte für jede Spalte enthält. |
Beispiel:
{
"type" : " table " ,
"columns" : [
{
"name" : " Name " ,
"type" : " string "
},
{
"name" : " Age " ,
"type" : " number "
}
],
"rows" : [
{
"Name" : " Alice " ,
"Age" : 30
},
{
"Name" : " Bob " ,
"Age" : 40
}
]
}Ein Bild, das im Panel angezeigt werden muss.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "image" sein. |
url | Saite | NEIN | Die URL des Bildes zu zeigen. |
Beispiel:
{
"type" : " image " ,
"url" : " https://example.com/images?purchaseId=012345 "
}Ein Video, das im Panel angezeigt werden soll.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "video" sein. |
url | Saite | NEIN | Die URL des zu angezeigten Videos. |
Beispiel:
{
"type" : " video " ,
"url" : " https://example.com/video.mp4 "
}Eine Audiodatei, die im Panel gespielt werden soll.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "audio" sein. |
url | Saite | NEIN | Die URL des Audios zu spielen. |
Beispiel:
{
"type" : " audio " ,
"url" : " https://example.com/audio.mp3 "
}Eine Schaltfläche, die beim Klicken eine Aktion auslöst.
| Parameter | Wert | Optional | Beschreibung |
|---|---|---|---|
type | Saite | NEIN | Muss "button" sein. |
text | Saite | NEIN | Der Text, der auf der Schaltfläche angezeigt werden soll. |
action | Objekt | NEIN | Die Aktion, die ausgeführt wird, wenn die Schaltfläche klickt. |
action.url | Saite | NEIN | Die URL, an die die Anfrage gesendet werden sollte. |
action.method | Saite | NEIN | Die HTTP -Methode für die Aktion (z. B. "POST" ). |
action.headers | Objekt | Ja | Optionale Header, die in die Anfrage einbezogen werden. |
action.body | Objekt | Ja | Der Körper der Anfrage im JSON -Format. |
Beispiel:
{
"type" : " button " ,
"text" : " Click me! " ,
"action" : {
"url" : " https://api.example.com/click " ,
"method" : " POST " ,
"headers" : {
"Content-Type" : " application/json "
},
"body" : {
"key" : " value "
}
}
}Mit dieser Funktion können Sie den Datenbrowser als einen anderen Benutzer verwenden und die Datenberechtigungen des Benutzers respektieren. Beispielsweise sehen Sie nur Aufzeichnungen und Felder, die der Benutzer die Erlaubnis hat.
Euen Anmelden als ein anderer Benutzer löst dieselben Cloud -Auslöser aus, als ob der Benutzer sich mit einer anderen Anmeldemethode in sich selbst angemeldet hätte. Anmeldung als ein anderer Benutzer erfordert, um das Kennwort dieses Benutzers einzugeben.
Mit dieser Funktion können Sie die Art und Weise ändern, wie ein Zeiger im Browser dargestellt wird. Standardmäßig wird ein Zeiger durch die objectId des verknüpften Objekts dargestellt. Sie können dies in eine andere Spalte der Objektklasse ändern. Wenn beispielsweise die Installation ein Feld hat, das einen Zeiger auf den User enthält, zeigt der Zeiger die objectId des Benutzer standardmäßig an. Sie können diese ändern, um die Feld email des Benutzers anzuzeigen, sodass ein Zeiger stattdessen die E -Mail -Adresse des Benutzers anzeigt.
objectId an.createdAt , updatedAt , ACL können nicht als Zeigerschlüssel festgelegt werden.objectId zurück.
Euen Für jede benutzerdefinierte Zeigertaste in jeder Zeile wird eine Serveranforderung ausgelöst, um den benutzerdefinierten Zeigerschlüssel zu beheben. Wenn der Browser beispielsweise eine Klasse mit 50 Zeilen zeigt und jede Zeile 3 benutzerdefinierte Zeigertasten enthält, werden insgesamt 150 separate Serveranforderungen ausgelöst.
Diese Funktion werden entweder ausgewählte Zeilen oder alle Zeilen einer einzelnen Klasse übernommen und sie in einer CSV -Datei gespeichert, die dann heruntergeladen wird. CSV -Header werden oben in der Datei hinzugefügt, die den Spaltennamen entspricht.
Euen Derzeit gibt es beim Exportieren aller Daten eine 10.000 Zeilengrenze. Wenn in der Klasse mehr als 10.000 Zeilen vorhanden sind, enthält die CSV -Datei nur 10.000 Zeilen.
Wir wollen wirklich, dass Parse deins ist, um zu sehen, wie es in der Open -Source -Community wächst und gedeiht. Bitte beachten Sie den Beitrag zum Dashboard Guide.
Ab dem 5. April 2017 hat Parse, LLC diesen Code an die Parse-Community-Organisation übertragen und wird diesen Code nicht mehr bei oder verteilen.
