parse dashboard
6.0.0
El panel de Parse es un tablero independiente para administrar sus aplicaciones de servidor de análisis.
Instale el tablero desde npm .
npm install -g parse-dashboard
Puede iniciar el tablero para una aplicación con un solo comando suministrando una ID de aplicación, clave maestra, URL y un nombre así:
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --appName optionalName
Puede establecer el host, el puerto y la ruta de montaje suministrando las opciones --host , --port y --mountPath para analizar a Dashboard. Puede usar todo lo que desee como nombre de la aplicación, o dejarlo fuera en cuyo caso se utilizará la ID de la aplicación.
El parámetro --dev deshabilita las características de seguridad listas para la producción. Este parámetro es útil cuando se ejecuta el tablero de parse en Docker. Usar este parámetro:
allowInsecureHTTPmasterKey sin cifrado
️ No use este parámetro al implementar el tablero de análisis en un entorno de producción.
Después de comenzar el tablero, puede visitar http: // localhost: 4040 en su navegador:
El tablero de análisis es compatible con las siguientes versiones del servidor de análisis.
| Versión del tablero de análisis | Versión del servidor de análisis | Compatible |
|---|---|---|
| > = 1.0 | > = 2.1.4 | ✅ Sí |
El tablero de análisis se prueba continuamente con las versiones más recientes de Node.js para garantizar la compatibilidad. Seguimos el plan de soporte a largo plazo de Node.js y solo probamos contra versiones que se respaldan oficialmente y no han alcanzado su fecha de fin de vida.
| Versión | Última versión | Final de la vida | Compatible |
|---|---|---|---|
| Nodo.js 18 | 18.20.4 | Mayo de 2025 | ✅ Sí |
| Nodo.js 20 | 20.18.0 | Abril de 2026 | ✅ Sí |
| Nodo.js 22 | 22.9.0 | Abril de 2027 | ✅ Sí |
| Parámetro | Tipo | Opcional | Por defecto | Ejemplo | Descripción |
|---|---|---|---|---|---|
apps | Array <ject> | No | - | [{ ... }, { ... }] | Las aplicaciones que están configuradas para el tablero. |
infoPanel | Array <ject> | Sí | - | [{ ... }, { ... }] | La configuración del panel de información. |
infoPanel[*].title | Cadena | No | - | User Details | El título del panel. |
infoPanel[*].classes | Array <String> | No | - | ["_User"] | Las clases para las cuales se debe mostrar el panel de información. |
infoPanel[*].cloudCodeFunction | Cadena | No | - | getUserDetails | La función de código de nube que recibió el objeto seleccionado en el navegador de datos y devuelve la respuesta que se mostrará en el panel de información. |
apps.scripts | Array <ject> | Sí | [] | [{ ... }, { ... }] | Los scripts que se pueden ejecutar para esa aplicación. |
apps.scripts.title | Cadena | No | - | 'Delete User' | El título que se mostrará en el menú contextual del navegador de datos y el diálogo de confirmación del script ejecuta. |
apps.scripts.classes | Array <String> | No | - | ['_User'] | Las clases de objetos de análisis para los cuales se pueden ejecutar los scripts. |
apps.scripts.cloudCodeFunction | Cadena | No | - | 'deleteUser' | El nombre de la función de nube de análisis para ejecutar. |
apps.scripts.showConfirmationDialog | Bool | Sí | false | true | Es true si se debe mostrar un cuadro de diálogo de confirmación antes de ejecutar el script, false si el script se ejecuta de inmediato. |
apps.scripts.confirmationDialogStyle | Cadena | Sí | info | critical | El estilo del diálogo de confirmación. Valores válidos: info (estilo azul), critical (estilo rojo). |
apps.cloudConfigHistoryLimit | Entero | Sí | 100 | 100 | El número de valores históricos que deben guardar en el historial de cambio de configuración en la nube. Valores válidos: 0 ... Number.MAX_SAFE_INTEGER . |
También puede iniciar el tablero desde la línea de comando con un archivo de configuración. Para hacer esto, cree un nuevo archivo llamado parse-dashboard-config.json dentro de su jerarquía local del directorio del tablero de Parse. El archivo debe coincidir con el siguiente formato:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " MyApp "
}
]
} Luego puede iniciar el tablero con parse-dashboard --config parse-dashboard-config.json .
Esto solo funciona al iniciar la aplicación usando el comando
parse-dashboard
También hay dos métodos que puede usar para configurar el tablero utilizando variables de entorno.
Proporcione la configuración de JSON completa en PARSE_DASHBOARD_CONFIG y se analizará al igual que el archivo de configuración.
También puede definir cada opción de configuración individualmente.
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
También es posible administrar múltiples aplicaciones desde el mismo tablero. Simplemente agregue entradas adicionales en la matriz "apps" del archivo 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 PASHORD tiene un parque infantil incorporado para jugar con la API GRAPHQL de PARSE Generada automáticamente.
Puede configurar el patio de juegos GraphQL pasando la opción --graphQLServerURL en la CLI parse-dashboard :
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --graphQLServerURL "https://example.com/graphql" --appName optionalName
La opción graphQLServerURL también está disponible a través de una variable de entorno llamada 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"
También puede configurar el patio de juegos GraphQL en su archivo 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 "
}
]
}Después de comenzar el tablero, puede visitar http://0.0.0.0:4040/apps/mytestapp/api_console/graphql en su navegador:
El tablero de analizador admite agregar un icono opcional para cada aplicación, por lo que puede identificarlos más fácilmente en la lista. Para hacerlo, debe usar el archivo de configuración, definir un iconsFolder en él y definir el parámetro iconName para cada aplicación (incluida la extensión). La ruta de iconsFolder es relativa al archivo de configuración. Si ha instalado Parsedashboard a nivel mundial, debe usar la ruta completa como valor para iconsFolder . Para visualizar lo que significa, en el siguiente ejemplo, icons hay un directorio ubicado en el mismo directorio que el archivo de configuración:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
}
],
"iconsFolder" : " icons "
} El tablero de analizador admite agregar un color de fondo opcional para cada aplicación, por lo que puede identificarlos más fácilmente en la lista. Para hacerlo, debe usar el archivo de configuración, definir un primaryBackgroundColor y secondaryBackgroundColor en él, parámetro para cada aplicación. Es CSS style . Para visualizar lo que significa, en el siguiente ejemplo, backgroundColor es un archivo de configuración:
{
"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
}
]
} Puede establecer appNameForURL en el archivo de configuración para cada aplicación para controlar la URL de su aplicación dentro del tablero. Esto puede facilitar el uso de marcadores o compartir enlaces en su tablero.
Para cambiar la aplicación a producción, simplemente establezca production en true en su archivo de configuración. El valor predeterminado es falso si no se especifica.
Puede evitar que algunas columnas sean ordenables agregando preventSort a las opciones de columna de la referencia de columna en cada configuración de la aplicación
"apps" : [
{
"appId" : " local_app_id " ,
"columnPreference" : {
"_User" : [
{
"name" : " createdAt " ,
"visible" : true ,
"preventSort" : true
},
{
"name" : " updatedAt " ,
"visible" : true ,
"preventSort" : false
},
]
}
}
] Si tiene clases con muchas columnas y las filtra a menudo con las mismas columnas, puede ordenarlas a la parte superior extendiendo la configuración columnPreference con la opción filterSortToTop :
"apps" : [
{
"columnPreference" : {
"_User" : [
{
"name" : " objectId " ,
"filterSortToTop" : true
},
{
"name" : " email " ,
"filterSortToTop" : true
}
]
}
}
] Los filtros que guarda en el navegador de datos del tablero de análisis solo están disponibles para el usuario actual del tablero en la sesión del navegador actual. Para hacer que los filtros estén disponibles permanentemente para todos los usuarios del tablero de una aplicación, puede definir filtros en la configuración classPreference .
Por ejemplo:
"apps" : [{
"classPreference" : {
"_Role" : {
"filters" : [{
"name" : " Filter Name " ,
"filter" : [
{
"field" : " objectId " ,
"constraint" : " exists "
}
]
}]
}
}
}]Puede crear convenientemente una definición de filtro sin tener que escribirlo a mano guardando primero un filtro en el navegador de datos, luego exportando la definición de filtro en Configuración de la aplicación> Exportar preferencias de clase .
Puede especificar scripts para ejecutar funciones de nube con la opción scripts :
"apps" : [
{
"scripts" : [
{
"title" : " Delete Account " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " deleteAccount " ,
"showConfirmationDialog" : true ,
"confirmationDialogStyle" : " critical "
}
]
}
] También puede especificar campos personalizados con la opción scrips :
"apps" : [
{
"scripts" : [
{
"title" : " Delete account " ,
"classes" : [
{
"name" : " _User " ,
"fields" : [
{ "name" : " createdAt " , "validator" : " value => value > new Date( " 2025 " ) " }
]
}
],
"cloudCodeFunction" : " deleteAccount "
}
]
}
]
A continuación, defina la función de nube en el servidor de análisis que se llamará. El objeto que se ha seleccionado en el navegador de datos estará disponible como parámetro de solicitud:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ; El campo en el que se invocó el script se puede acceder por 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 en true para que el objeto seleccionado en el navegador de datos esté disponible en la función en la nube como una instancia de Parse.Object . Si la opción no está configurada, se establece en false , o está utilizando una versión anterior del servidor de Parse, el objeto está disponible como un objeto JavaScript simple y debe convertirse de un objeto JSON a una instancia Parse.Object con req.params.object = Parse.Object.fromJSON(req.params.object); , antes de que pueda llamar a cualquier propiedad y métodos Parse.Object .
Para versiones más antiguas del servidor de Parse:
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 } ) ;
} ) ;En lugar de comenzar el tablero de análisis con la CLI, también puede ejecutarlo como un middleware expreso.
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 desea ejecutar el servidor de parse y el tablero de análisis en el mismo servidor/puerto, puede ejecutarlos como middleware expreso:
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 ) ; Asegúrese de que el navegador pueda acceder a las URL del servidor para sus aplicaciones. Si está implementando el tablero, entonces las URL localhost no funcionarán.
Para implementar de forma segura el tablero sin filtrar su clave maestra de aplicaciones, deberá usar HTTPS y autenticación básica.
El tablero implementado detecta si está utilizando una conexión segura. Si está implementando el tablero detrás de un equilibrador de carga o proxy frontal, entonces la aplicación no podrá detectar que la conexión sea segura. En este caso, puede iniciar el tablero con la opción --trustProxy=1 (o establecer los encabezados parse_dashboard_trust_proxy var a 1) para confiar en los encabezados X-forward-* para la seguridad de conexión del cliente. Esto es útil para alojar en servicios como Heroku, donde puede confiar en los encabezados proxy proporcionados para determinar correctamente si está utilizando HTTP o HTTPS. También puede activar esta configuración cuando usa el tablero como middleware expreso:
var trustProxy = true ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
}
] ,
"trustProxy" : 1
} ) ; Puede ver el estado de seguridad de su servidor de análisis al habilitar la opción de tablero enableSecurityChecks y visitando la configuración de la aplicación> seguridad.
const dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
"enableSecurityChecks" : true
}
] ,
} ) ; Puede configurar su tablero para la autenticación básica agregando nombres de usuario y contraseñas de su archivo de configuración parse-dashboard-config.json :
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass "
},
{
"user" : " user2 " ,
"pass" : " pass "
}
],
"useEncryptedPasswords" : true | false
} Puede almacenar la contraseña en formatos plain text o bcrypt . Para usar el formato bcrypt , debe establecer el parámetro Config useEncryptedPasswords en true . Puede generar contraseñas encriptadas utilizando parse-dashboard --createUser y pegando el resultado en la configuración de sus usuarios.
Puede agregar una capa adicional de seguridad para una cuenta de usuario requeriendo autenticación multifactor (MFA) para que el usuario inicie sesión.
Con MFA habilitado, un usuario debe proporcionar una contraseña única que generalmente esté vinculada a un dispositivo físico, además de su contraseña de inicio de sesión. Esto significa que además de conocer la contraseña de inicio de sesión, el usuario debe tener acceso físico a un dispositivo para generar la contraseña única. Esta contraseña única está basada en el tiempo (TOTP) y solo es válida por un corto período de tiempo, generalmente 30 segundos, hasta que expire.
El usuario requiere una aplicación de autenticador para generar la contraseña única. Estas aplicaciones son proporcionadas por muchos terceros y principalmente de forma gratuita.
Si crea un nuevo usuario ejecutando parse-dashboard --createUser , se le preguntará si desea habilitar MFA para el nuevo usuario. Para habilitar MFA para un usuario existente, ejecute parse-dashboard --createMFA para generar un secreto mfa que luego agregue a la configuración del usuario existente, por ejemplo:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass " ,
"mfa" : " lmvmOIZGMTQklhOIhveqkumss "
}
]
} El panel de PARSE sigue el estándar de la industria y admite el algoritmo OTP común SHA-1 de forma predeterminada, para ser compatible con la mayoría de las aplicaciones de autenticador. Si tiene requisitos de seguridad específicos con respecto a las características de TOTP (algoritmo, duración del dígito, período de tiempo), puede personalizarlos utilizando la configuración guiada mencionada anteriormente.
Si ha configurado su tablero para administrar múltiples aplicaciones, puede restringir la administración de aplicaciones en función de la identidad del usuario.
Para hacerlo, actualice su archivo de configuración de parse-dashboard-config.json para que coincida con el siguiente formato:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass1 " ,
"apps" : [{ "appId" : " myAppId1 " }, { "appId" : " myAppId2 " }]
},
{
"user" : " user2 " ,
"pass" : " pass2 " ,
"apps" : [{ "appId" : " myAppId1 " }]
} ]
}El efecto de dicha configuración es el siguiente:
Cuando user1 inicie sesión, él/ella podrá administrar myAppId1 y myAppId2 desde el tablero.
Cuando user2 inicie sesión, él/ella solo podrá administrar myAppId1 desde el tablero.
Comenzando el servidor de análisis 2.6.5, es posible proporcionar a un readOnlyMasterKey a servidor de análisis para evitar mutaciones en objetos de un cliente. Si desea proteger su tablero con esta función, simplemente use el readOnlyMasterKey en lugar del masterKey . Todas las llamadas de escritura fallarán.
Comience su parse-server con
{
"masterKey" : " YOUR_MASTER_KEY_HERE " ,
"readOnlyMasterKey" : " YOUR_READ_ONLY_MASTER_KEY " ,
}Luego en la configuración de su tablero:
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
} ) ; Asegúrese de especificar el readOnlyMasterKey para las aplicaciones que desea utilizar la función de solo lectura en la configuración "Aplicaciones". Puede marcar a un usuario como usuario de solo lectura:
{
"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 esta manera, user1 tendrá un acceso de lectura a myAppId1 y myAppId2
Asegúrese de especificar el readOnlyMasterKey para las aplicaciones que desea utilizar la función de solo lectura en la configuración "Aplicaciones". Puede dar acceso a solo lectura a un usuario por aplicación:
{
"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 " }]
}
]
} Con esta configuración, User1 habrá solo leer acceso a myAppId1 y acceso de lectura/escritura a myAppId2 .
Con la última versión del tablero, es posible enviar mensajes localizados para notificaciones push. Puede proporcionar una lista de locales o idiomas que desee admitir para los usuarios de su tablero.
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
"supportedPushLocales" : [ " en " , " ru " , " fr " ]
}
],
"iconsFolder" : " icons "
}La imagen oficial de Docker se publica en Docker Hub
Ejecute la imagen con su config.json montado como volumen
docker run -d -p 8080:4040 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parseplatform/parse-dashboard --dev
También puede pasar el APPID, MasterKey y ServerUrl como argumentos:
docker run -d -p 4040:4040 parseplatform/parse-dashboard --dev --appId $APP_ID --masterKey $MASTER_KEY --serverURL $SERVER_URL
Por defecto, el contenedor iniciará la aplicación en el puerto 4040 dentro del contenedor. Sin embargo, también puede ejecutar el comando personalizado (vea Deploying in production para la configuración personalizada).
En este ejemplo, queremos ejecutar la aplicación en modo de producción en el puerto 80 de la máquina host.
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 no está familiarizado con Docker, --port 8080 se pasará como argumento al punto de entrada para formar el comando completo npm start -- --port 8080 . La aplicación comenzará en el puerto 8080 dentro del contenedor y el puerto 8080 se montará en el puerto 80 en su máquina host.
(La siguiente no es una lista completa de características, sino un trabajo en progreso para construir una lista completa de características).
El diálogo del filtro permite agregar condiciones de filtro relacional basado en otras clases que tienen un puntero a la clase actual.
Por ejemplo, los usuarios en la clase _User pueden tener:
Purchase con un campo de puntero _UserPayment con un campo de puntero _UserUn filtro relacional le permite filtrar a todos los usuarios que:
Purchase )Payment ) Para aplicar dicho filtro, simplemente vaya a la clase _User y agregue las dos condiciones de filtro requeridas con las clases Purchase y Payment .
El navegador de datos ofrece un panel de información que puede mostrar información relacionada con el objeto seleccionado actualmente en la tabla del navegador de datos. El panel de información se hace visible haciendo clic en el botón Menú Mostrar panel en la esquina superior derecha al navegar por una clase para la cual el panel de información está configurado en las opciones de tablero.
El siguiente ejemplo de configuración del tablero muestra un panel de información para la clase _User con los User Details del título, llamando a la función de código de nube getUserDetails y mostrando la respuesta devuelta.
"apps" : [
{
"infoPanel" : [
{
"title" : " User Details " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " getUserDetails "
}
]
}
]La función de código de nube recibe el objeto seleccionado en la carga útil y devuelve una respuesta que puede incluir varios elementos.
El panel de información puede contener múltiples segmentos para mostrar diferentes grupos de información.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
segments | Formación | No | Una matriz ordenada de segmentos, donde cada segmento representa un grupo distinto de elementos para mostrar. |
segments[i].title | Cadena | No | El título del segmento que se mostrará. |
segments[i].items | Formación | No | Una matriz ordenada de artículos dentro del segmento. Cada elemento puede ser de diferentes tipos, como texto, pares de valores clave, tablas, imágenes, etc. |
Ejemplo:
{
"panel" : {
"segments" : [
{
"title" : " Purchases " ,
"items" : [
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}
]
}
]
}
}La matriz de elementos puede incluir varios tipos de contenido, como texto, pares de valores clave, tablas, imágenes, videos, audios y botones. Cada tipo ofrece una forma diferente de mostrar información dentro del panel de información, lo que permite una experiencia de usuario personalizable y rica. A continuación se muestra una explicación detallada de cada tipo.
Un campo de texto simple.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "text" . |
text | Cadena | No | El texto a mostrar. |
Ejemplo:
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}Un elemento de texto que consiste en una clave y un valor. El valor se puede vincular opcionalmente a una URL.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "keyValue" . |
key | Cadena | No | El texto clave para mostrar. |
value | Cadena | No | El texto de valor para mostrar. |
url | Cadena | Sí | La URL que se abrirá en una nueva pestaña del navegador al hacer clic en el texto del valor. |
Ejemplos:
{
"type" : " keyValue " ,
"key" : " Lifetime purchase value " ,
"value" : " $10k "
}{
"type" : " keyValue " ,
"key" : " Last purchase ID " ,
"value" : " 123 " ,
"url" : " https://example.com/purchaseDetails?purchaseId=012345 "
}Una tabla con columnas y filas para mostrar datos en un formato estructurado.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "table" . |
columns | Formación | No | Las definiciones de la columna, incluidos los nombres y tipos. |
columns[*].name | Cadena | No | El nombre de la columna para mostrar. |
columns[*].type | Cadena | No | El tipo de valor de columna (por ejemplo, "string" , "number" ). |
rows | Formación | No | Las filas de datos, donde cada fila es un objeto que contiene valores para cada columna. |
Ejemplo:
{
"type" : " table " ,
"columns" : [
{
"name" : " Name " ,
"type" : " string "
},
{
"name" : " Age " ,
"type" : " number "
}
],
"rows" : [
{
"Name" : " Alice " ,
"Age" : 30
},
{
"Name" : " Bob " ,
"Age" : 40
}
]
}Una imagen que se mostrará en el panel.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "image" . |
url | Cadena | No | La URL de la imagen para mostrar. |
Ejemplo:
{
"type" : " image " ,
"url" : " https://example.com/images?purchaseId=012345 "
}Un video que se mostrará en el panel.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "video" . |
url | Cadena | No | La URL del video para mostrar. |
Ejemplo:
{
"type" : " video " ,
"url" : " https://example.com/video.mp4 "
}Un archivo de audio que se reproducirá en el panel.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "audio" . |
url | Cadena | No | La URL del audio para reproducir. |
Ejemplo:
{
"type" : " audio " ,
"url" : " https://example.com/audio.mp3 "
}Un botón que desencadena una acción cuando se hace clic.
| Parámetro | Valor | Opcional | Descripción |
|---|---|---|---|
type | Cadena | No | Debe ser "button" . |
text | Cadena | No | El texto para mostrar en el botón. |
action | Objeto | No | La acción a realizar cuando se hace clic en el botón. |
action.url | Cadena | No | La URL a la que se debe enviar la solicitud. |
action.method | Cadena | No | El método HTTP para usar para la acción (por ejemplo, "POST" ). |
action.headers | Objeto | Sí | Encabezados opcionales para incluir en la solicitud. |
action.body | Objeto | Sí | El cuerpo de la solicitud en formato JSON. |
Ejemplo:
{
"type" : " button " ,
"text" : " Click me! " ,
"action" : {
"url" : " https://api.example.com/click " ,
"method" : " POST " ,
"headers" : {
"Content-Type" : " application/json "
},
"body" : {
"key" : " value "
}
}
}Esta característica le permite usar el navegador de datos como otro usuario, respetando los permisos de datos de ese usuario. Por ejemplo, solo verá registros y campos que el usuario tiene permiso para ver.
️ Iniciar sesión como otro usuario activará los mismos desencadenantes de la nube como si el usuario inició sesión en sí mismo utilizando cualquier otro método de inicio de sesión. Iniciar sesión como otro usuario requiere ingresar la contraseña de ese usuario.
Esta característica le permite cambiar cómo se representa un puntero en el navegador. Por defecto, el objectId del objeto vinculado representa un puntero. Puede cambiar esto a cualquier otra columna de la clase de objeto. Por ejemplo, si Installation de clase tiene un campo que contiene un puntero al User de la clase, el puntero mostrará el objectId del usuario de forma predeterminada. Puede cambiar esto para mostrar el email de campo del usuario, de modo que un puntero muestre la dirección de correo electrónico del usuario.
objectId .createdAt , updatedAt , ACL no se pueden configurar como clave de puntero.objectId .
️ Para cada tecla de puntero personalizado en cada fila, se activa una solicitud de servidor para resolver la tecla de puntero personalizado. Por ejemplo, si el navegador muestra una clase con 50 filas y cada fila contiene 3 claves de puntero personalizadas, se activan un total de 150 solicitudes de servidor separadas.
Esta característica tomará filas seleccionadas o todas las filas de una clase individual y las guardará en un archivo CSV, que luego se descarga. Los encabezados CSV se agregan a la parte superior del archivo que coincide con los nombres de la columna.
️ Actualmente hay un límite de 10,000 filas al exportar todos los datos. Si hay más de 10,000 filas presentes en la clase, el archivo CSV solo contendrá 10,000 filas.
Realmente queremos que PARSE sea tuyo, verlo crecer y prosperar en la comunidad de código abierto. Consulte la guía del tablero contribuyente a PARSE.
A partir del 5 de abril de 2017, Parse, LLC ha transferido este código a la organización de comunicación de análisis, y ya no contribuirá o distribuirá este código.
