parse dashboard
6.0.0
O Parse Painel é um painel independente para gerenciar seus aplicativos de servidor Parse.
Instale o painel do npm .
npm install -g parse-dashboard
Você pode iniciar o painel para um aplicativo com um único comando fornecendo um ID do aplicativo, chave mestre, URL e nome como este:
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --appName optionalName
Você pode definir o caminho do host, porta e montagem, fornecendo as opções --host , --port e --mountPath para o painel de parse. Você pode usar o que quiser como nome do aplicativo ou deixá -lo de fora, caso em que o ID do aplicativo será usado.
O parâmetro --dev desativa os recursos de segurança prontos para produção. Este parâmetro é útil ao executar o painel Parse no Docker. Usando este parâmetro será:
allowInsecureHTTPmasterKey seja transmitido no ClearText sem criptografia
️ Não use este parâmetro ao implantar o painel Parse em um ambiente de produção.
Depois de iniciar o painel, você pode visitar http: // localhost: 4040 no seu navegador:
O painel Parse é compatível com as versões do servidor Parse a seguir.
| Versão do painel Parse | Versão do servidor parse | Compatível |
|---|---|---|
| > = 1.0 | > = 2.1.4 | ✅ Sim |
O painel Parse é testado continuamente com os lançamentos mais recentes do Node.js para garantir a compatibilidade. Seguimos o plano de suporte a longo prazo do Node.js e apenas testamos versões que são oficialmente apoiadas e não atingimos sua data de final de vida.
| Versão | Versão mais recente | Final de vida | Compatível |
|---|---|---|---|
| Node.js 18 | 18.20.4 | Maio de 2025 | ✅ Sim |
| Node.js 20 | 20.18.0 | Abril de 2026 | ✅ Sim |
| Node.js 22 | 22.9.0 | Abril de 2027 | ✅ Sim |
| Parâmetro | Tipo | Opcional | Padrão | Exemplo | Descrição |
|---|---|---|---|---|---|
apps | Array <ject> | não | - | [{ ... }, { ... }] | Os aplicativos configurados para o painel. |
infoPanel | Array <ject> | sim | - | [{ ... }, { ... }] | A configuração do painel de informações. |
infoPanel[*].title | Corda | não | - | User Details | O título do painel. |
infoPanel[*].classes | Array <tring> | não | - | ["_User"] | As classes para as quais o painel de informações devem ser exibidas. |
infoPanel[*].cloudCodeFunction | Corda | não | - | getUserDetails | A função de código da nuvem que recebeu o objeto selecionado no navegador de dados e retorna a resposta a ser exibida no painel de informações. |
apps.scripts | Array <ject> | sim | [] | [{ ... }, { ... }] | Os scripts que podem ser executados para esse aplicativo. |
apps.scripts.title | Corda | não | - | 'Delete User' | O título que será exibido no menu de contexto do navegador de dados e na caixa de diálogo Confirmação de execução do script. |
apps.scripts.classes | Array <tring> | não | - | ['_User'] | As classes de objetos de análise para os quais os scripts podem ser executados. |
apps.scripts.cloudCodeFunction | Corda | não | - | 'deleteUser' | O nome da função de nuvem de Parse a ser executada. |
apps.scripts.showConfirmationDialog | Bool | sim | false | true | É true se uma caixa de diálogo de confirmação for exibida antes da execução do script, false o script for executado imediatamente. |
apps.scripts.confirmationDialogStyle | Corda | sim | info | critical | O estilo da caixa de diálogo de confirmação. Valores válidos: info (estilo azul), critical (estilo vermelho). |
apps.cloudConfigHistoryLimit | Inteiro | sim | 100 | 100 | O número de valores históricos que devem ser salvos no histórico de mudanças de configuração da nuvem. Valores válidos: 0 ... Number.MAX_SAFE_INTEGER . |
Você também pode iniciar o painel da linha de comando com um arquivo de configuração. Para fazer isso, crie um novo arquivo chamado parse-dashboard-config.json dentro da sua hierarquia local de diretório de painel Parse. O arquivo deve corresponder ao seguinte formato:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " MyApp "
}
]
} Em seguida, você pode iniciar o painel usando parse-dashboard --config parse-dashboard-config.json .
Isso só funciona ao iniciar o aplicativo usando o comando
parse-dashboard
Existem também dois métodos que você pode usar para configurar o painel usando variáveis de ambiente.
Forneça toda a configuração JSON em PARSE_DASHBOARD_CONFIG e ele será analisado como o arquivo de configuração.
Você também pode definir cada opção de configuração 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
O gerenciamento de vários aplicativos do mesmo painel também é possível. Basta adicionar entradas adicionais à matriz "apps" do arquivo 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 "
}
]
}O Parse Pashboard possui um playground embutido para grafql para jogar com a API GRAPHQL GRAPACHQL gerada automaticamente.
Você pode configurar o playground do GraphQL, passando a opção --graphQLServerURL para a placa parse-dashboard :
parse-dashboard --dev --appId yourAppId --masterKey yourMasterKey --serverURL "https://example.com/parse" --graphQLServerURL "https://example.com/graphql" --appName optionalName
A opção graphQLServerURL também está disponível em uma variável de ambiente chamada 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"
Você também pode configurar o playground do GraphQL em seu arquivo 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 "
}
]
}Depois de iniciar o painel, você pode visitar http://0.0.0.0:4040/apps/mytestapp/api_console/graphql no seu navegador:
O painel de parse suporta adicionar um ícone opcional para cada aplicativo, para que você possa identificá -los mais fácil na lista. Para fazer isso, você deve usar o arquivo de configuração, definir uma iconsFolder e definir o parâmetro iconName para cada aplicativo (incluindo a extensão). O caminho do iconsFolder é relativo ao arquivo de configuração. Se você instalou o Parsedashboard globalmente, precisará usar o caminho completo como valor para a iconsFolder . Para visualizar o que significa, no exemplo a seguir, icons estão um diretório localizado no mesmo diretório que o arquivo de configuração:
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
}
],
"iconsFolder" : " icons "
} O painel Parse suporta adicionar uma cor de fundo opcional para cada aplicativo, para que você possa identificá -los mais fácil na lista. Para fazer isso, você deve usar o arquivo de configuração, definir um parâmetro primaryBackgroundColor e secondaryBackgroundColor , parâmetro para cada aplicativo. É CSS style . Para visualizar o que significa, no exemplo a seguir, backgroundColor é um arquivo de configuração:
{
"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
}
]
} Você pode definir appNameForURL no arquivo de configuração para cada aplicativo para controlar o URL do seu aplicativo dentro do painel. Isso pode facilitar o uso de favoritos ou compartilhar links no seu painel.
Para alterar o aplicativo para a produção, basta definir production como true em seu arquivo de configuração. O valor padrão é falso se não for especificado.
Você pode impedir que algumas colunas sejam classificáveis adicionando as opções de preventSort de column em cada configuração de aplicativos
"apps" : [
{
"appId" : " local_app_id " ,
"columnPreference" : {
"_User" : [
{
"name" : " createdAt " ,
"visible" : true ,
"preventSort" : true
},
{
"name" : " updatedAt " ,
"visible" : true ,
"preventSort" : false
},
]
}
}
] Se você tem aulas com muitas colunas e as filtra frequentemente com as mesmas colunas, pode classificá -las para o topo, estendendo a configuração de columnPreference com a opção filterSortToTop :
"apps" : [
{
"columnPreference" : {
"_User" : [
{
"name" : " objectId " ,
"filterSortToTop" : true
},
{
"name" : " email " ,
"filterSortToTop" : true
}
]
}
}
] Os filtros que você salva no navegador de dados do painel Parse estão disponíveis apenas para o usuário atual do painel na sessão atual do navegador. Para disponibilizar filtros permanentemente para todos os usuários do painel de um aplicativo, você pode definir filtros na configuração classPreference .
Por exemplo:
"apps" : [{
"classPreference" : {
"_Role" : {
"filters" : [{
"name" : " Filter Name " ,
"filter" : [
{
"field" : " objectId " ,
"constraint" : " exists "
}
]
}]
}
}
}]Você pode criar convenientemente uma definição de filtro sem precisar escrevê -la manualmente, salvando um filtro no navegador de dados e, em seguida, exportando a definição de filtro em Configurações do aplicativo> Preferências da classe de exportação .
Você pode especificar scripts para executar funções em nuvem com a opção scripts :
"apps" : [
{
"scripts" : [
{
"title" : " Delete Account " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " deleteAccount " ,
"showConfirmationDialog" : true ,
"confirmationDialogStyle" : " critical "
}
]
}
] Você também pode especificar campos personalizados com a opção scrips :
"apps" : [
{
"scripts" : [
{
"title" : " Delete account " ,
"classes" : [
{
"name" : " _User " ,
"fields" : [
{ "name" : " createdAt " , "validator" : " value => value > new Date( " 2025 " ) " }
]
}
],
"cloudCodeFunction" : " deleteAccount "
}
]
}
]
Em seguida, defina a função de nuvem no servidor Parse que será chamado. O objeto que foi selecionado no navegador de dados será disponibilizado como um parâmetro de solicitação:
Parse . Cloud . define ( 'deleteAccount' , async ( req ) => {
req . params . object . set ( 'deleted' , true ) ;
await req . params . object . save ( null , { useMasterKey : true } ) ;
} , {
requireMaster : true
} ) ; O campo em que o script foi chamado pode ser acessado pelo 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 como true para que o objeto selecionado no navegador de dados seja disponibilizado na função da nuvem como uma instância de Parse.Object . Se a opção não estiver definida, estiver definida como false ou você estiver usando uma versão mais antiga do servidor Parse, o objeto será disponibilizado como um objeto JavaScript simples e precisa ser convertido de um objeto json em uma instância Parse.Object com req.params.object = Parse.Object.fromJSON(req.params.object); , antes que você possa chamar qualquer propriedade e métodos Parse.Object .
Para versões mais antigas do servidor 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 } ) ;
} ) ;Em vez de iniciar o painel Parse com a CLI, você também pode executá -lo como um middleware expresso.
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 ) ;Se você deseja executar o painel Parse Server e Parse no mesmo servidor/porta, poderá executá -los como middleware expresso:
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 ) ; Verifique se os URLs do servidor para seus aplicativos podem ser acessados pelo seu navegador. Se você estiver implantando o painel, os URLs localhost não funcionarão.
Para implantar com segurança o painel sem vazar sua chave mestre de aplicativos, você precisará usar o HTTPS e a autenticação básica.
O painel implantado detecta se você estiver usando uma conexão segura. Se você estiver implantando o painel atrás de um balanceador de carga ou proxy frontal, o aplicativo não poderá detectar que a conexão está segura. Nesse caso, você pode iniciar o painel com a opção --trustProxy=1 (ou definir o parse_dashboard_trust_proxy config var como 1) para confiar nos cabeçalhos X-forwarded-* para a segurança de conexão do cliente. Isso é útil para hospedar serviços como a Heroku, onde você pode confiar nos cabeçalhos proxy fornecidos para determinar corretamente se você está usando HTTP ou HTTPS. Você também pode ativar essa configuração ao usar o painel como middleware expresso:
var trustProxy = true ;
var dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
}
] ,
"trustProxy" : 1
} ) ; Você pode visualizar o status de segurança do seu servidor Parse, ativando a opção Painel enableSecurityChecks e visitando Configurações de aplicativos> Segurança.
const dashboard = new ParseDashboard ( {
"apps" : [
{
"serverURL" : "http://localhost:1337/parse" ,
"appId" : "myAppId" ,
"masterKey" : "myMasterKey" ,
"appName" : "MyApp"
"enableSecurityChecks" : true
}
] ,
} ) ; Você pode configurar o seu painel para obter autenticação básica adicionando nomes de usuário e senhas seu arquivo de configuração de parse-dashboard-config.json :
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass "
},
{
"user" : " user2 " ,
"pass" : " pass "
}
],
"useEncryptedPasswords" : true | false
} Você pode armazenar a senha nos formatos plain text ou bcrypt . Para usar o formato bcrypt , você deve definir o parâmetro de configuração useEncryptedPasswords como true . Você pode gerar senhas criptografadas usando parse-dashboard --createUser e colar o resultado na configuração dos usuários.
Você pode adicionar uma camada adicional de segurança para uma conta de usuário exigindo autenticação multifatorial (MFA) para o usuário fazer login.
Com o MFA ativado, um usuário deve fornecer uma senha única que normalmente esteja ligada a um dispositivo físico, além de sua senha de login. Isso significa que, além de conhecer a senha de login, o usuário precisa ter acesso físico a um dispositivo para gerar a senha única. Essa senha única é baseada no tempo (TOTP) e só válida por um curto período de tempo, normalmente 30 segundos, até que expire.
O usuário exige que um aplicativo do Authenticator gere a senha única. Esses aplicativos são fornecidos por muitas terceiros e principalmente de graça.
Se você criar um novo usuário executando parse-dashboard --createUser , será perguntado se deseja ativar o MFA para o novo usuário. Para habilitar o MFA para um usuário existente, execute parse-dashboard --createMFA para gerar um segredo mfa que você adiciona à configuração do usuário existente, por exemplo:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass " ,
"mfa" : " lmvmOIZGMTQklhOIhveqkumss "
}
]
} O painel Parse segue o padrão da indústria e suporta o algoritmo OTP comum SHA-1 por padrão, para ser compatível com a maioria dos aplicativos autenticadores. Se você tiver requisitos de segurança específicos em relação às características do TOTP (algoritmo, dígito, período de tempo), poderá personalizá -las usando a configuração guiada mencionada acima.
Se você configurou seu painel para gerenciar vários aplicativos, pode restringir o gerenciamento de aplicativos com base na identidade do usuário.
Para fazer isso, atualize seu arquivo de configuração parse-dashboard-config.json para corresponder ao seguinte formato:
{
"apps" : [{ "..." : " ... " }],
"users" : [
{
"user" : " user1 " ,
"pass" : " pass1 " ,
"apps" : [{ "appId" : " myAppId1 " }, { "appId" : " myAppId2 " }]
},
{
"user" : " user2 " ,
"pass" : " pass2 " ,
"apps" : [{ "appId" : " myAppId1 " }]
} ]
}O efeito dessa configuração é o seguinte:
Quando user1 efetua login, ele poderá gerenciar myAppId1 e myAppId2 no painel.
Quando user2 faz login, ele/ela só poderá gerenciar myAppId1 no painel.
Iniciando o Parse-Server 2.6.5, é possível fornecer a um readOnlyMasterKey para analisar o servidor para impedir mutações nos objetos de um cliente. Se você deseja proteger seu painel com esse recurso, basta usar o readOnlyMasterKey em vez do masterKey . Todas as chamadas de gravação falharão.
Comece seu parse-server com
{
"masterKey" : " YOUR_MASTER_KEY_HERE " ,
"readOnlyMasterKey" : " YOUR_READ_ONLY_MASTER_KEY " ,
}Então, na configuração do seu painel:
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
} ) ; Certifique-se de especificar o readOnlyMasterKey para os aplicativos que você deseja usar o recurso somente leitura na configuração "Apps". Você pode marcar um usuário como um usuário somente leitura:
{
"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 " }]
}
]
} user1 myAppId1 myAppId2
Certifique-se de especificar o readOnlyMasterKey para os aplicativos que você deseja usar o recurso somente leitura na configuração "Apps". Você pode dar acesso apenas ao usuário a um usuário por aplicativo:
{
"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 " }]
}
]
} Com essa configuração, o User1 terá acesso apenas ao myAppId1 e ao acesso a leitura/gravação ao myAppId2 .
Com a versão mais recente do painel, é possível enviar mensagens localizadas para notificações push. Você pode fornecer uma lista de locais ou idiomas que deseja suportar para os usuários do painel.
{
"apps" : [
{
"serverURL" : " http://localhost:1337/parse " ,
"appId" : " myAppId " ,
"masterKey" : " myMasterKey " ,
"appName" : " My Parse Server App " ,
"iconName" : " MyAppIcon.png " ,
"supportedPushLocales" : [ " en " , " ru " , " fr " ]
}
],
"iconsFolder" : " icons "
}A imagem oficial do Docker é publicada no Docker Hub
Execute a imagem com seu config.json montado como um volume
docker run -d -p 8080:4040 -v host/path/to/config.json:/src/Parse-Dashboard/parse-dashboard-config.json parseplatform/parse-dashboard --dev
Você também pode passar no Appid, MasterKey e Serverurl como argumentos:
docker run -d -p 4040:4040 parseplatform/parse-dashboard --dev --appId $APP_ID --masterKey $MASTER_KEY --serverURL $SERVER_URL
Por padrão, o contêiner iniciará o aplicativo na porta 4040 dentro do contêiner. No entanto, você também pode executar o comando personalizado (consulte Deploying in production para configuração personalizada).
Neste exemplo, queremos executar o aplicativo no modo de produção na porta 80 da 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
Se você não estiver familiarizado com o Docker, --port 8080 será passado como argumento para o ponto de entrada para formar o comando completo npm start -- --port 8080 . O aplicativo começará na porta 8080 dentro do recipiente e a porta 8080 será montada na porta 80 na sua máquina host.
(O seguinte não é uma lista completa de recursos, mas um trabalho em andamento para criar uma lista de recursos abrangentes.)
A caixa de diálogo Filtro permite adicionar condições de filtro relacional com base em outras classes que têm um ponteiro para a classe atual.
Por exemplo, os usuários da classe _User podem ter:
Purchase com um campo de ponteiro _UserPayment com um campo de ponteiro _UserUm filtro relacional permite filtrar todos os usuários que:
Purchase )Payment ) Para aplicar esse filtro, basta acessar a classe _User e adicionar as duas condições de filtro necessárias com as classes Purchase e Payment .
O navegador de dados oferece um painel de informações que pode exibir informações relacionadas ao objeto atualmente selecionado na tabela de navegador de dados. O painel de informações é tornado visível clicando no botão Menu Show Painel no canto superior direito ao navegar em uma aula para a qual o painel de informações está configurado nas opções do painel.
O exemplo a seguir a configuração do painel mostra um painel de informações para a classe _User com os User Details do título, chamando a função de código da nuvem getUserDetails e exibindo a resposta retornada.
"apps" : [
{
"infoPanel" : [
{
"title" : " User Details " ,
"classes" : [ " _User " ],
"cloudCodeFunction" : " getUserDetails "
}
]
}
]A função de código da nuvem recebe o objeto selecionado na carga útil e retorna uma resposta que pode incluir vários itens.
O painel de informações pode conter vários segmentos para exibir diferentes grupos de informações.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
segments | Variedade | Não | Uma variedade ordenada de segmentos, onde cada segmento representa um grupo distinto de itens a serem exibidos. |
segments[i].title | Corda | Não | O título do segmento que será exibido. |
segments[i].items | Variedade | Não | Uma variedade ordenada de itens dentro do segmento. Cada item pode ser de tipos diferentes, como texto, pares de valor-chave, mesas, imagens, etc. |
Exemplo:
{
"panel" : {
"segments" : [
{
"title" : " Purchases " ,
"items" : [
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}
]
}
]
}
}A matriz de itens pode incluir vários tipos de conteúdo, como texto, pares de valor-chave, tabelas, imagens, vídeos, áudios e botões. Cada tipo oferece uma maneira diferente de exibir informações no painel de informações, permitindo uma experiência de usuário personalizável e rica. Abaixo está uma explicação detalhada de cada tipo.
Um campo de texto simples.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "text" . |
text | Corda | Não | O texto a ser exibido. |
Exemplo:
{
"type" : " text " ,
"text" : " This user has a high churn risk! "
}Um item de texto que consiste em uma chave e um valor. O valor pode opcionalmente estar vinculado a um URL.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "keyValue" . |
key | Corda | Não | O texto principal a ser exibido. |
value | Corda | Não | O texto do valor a ser exibido. |
url | Corda | Sim | O URL que será aberto em uma nova guia do navegador ao clicar no texto do valor. |
Exemplos:
{
"type" : " keyValue " ,
"key" : " Lifetime purchase value " ,
"value" : " $10k "
}{
"type" : " keyValue " ,
"key" : " Last purchase ID " ,
"value" : " 123 " ,
"url" : " https://example.com/purchaseDetails?purchaseId=012345 "
}Uma tabela com colunas e linhas para exibir dados em um formato estruturado.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "table" . |
columns | Variedade | Não | As definições da coluna, incluindo nomes e tipos. |
columns[*].name | Corda | Não | O nome da coluna para exibir. |
columns[*].type | Corda | Não | O tipo do valor da coluna (por exemplo, "string" , "number" ). |
rows | Variedade | Não | As linhas de dados, onde cada linha é um objeto que contém valores para cada coluna. |
Exemplo:
{
"type" : " table " ,
"columns" : [
{
"name" : " Name " ,
"type" : " string "
},
{
"name" : " Age " ,
"type" : " number "
}
],
"rows" : [
{
"Name" : " Alice " ,
"Age" : 30
},
{
"Name" : " Bob " ,
"Age" : 40
}
]
}Uma imagem a ser exibida no painel.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "image" . |
url | Corda | Não | O URL da imagem para exibir. |
Exemplo:
{
"type" : " image " ,
"url" : " https://example.com/images?purchaseId=012345 "
}Um vídeo a ser exibido no painel.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "video" . |
url | Corda | Não | O URL do vídeo a ser exibido. |
Exemplo:
{
"type" : " video " ,
"url" : " https://example.com/video.mp4 "
}Um arquivo de áudio a ser reproduzido no painel.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "audio" . |
url | Corda | Não | O URL do áudio para tocar. |
Exemplo:
{
"type" : " audio " ,
"url" : " https://example.com/audio.mp3 "
}Um botão que aciona uma ação quando clicado.
| Parâmetro | Valor | Opcional | Descrição |
|---|---|---|---|
type | Corda | Não | Deve ser "button" . |
text | Corda | Não | O texto a ser exibido no botão. |
action | Objeto | Não | A ação a ser executada quando o botão é clicada. |
action.url | Corda | Não | O URL para o qual a solicitação deve ser enviada. |
action.method | Corda | Não | O método HTTP a ser usado para a ação (por exemplo, "POST" ). |
action.headers | Objeto | Sim | Cabeçalhos opcionais para incluir na solicitação. |
action.body | Objeto | Sim | O corpo da solicitação no formato JSON. |
Exemplo:
{
"type" : " button " ,
"text" : " Click me! " ,
"action" : {
"url" : " https://api.example.com/click " ,
"method" : " POST " ,
"headers" : {
"Content-Type" : " application/json "
},
"body" : {
"key" : " value "
}
}
}Esse recurso permite que você use o navegador de dados como outro usuário, respeitando as permissões de dados desse usuário. Por exemplo, você verá apenas registros e campos que o usuário tem permissão para ver.
️ O login como outro usuário acionará o mesmo gatilho da nuvem como se o usuário conectasse a si mesmas usando qualquer outro método de login. O login como outro usuário exige inserir a senha desse usuário.
Esse recurso permite alterar a forma como um ponteiro é representado no navegador. Por padrão, um ponteiro é representado pelo objectId do objeto vinculado. Você pode alterar isso para qualquer outra coluna da classe de objeto. Por exemplo, se Installation da classe possui um campo que contém um ponteiro para User da classe, o ponteiro mostrará o objectId do usuário por padrão. Você pode alterar isso para exibir o email de campo do usuário, para que um ponteiro exiba o endereço de email do usuário.
objectId .createdAt , updatedAt , ACL não podem ser definidas como chave de ponteiro.objectId .
️ Para cada chave de ponteiro personalizada em cada linha, uma solicitação de servidor é acionada para resolver a tecla de ponteiro personalizada. Por exemplo, se o navegador mostrar uma classe com 50 linhas e cada linha contiver 3 teclas de ponteiro personalizadas, um total de 150 solicitações de servidor separadas serão acionadas.
Esse recurso levará linhas selecionadas ou todas as linhas de uma classe individual e as salvará em um arquivo CSV, que é baixado. Os cabeçalhos CSV são adicionados à parte superior do arquivo que corresponde aos nomes das colunas.
️ Atualmente, existe um limite de 10.000 linhas ao exportar todos os dados. Se mais de 10.000 linhas estiverem presentes na classe, o arquivo CSV conterá apenas 10.000 linhas.
Nós realmente queremos que a Parse seja sua, para que ela cresça e prospere na comunidade de código aberto. Por favor, consulte a contribuição para o Guia do painel Parse.
Em 5 de abril de 2017, a Parse, a LLC transferiu esse código para a organização Parse-Community e não estará mais contribuindo ou distribuindo esse código.
