parse dashboard
6.0.0
Le tableau de bord Parse est un tableau de bord autonome pour gérer vos applications de serveur Parse.
Installez le tableau de bord à partir de npm .
npm install -g parse-dashboard
Vous pouvez lancer le tableau de bord pour une application avec une seule commande en fournissant un ID d'application, une clé principale, une URL et un nom comme ceci:
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --appName optionalName
Vous pouvez définir l'hôte, le port et le chemin de montage en fournissant les options --host , --port et --mountPath pour parse-dashboard. Vous pouvez utiliser tout ce que vous voulez comme nom d'application, ou le laisser de côté, auquel cas l'ID d'application sera utilisé.
Le paramètre --dev désactive les fonctionnalités de sécurité prêtes pour la production. Ce paramètre est utile lors de l'exécution du tableau de bord d'analyse sur Docker. L'utilisation de ce paramètre sera:
allowInsecureHTTPmasterKey Parse Server à transmettre en texte clair sans cryptage
️ N'utilisez pas ce paramètre lors du déploiement du tableau de bord d'analyse dans un environnement de production.
Après avoir commencé le tableau de bord, vous pouvez visiter http: // localhost: 4040 dans votre navigateur:
Le tableau de bord de l'analyse est compatible avec les versions de serveur Parse Server suivantes.
| Version du tableau de bord d'analyse | Version du serveur d'analyse | Compatible |
|---|---|---|
| > = 1.0 | > = 2.1.4 | ✅ Oui |
Le tableau de bord d'analyse est testé en continu avec les versions les plus récentes de Node.js pour assurer la compatibilité. Nous suivons le plan de support à long terme Node.js et ne testons que des versions qui sont officiellement soutenues et n'ont pas atteint leur date de fin de vie.
| Version | Dernière version | Fin de vie | Compatible |
|---|---|---|---|
| Node.js 18 | 18.20.4 | Mai 2025 | ✅ Oui |
| Node.js 20 | 20.18.0 | Avril 2026 | ✅ Oui |
| Node.js 22 | 22.9.0 | Avril 2027 | ✅ Oui |
| Paramètre | Taper | Facultatif | Défaut | Exemple | Description |
|---|---|---|---|---|---|
apps | Array <objet> | Non | - | [{ ... }, { ... }] | Les applications configurées pour le tableau de bord. |
infoPanel | Array <objet> | Oui | - | [{ ... }, { ... }] | La configuration du panneau d'information. |
infoPanel[*].title | Chaîne | Non | - | User Details | Le titre du panneau. |
infoPanel[*].classes | Array <string> | Non | - | ["_User"] | Les classes pour lesquelles le panneau d'information doit être affiché. |
infoPanel[*].cloudCodeFunction | Chaîne | Non | - | getUserDetails | La fonction de code cloud qui a reçu l'objet sélectionné dans le navigateur de données et renvoie la réponse à afficher dans le panneau d'information. |
apps.scripts | Array <objet> | Oui | [] | [{ ... }, { ... }] | Les scripts qui peuvent être exécutés pour cette application. |
apps.scripts.title | Chaîne | Non | - | 'Delete User' | Le titre qui sera affiché dans le menu contextuel du navigateur de données et la boîte de dialogue de confirmation d'exécution du script. |
apps.scripts.classes | Array <string> | Non | - | ['_User'] | Les classes d'objets d'analyse pour lesquelles les scripts peuvent être exécutés. |
apps.scripts.cloudCodeFunction | Chaîne | Non | - | 'deleteUser' | Le nom de la fonction Cloud Parse à exécuter. |
apps.scripts.showConfirmationDialog | Bool | Oui | false | true | Est true si une boîte de dialogue de confirmation doit être affichée avant l'exécution du script, false si le script doit être exécuté immédiatement. |
apps.scripts.confirmationDialogStyle | Chaîne | Oui | info | critical | Le style de la boîte de dialogue de confirmation. Valeurs valides: info (style bleu), critical (style rouge). |
apps.cloudConfigHistoryLimit | Entier | Oui | 100 | 100 | Le nombre de valeurs historiques qui doivent être enregistrées dans l'historique des changements de configuration du cloud. Valeurs valides: 0 ... Number.MAX_SAFE_INTEGER . |
Vous pouvez également démarrer le tableau de bord à partir de la ligne de commande avec un fichier de configuration. Pour ce faire, créez un nouveau fichier appelé parse-dashboard-config.json dans votre hiérarchie de répertoire de tableau de bord Parse local. Le fichier doit correspondre au format suivant:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " MyApp "
}
]
} Vous pouvez ensuite démarrer le tableau de bord à l'aide de parse-dashboard --config parse-dashboard-config.json .
Cela ne fonctionne que lors du démarrage de l'application à l'aide de la commande
parse-dashboard
Il existe également deux méthodes que vous pouvez utiliser pour configurer le tableau de bord à l'aide des variables d'environnement.
Fournissez toute la configuration JSON dans PARSE_DASHBOARD_CONFIG et elle sera analysée comme le fichier de configuration.
Vous pouvez également définir chaque option de configuration individuellement.
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
La gestion de plusieurs applications du même tableau de bord est également possible. Ajoutez simplement des entrées supplémentaires dans le tableau "apps" du fichier parse-dashboard-config.json :
{
"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 a un terrain de jeu GraphQL intégré à jouer avec l'API GRAPHQL PARSE GÉNÉRÉ AUTO.
Vous pouvez configurer le terrain de jeu GraphQL en passant l'option --graphQLServerURL à la CLI parse-dashboard :
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --graphQLServerURL "https://example.com/graphql" --appName optionalName
L'option graphQLServerURL est également disponible via une variable d'environnement appelée PARSE_DASHBOARD_GRAPHQL_SERVER_URL :
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"
Vous pouvez également configurer le terrain de jeu GraphQL dans votre fichier parse-dashboard-config.json :
{
"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 "
}
]
}Après avoir commencé le tableau de bord, vous pouvez visiter http://0.0.0.0:4040/apps/mytestapp/API_CONSOLE/GRAPHQL dans votre navigateur:
Le tableau de bord d'analyse prend en charge l'ajout d'une icône en option pour chaque application, vous pouvez donc les identifier plus facilement dans la liste. Pour ce faire, vous devez utiliser le fichier de configuration, définir un iconsFolder dedans et définir le paramètre iconName pour chaque application (y compris l'extension). Le chemin d'accès des iconsFolder est relatif au fichier de configuration. Si vous avez installé Parsedashboard à l'échelle mondiale, vous devez utiliser le chemin complet comme valeur pour les iconsFolder . Pour visualiser ce que cela signifie, dans l'exemple suivant, icons se trouvent un répertoire situé dans le même répertoire que le fichier de configuration:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
}
],
"iconsFolder" : " icons "
} Le tableau de bord d'analyse prend en charge l'ajout d'une couleur d'arrière-plan en option pour chaque application, vous pouvez donc les identifier plus facilement dans la liste. Pour ce faire, vous devez utiliser le fichier de configuration, définir un paramètre primaryBackgroundColor et secondaryBackgroundColor , paramètre pour chaque application. C'est CSS style . Pour visualiser ce que cela signifie, dans l'exemple suivant, backgroundColor est un fichier de configuration:
{
"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
}
]
} Vous pouvez définir appNameForURL dans le fichier de configuration pour chaque application afin de contrôler l'URL de votre application dans le tableau de bord. Cela peut faciliter l'utilisation de signets ou partager des liens sur votre tableau de bord.
Pour changer l'application en production, définissez simplement production sur true dans votre fichier de configuration. La valeur par défaut est fausse si elle n'est pas spécifiée.
Vous pouvez éviter que certaines colonnes soient triables en ajoutant preventSort à des options de chronique dans la configuration de chaque application
"apps" : [
{
"appId" : " local_app_id " ,
"columnPreference" : {
"_User" : [
{
"name" : " createdAt " ,
"visible" : true ,
"preventSort" : true
},
{
"name" : " updatedAt " ,
"visible" : true ,
"preventSort" : false
},
]
}
}
] Si vous avez des classes avec beaucoup de colonnes et que vous les filtrez souvent avec les mêmes colonnes, vous pouvez les trier en haut en étendant le paramètre columnPreference avec l'option filterSortToTop :
"apps" : [
{
"columnPreference" : {
"_User" : [
{
"name" : " objectId " ,
"filterSortToTop" : true
},
{
"name" : " email " ,
"filterSortToTop" : true
}
]
}
}
] Les filtres que vous enregistrez dans le navigateur de données du tableau de bord Parse ne sont disponibles que pour l'utilisateur actuel du tableau de bord dans la session actuelle du navigateur. Pour rendre les filtres disposés en permanence pour tous les utilisateurs du tableau de bord d'une application, vous pouvez définir des filtres dans le paramètre classPreference .
Par exemple:
"apps" : [{
"classPreference" : {
"_Role" : {
"filters" : [{
"name" : " Filter Name " ,
"filter" : [
{
"field" : " objectId " ,
"constraint" : " exists "
}
]
}]
}
}
}]Vous pouvez facilement créer une définition de filtre sans avoir à l'écrire à la main en enregistrant d'abord un filtre dans le navigateur de données, puis en exportant la définition du filtre dans les paramètres de l'application> Préférences de classe d'exportation .
Vous pouvez spécifier des scripts pour exécuter les fonctions cloud avec l'option scripts :
"apps" : [
{
"scripts" : [
{
"title" : " Delete Account " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " deleteAccount " ,
"showConfirmationDialog" : true ,
"confirmationDialogStyle" : " critical "
}
]
}
] Vous pouvez également spécifier des champs personnalisés avec l'option scrips :
"apps" : [
{
"scripts" : [
{
"title" : " Delete account " ,
"classes" : [
{
"name" : " _User " ,
"fields" : [
{ "name" : " createdAt " , "validator" : " value => value > new Date( " 2025 " ) " }
]
}
],
"cloudCodeFunction" : " deleteAccount "
}
]
}
]
Ensuite, définissez la fonction Cloud dans Parse Server qui sera appelée. L'objet qui a été sélectionné dans le navigateur de données sera mis à disposition en tant que paramètre de demande:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ; Le champ sur lequel le script a été invoqué peut être accessible par selectedField :
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
} ) ;encodeParseObjectInCloudFunction sur true afin que l'objet sélectionné dans le navigateur de données soit mis à disposition dans la fonction cloud comme une instance de Parse.Object . Si l'option n'est pas définie, est définie sur false , ou si vous utilisez une ancienne version de Parse Server, l'objet est rendu disponible sous forme d'un objet JavaScript simple et doit être converti à partir d'un objet JSON en une instance Parse.Object avec req.params.object = Parse.Object.fromJSON(req.params.object); , avant de pouvoir appeler n'importe quelle propriétés et méthodes Parse.Object .
Pour les anciennes versions de 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 } ) ;
} ) ;Au lieu de commencer le tableau de bord d'analyse avec la CLI, vous pouvez également l'exécuter en tant que middleware express.
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 ) ;Si vous souhaitez exécuter Parse Server et Parse Dashboard sur le même serveur / port, vous pouvez les exécuter tous les deux en middleware express:
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 ) ; Assurez-vous que les URL du serveur pour vos applications sont accessibles par votre navigateur. Si vous déploiez le tableau de bord, les URL localhost ne fonctionneront pas.
Afin de déployer en toute sécurité le tableau de bord sans divulguer la clé maître de votre application, vous devrez utiliser HTTPS et l'authentification de base.
Le tableau de bord déployé détecte si vous utilisez une connexion sécurisée. Si vous déployez le tableau de bord derrière un équilibreur de charge ou un proxy orienté vers l'avant, l'application ne pourra pas détecter que la connexion est sécurisée. Dans ce cas, vous pouvez démarrer le tableau de bord avec l'option --trustProxy=1 (ou définir la configuration PARSE_DASHBOOK_TRUST_PROXY VAR sur 1) pour s'appuyer sur les en-têtes X-Forwarded- * pour la sécurité de connexion du client. Ceci est utile pour héberger des services comme Heroku, où vous pouvez faire confiance aux en-têtes proxy fournis pour déterminer correctement si vous utilisez HTTP ou HTTPS. Vous pouvez également activer ce paramètre lorsque vous utilisez le tableau de bord comme middleware express:
var trustProxy = true ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
}
] ,
"trustProxy" : 1
} ) ; Vous pouvez afficher l'état de sécurité de votre serveur Parse en activant l'option de tableau de bord enableSecurityChecks et en visitant les paramètres de l'application> Security.
const dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
"enableSecurityChecks" : true
}
] ,
} ) ; Vous pouvez configurer votre tableau de bord pour l'authentification de base en ajoutant des noms d'utilisateur et des mots de passe de votre fichier de configuration parse-dashboard-config.json :
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass "
},
{
"user" : " user2 " ,
"pass" : " pass "
}
],
"useEncryptedPasswords" : true | false
} Vous pouvez stocker le mot de passe dans des formats plain text ou bcrypt . Pour utiliser le format bcrypt , vous devez définir le paramètre Config useEncryptedPasswords sur true . Vous pouvez générer des mots de passe chiffrés en utilisant parse-dashboard --createUser et coller le résultat dans la configuration de vos utilisateurs.
Vous pouvez ajouter une couche de sécurité supplémentaire pour un compte d'utilisateur en nécessitant une authentification multi-facteurs (MFA) pour que l'utilisateur se connecte.
Avec MFA activé, un utilisateur doit fournir un mot de passe unique qui est généralement lié à un appareil physique, en plus de son mot de passe de connexion. Cela signifie qu'en plus de connaître le mot de passe de connexion, l'utilisateur doit avoir un accès physique à un appareil pour générer le mot de passe unique. Ce mot de passe ponctuel est basé sur le temps (TOTP) et valide uniquement pendant un court laps de temps, généralement 30 secondes, jusqu'à ce qu'il expire.
L'utilisateur nécessite une application Authenticatrice pour générer le mot de passe ponctuel. Ces applications sont fournies par de nombreuses tiers et surtout gratuitement.
Si vous créez un nouvel utilisateur en exécutant parse-dashboard --createUser , il vous sera demandé si vous souhaitez activer MFA pour le nouvel utilisateur. Pour activer le MFA pour un utilisateur existant, exécutez parse-dashboard --createMFA pour générer un secret mfa que vous ajoutez ensuite à la configuration de l'utilisateur existant, par exemple:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass " ,
"mfa" : " lmvmOIZGMTQklhOIhveqkumss "
}
]
} Le tableau de bord d'analyse suit la norme de l'industrie et prend en charge l'algorithme OTP commun SHA-1 par défaut, pour être compatible avec la plupart des applications d'authentification. Si vous avez des exigences de sécurité spécifiques concernant les caractéristiques TOTP (algorithme, longueur de chiffre, période de temps), vous pouvez les personnaliser en utilisant la configuration guidée mentionnée ci-dessus.
Si vous avez configuré votre tableau de bord pour gérer plusieurs applications, vous pouvez restreindre la gestion des applications en fonction de l'identité de l'utilisateur.
Pour ce faire, mettez à jour votre fichier de configuration parse-dashboard-config.json pour correspondre au format suivant:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass1 " ,
"apps" : [{ "appId" : " myAppId1 " }, { "appId" : " myAppId2 " }]
},
{
"user" : " user2 " ,
"pass" : " pass2 " ,
"apps" : [{ "appId" : " myAppId1 " }]
} ]
}L'effet d'une telle configuration est le suivant:
Lorsque user1 se connecte, il pourra gérer myAppId1 et myAppId2 à partir du tableau de bord.
Lorsque user2 se connecte, il / elle ne pourra gérer myAppId1 à partir du tableau de bord.
Démarrage de Parse-Server 2.6.5, il est possible de fournir un readOnlyMasterKey à Parse-Server pour empêcher les mutations sur les objets d'un client. Si vous souhaitez protéger votre tableau de bord avec cette fonctionnalité, utilisez simplement le readOnlyMasterKey au lieu de masterKey . Tous les appels d'écriture échoueront.
Commencez votre parse-server avec
{
"masterKey" : " YOUR_MASTER_KEY_HERE " ,
"readOnlyMasterKey" : " YOUR_READ_ONLY_MASTER_KEY " ,
}Ensuite, dans la configuration de votre tableau de bord:
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
} ) ; Assurez-vous de spécifier le readOnlyMasterKey pour les applications que vous souhaitez utiliser la fonctionnalité en lecture seule dans la configuration "Apps". Vous pouvez marquer un utilisateur en tant qu'utilisateur en lecture seule:
{
"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 " }]
}
]
} De cette façon, user1 aura un accès en lecture à myAppId1 et myAppId2
Assurez-vous de spécifier le readOnlyMasterKey pour les applications que vous souhaitez utiliser la fonctionnalité en lecture seule dans la configuration "Apps". Vous pouvez donner un accès unique à un utilisateur sur une base par apparence:
{
"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 " }]
}
]
} Avec cette configuration, User1 n'aura lu que l'accès à myAppId1 et en lisant / écrivez un accès à myAppId2 .
Avec la dernière version du tableau de bord, il est possible d'envoyer des messages localisés pour les notifications push. Vous pouvez fournir une liste de lieux ou de langues que vous souhaitez prendre en charge pour les utilisateurs de votre tableau de bord.
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
"supportedPushLocales" : [ " en " , " ru " , " fr " ]
}
],
"iconsFolder" : " icons "
}L'image officielle Docker est publiée sur Docker Hub
Exécutez l'image avec votre config.json monté comme un volume
docker run -d -p 8080:4040 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parseplatform/parse-dashboard --dev
Vous pouvez également passer l'AppID, Masterkey et ServerUrl comme arguments:
docker run -d -p 4040:4040 parseplatform/parse-dashboard --dev --appId $APP_ID --masterKey $MASTER_KEY --serverURL $SERVER_URL
Par défaut, le conteneur démarrera l'application au port 4040 à l'intérieur du conteneur. Cependant, vous pouvez également exécuter la commande personnalisée (voir Deploying in production pour la configuration personnalisée).
Dans cet exemple, nous voulons exécuter l'application en mode de production au port 80 de la machine hôte.
docker run -d -p 80:8080 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parse-dashboard --port 8080 --dev
Si vous n'êtes pas familier avec Docker, --port 8080 sera transmis en tant qu'argument au point d'entrée pour former la commande complète npm start -- --port 8080 . L'application commencera au port 8080 à l'intérieur du conteneur et le port 8080 sera monté sur le port 80 sur votre machine hôte.
(Ce qui suit n'est pas une liste complète des fonctionnalités mais un travail en cours pour créer une liste de fonctionnalités complètes.)
La boîte de dialogue Filtre permet d'ajouter des conditions de filtre relationnelles basées sur d'autres classes qui ont un pointeur à la classe actuelle.
Par exemple, les utilisateurs de la classe _User peuvent avoir:
Purchase avec un champ de pointeur _UserPayment avec un champ de pointeur _UserUn filtre relationnel vous permet de filtrer tous les utilisateurs qui:
Purchase )Payment ) Pour appliquer un tel filtre, accédez simplement à la classe _User et ajoutez les deux conditions de filtre requises avec les cours Purchase et Payment .
Le navigateur de données propose un panneau d'information qui peut afficher des informations liées à l'objet actuellement sélectionné dans la table du navigateur de données. Le panneau d'information est rendu visible en cliquant sur le bouton de menu Afficher le panneau dans le coin supérieur droit lors de la navigation sur une classe pour laquelle le panneau d'information est configuré dans les options de tableau de bord.
L'exemple de configuration du tableau de bord suivant affiche un panneau d'information pour la classe _User avec les User Details du titre, en appelant la fonction Cloud Code getUserDetails et en affichant la réponse renvoyée.
"apps" : [
{
"infoPanel" : [
{
"title" : " User Details " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " getUserDetails "
}
]
}
]La fonction de code cloud reçoit l'objet sélectionné dans la charge utile et renvoie une réponse qui peut inclure divers éléments.
Le panneau d'information peut contenir plusieurs segments pour afficher différents groupes d'informations.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
segments | Tableau | Non | Un tableau ordonné de segments, où chaque segment représente un groupe distinct d'éléments à afficher. |
segments[i].title | Chaîne | Non | Le titre du segment qui sera affiché. |
segments[i].items | Tableau | Non | Une gamme d'articles commandés dans le segment. Chaque élément peut être de différents types, tels que du texte, des paires de valeurs clés, des tables, des images, etc. |
Exemple:
{
"panel" : {
"segments" : [
{
"title" : " Purchases " ,
"items" : [
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}
]
}
]
}
}Le tableau des éléments peut inclure différents types de contenu tels que du texte, des paires de valeurs clés, des tables, des images, des vidéos, des audios et des boutons. Chaque type offre une façon différente d'afficher des informations dans le panneau d'information, permettant une expérience utilisateur personnalisable et riche. Vous trouverez ci-dessous une explication détaillée de chaque type.
Un champ de texte simple.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "text" . |
text | Chaîne | Non | Le texte à afficher. |
Exemple:
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}Un élément de texte qui se compose d'une clé et d'une valeur. La valeur peut éventuellement être liée à une URL.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "keyValue" . |
key | Chaîne | Non | Le texte clé à afficher. |
value | Chaîne | Non | Le texte de valeur à afficher. |
url | Chaîne | Oui | L'URL qui sera ouverte dans un nouvel onglet de navigateur lors du clic sur le texte de la valeur. |
Exemples:
{
"type" : " keyValue " ,
"key" : " Lifetime purchase value " ,
"value" : " $10k "
}{
"type" : " keyValue " ,
"key" : " Last purchase ID " ,
"value" : " 123 " ,
"url" : " https://example.com/purchaseDetails?purchaseId=012345 "
}Une table avec des colonnes et des lignes pour afficher les données dans un format structuré.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "table" . |
columns | Tableau | Non | Les définitions de colonne, y compris les noms et les types. |
columns[*].name | Chaîne | Non | Le nom de la colonne à afficher. |
columns[*].type | Chaîne | Non | Le type de valeur de colonne (par exemple, "string" , "number" ). |
rows | Tableau | Non | Les lignes de données, où chaque ligne est un objet contenant des valeurs pour chaque colonne. |
Exemple:
{
"type" : " table " ,
"columns" : [
{
"name" : " Name " ,
"type" : " string "
},
{
"name" : " Age " ,
"type" : " number "
}
],
"rows" : [
{
"Name" : " Alice " ,
"Age" : 30
},
{
"Name" : " Bob " ,
"Age" : 40
}
]
}Une image à afficher dans le panneau.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "image" . |
url | Chaîne | Non | L'URL de l'image à afficher. |
Exemple:
{
"type" : " image " ,
"url" : " https://example.com/images?purchaseId=012345 "
}Une vidéo à afficher dans le panneau.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "video" . |
url | Chaîne | Non | L'URL de la vidéo à afficher. |
Exemple:
{
"type" : " video " ,
"url" : " https://example.com/video.mp4 "
}Un fichier audio à lire dans le panneau.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "audio" . |
url | Chaîne | Non | L'URL de l'audio à jouer. |
Exemple:
{
"type" : " audio " ,
"url" : " https://example.com/audio.mp3 "
}Un bouton qui déclenche une action lorsqu'il est cliqué.
| Paramètre | Valeur | Facultatif | Description |
|---|---|---|---|
type | Chaîne | Non | Doit être "button" . |
text | Chaîne | Non | Le texte à afficher sur le bouton. |
action | Objet | Non | L'action à effectuer lorsque le bouton est cliqué. |
action.url | Chaîne | Non | L'URL à laquelle la demande doit être envoyée. |
action.method | Chaîne | Non | La méthode HTTP à utiliser pour l'action (par exemple, "POST" ). |
action.headers | Objet | Oui | En-têtes facultatifs à inclure dans la demande. |
action.body | Objet | Oui | Le corps de la demande au format JSON. |
Exemple:
{
"type" : " button " ,
"text" : " Click me! " ,
"action" : {
"url" : " https://api.example.com/click " ,
"method" : " POST " ,
"headers" : {
"Content-Type" : " application/json "
},
"body" : {
"key" : " value "
}
}
}Cette fonctionnalité vous permet d'utiliser le navigateur de données comme un autre utilisateur, en respectant les autorisations de données de cet utilisateur. Par exemple, vous ne verrez que des enregistrements et des champs que l'utilisateur a la permission de voir.
️ La connexion car un autre utilisateur déclenchera les mêmes déclencheurs de cloud que si l'utilisateur s'est connecté en eux-mêmes à l'aide d'une autre méthode de connexion. Connexion car un autre utilisateur a besoin de saisir le mot de passe de cet utilisateur.
Cette fonctionnalité vous permet de modifier la façon dont un pointeur est représenté dans le navigateur. Par défaut, un pointeur est représenté par l' objectId de l'objet lié. Vous pouvez le changer en n'importe quelle autre colonne de la classe d'objets. Par exemple, si Installation de classe a un champ qui contient un User de pointeur vers la classe, le pointeur affichera l' objectId de l'utilisateur par défaut. Vous pouvez modifier cela pour afficher l' email de champ de l'utilisateur, afin qu'un pointeur affiche plutôt l'adresse e-mail de l'utilisateur.
objectId .createdAt , updatedAt , ACL ne peut pas être définie comme clé de pointeur.objectId .
️ Pour chaque touche de pointeur personnalisée dans chaque ligne, une demande de serveur est déclenchée pour résoudre la touche de pointeur personnalisée. Par exemple, si le navigateur affiche une classe avec 50 lignes et que chaque ligne contient 3 touches de pointeur personnalisées, un total de 150 demandes de serveur distinctes sont déclenchées.
Cette fonction prendra des lignes sélectionnées ou toutes les lignes d'une classe individuelle et les enregistre dans un fichier CSV, qui est ensuite téléchargé. Les en-têtes CSV sont ajoutés en haut du fichier correspondant aux noms de colonne.
️ Il y a actuellement une limite de 10 000 lignes lors de l'exportation de toutes les données. Si plus de 10 000 lignes sont présentes dans la classe, le fichier CSV ne contiendra que 10 000 lignes.
Nous voulons vraiment que Parse soit le vôtre, le verra grandir et prospérer dans la communauté open source. Veuillez consulter le Guide du tableau de bord Parse.
Au 5 avril 2017, Parse, LLC a transféré ce code à l'organisation Parse-Community et ne contribuera plus ou ne distribuera pas ce code.
