Como utilizar as aplicações móveis Node.js SDK

Artigo
10/01/2016

Este artigo fornece informações detalhadas e exemplos que mostram como trabalhar com um Node.js back end na funcionalidade de Aplicações Móveis de Serviço de Aplicações do Azure.

Introdução

As Aplicações Móveis fornecem a capacidade de adicionar uma API web de acesso de dados otimizada para dispositivos móveis a uma aplicação web. O SDK de aplicações móveis está previsto para aplicações web ASP.NET e Node.js. O SDK fornece as seguintes operações:

Operações de tabela (ler, inserir, atualizar, excluir) para acesso a dados
Operações API personalizadas

Ambas as operações prevêem a autenticação em todos os fornecedores de identidade que Serviço de Aplicações do Azure permite. Estes fornecedores incluem fornecedores de identidade social como Facebook, Twitter, Google e Microsoft, bem como Azure Ative Directory para a identidade da empresa.

Pode encontrar amostras para cada caso de utilização no diretório de amostras no GitHub.

Plataformas suportadas

As Aplicações Móveis Node.js SDK suporta a atual versão LTS do Nó e mais tarde. Atualmente, a versão mais recente do LTS é Node v4.5.0. Outras versões de Nó podem funcionar, mas não são suportadas.

O Mobile Apps Node.js SDK suporta dois controladores de base de dados:

O condutor do nó-mssql suporta Base de Dados SQL do Azure e locais SQL Server casos.
O condutor sqlite3 suporta bases de dados SQLite apenas num único caso.

Crie uma parte traseira Node.js básica utilizando a linha de comando

Todas as aplicações móveis Node.js final de trás começa como uma aplicação ExpressJS. O ExpressJS é o quadro de serviços web mais popular disponível para Node.js. Pode criar uma aplicação express básica da seguinte forma:

Numa janela de comando ou PowerShell, crie um diretório para o seu projeto:
```
 mkdir basicapp
```
Correr npm init para rubricar a estrutura do pacote:
```
 cd basicapp
 npm init
```
O npm init comando faz um conjunto de perguntas para inicializar o projeto. Consulte a saída do exemplo:
Instale as express bibliotecas e azure-mobile-apps bibliotecas a partir do repositório npm:
```
 npm install --save express azure-mobile-apps
```

Crie um ficheiro app.js para implementar o servidor móvel básico:

var express = require('express'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Define a TodoItem table.
mobile.tables.add('TodoItem');

// Add the Mobile API so it is accessible as a Web API.
app.use(mobile);

// Start listening on HTTP.
app.listen(process.env.PORT || 3000);

Esta aplicação cria uma API Web otimizada para dispositivos móveis com um único ponto final (/tables/TodoItem) que proporciona acesso não autenticado a uma loja de dados SQL subjacente utilizando um esquema dinâmico. É adequado para seguir os rápidos arranques da biblioteca do cliente:

Pode encontrar o código para esta aplicação básica na amostra basicapp na GitHub.

Crie uma parte traseira Node.js utilizando Visual Studio 2015

Visual Studio 2015 exige uma extensão para desenvolver aplicações Node.js no âmbito do IDE. Para iniciar, instale as ferramentasNode.js 1.1 para Visual Studio. Quando terminar a instalação, crie uma aplicação Express 4.x:

Abra a caixa de diálogo New Project (a partir de File>New>Project).
Expandir modelos>JavaScript>Node.js.
Selecione Azure Basic Node.js Express 4 Application.
Preencha o nome do projeto. Selecione OK.
Clique com o botão direito no nó npm e selecione Instalar novos pacotes npm.
Poderá ter de refrescar o catálogo da Npm depois de criar a sua primeira aplicação Node.js. Selecione Refresh se necessário.
Introduza aplicativos azure-mobile na caixa de pesquisa. Selecione o pacote azure-mobile-apps 2.0.0 e, em seguida, selecione Pacote de Instalação.
Selecione Fechar.
Abra o ficheiro app.js para adicionar suporte para o SDK de aplicações móveis. Na linha 6 na parte inferior das declarações da biblioteca require , adicione o seguinte código:
```
var bodyParser = require('body-parser');
var azureMobileApps = require('azure-mobile-apps');
```
Aproximadamente na linha 27 após as outras app.use declarações, adicione o seguinte código:
```
app.use('/users', users);

// Mobile Apps initialization
var mobile = azureMobileApps();
mobile.tables.add('TodoItem');
app.use(mobile);
```
Guarde o ficheiro.
Ou executar o pedido localmente (a API é servida em https://localhost:3000) ou publicar para a Azure.

Crie uma parte traseira Node.js utilizando o portal do Azure

Pode criar um final de aplicações móveis logo no portal do Azure. Pode completar os seguintes passos ou criar um cliente e servidor em conjunto seguindo o tutorial de aplicações móveis Create . O tutorial contém uma versão simplificada destas instruções e é o melhor para projetos de prova de conceito.

Inicie sessão no portal do Azure.
Selecione +NEW>Web + Mobile>Mobile App e, em seguida, forneça um nome para as suas Aplicações Móveis de volta.
Para o Grupo de Recursos, selecione um grupo de recursos existente ou crie um novo (utilizando o mesmo nome que a sua aplicação).
Para Serviço de Aplicações plano, o plano padrão (no nível Standard) é selecionado. Também pode selecionar um plano diferente ou criar um novo.

As definições do plano Serviço de Aplicações determinam a localização, funcionalidades, custos e recursos de computação associados à sua aplicação. Para mais sobre Serviço de Aplicações planos e como criar um novo plano num nível de preços diferente e na sua localização desejada, consulte Serviço de Aplicações do Azure planos em profundidade.
Selecione Criar. Este passo cria o back end das Aplicações Móveis.
No painel de Definições para o novo back end de Aplicações Móveis, selecione Quick start> your client app platform >Ligação uma base de dados.
No painel de ligação de dados Adicionar, selecione Base de Dados SQL>Create uma nova base de dados. Introduza o nome da base de dados, escolha um nível de preços e, em seguida, selecione Server. Pode reutilizar esta nova base de dados. Se já tiver uma base de dados na mesma localização, pode escolher Utilizar uma base de dados existente. Não recomendamos o uso de uma base de dados num local diferente, devido aos custos de largura de banda e à maior latência.
No painel de servidor Novo , insira um nome de servidor único na caixa de nomes do Servidor , forneça um login e uma palavra-passe, selecione Permitir serviços Azure para aceder ao servidor e selecione OK. Este passo cria a nova base de dados.
Voltar ao painel de ligação de dados Adicionar , selecionar a cadeia de ligação, introduzir os valores de login e palavra-passe para a sua base de dados e selecionar OK.

Aguarde alguns minutos para que a base de dados seja implantada com sucesso antes de prosseguir.

De volta ao painel de Introdução, sob a Criação de uma API de mesa, escolha Node.js como idioma de fundo. Selecione a caixa para eu reconhecer que isto irá substituir todos os conteúdos do site e, em seguida, selecione Criar a tabela TodoItem.

Descarregue o projeto de código quickstart de back-end Node.js usando Git

Quando cria uma Node.js Mobile Apps de volta, utilizando o painel de início rápido do portal, é criado um projeto Node.js para si e implementado no seu site. No portal, pode adicionar tabelas e APIs e editar ficheiros de código para o Node.js final. Também pode usar várias ferramentas de implementação para descarregar o projeto back-end para que possa adicionar ou modificar tabelas e APIs e, em seguida, reeditar o projeto. Para mais informações, consulte o guia de Serviço de Aplicações do Azure de implementação.

O seguinte procedimento utiliza um repositório git para descarregar o código de projeto quickstart:

Instale git, se ainda não o fez. Os passos necessários para instalar o Git variam entre os sistemas operativos. Para distribuição e orientação de instalação específicas do sistema operativo, consulte a Instalação do Git.
Consulte preparar o seu repositório para ativar o repositório git para o seu local de back-end. Tome nota do nome de utilizador e da palavra-passe da implementação.
No painel para o final das suas Aplicações Móveis, tome nota da definição de URL do clone git .
Execute o git clone comando utilizando o URL do clone git. Introduza a sua palavra-passe quando necessário, como no seguinte exemplo:
```
 $ git clone https://username@todolist.scm.azurewebsites.net:443/todolist.git
```
Navegue no diretório local (/todolist no exemplo anterior) e note que os ficheiros do projeto foram descarregados. Localize o ficheiro todoitem.json no /tables diretório. Este ficheiro define permissões na mesa. Também encontre o ficheiro todoitem.js no mesmo diretório. Define os scripts de operação CRUD para a tabela.
Depois de es fazer alterações nos ficheiros do projeto, executar os seguintes comandos para adicionar, comprometer e, em seguida, carregar as alterações no site:
```
 $ git commit -m "updated the table script"
 $ git push origin master
```
Quando adiciona novos ficheiros ao projeto, primeiro tem de executar o git add . comando.

O site é republicado sempre que um novo conjunto de compromissos é empurrado para o site.

Publique o seu Node.js final para Azure

Microsoft Azure fornece muitos mecanismos para a publicação das suas Aplicações Móveis Node.js final para o serviço Azure. Estes mecanismos incluem ferramentas de implantação integradas em Visual Studio, ferramentas de linha de comando e opções de implementação contínua baseadas no controlo de fontes. Para mais informações, consulte o guia de Serviço de Aplicações do Azure de implementação.

Serviço de Aplicações do Azure tem conselhos específicos para Node.js aplicações que deve rever antes de publicar a parte de trás:

Como especificar a versão nó
Como utilizar módulos de nó

Ativar uma página inicial para a sua aplicação

Muitas aplicações são uma combinação de aplicações web e móveis. Pode utilizar a estrutura ExpressJS para combinar as duas facetas. Por vezes, porém, é melhor implementar apenas uma interface móvel. É útil fornecer uma página inicial para garantir que o serviço de aplicações está em funcionamento. Pode fornecer a sua própria página inicial ou ativar uma página inicial temporária. Para ativar uma página inicial temporária, utilize o seguinte código para instantaneaizar aplicações móveis:

var mobile = azureMobileApps({ homePage: true });

Se apenas quiser esta opção disponível no desenvolvimento local, pode adicionar esta definição ao seu ficheiro azureMobile.js.

Operações de tabela

O azure-mobile-apps Node.js Server SDK fornece mecanismos para expor as tabelas de dados armazenadas em Base de Dados SQL do Azure como uma API web. Fornece cinco operações:

Operação	Description
GET /tabelas/nome de mesa	Pegue todos os registos na mesa.
GET /tables/tablename/:id	Obter um registo específico na mesa.
POST /tabelas/nome de mesa	Criar um disco na mesa.
PATCH /tabelas/nome de mesa/:id	Atualize um recorde na tabela.
DELETE /tabelas/nome de mesa/:id	Apague um disco na mesa.

Esta API Web suporta o OData e alarga o esquema de tabela para suportar a sincronização de dados offline.

Defina tabelas usando um esquema dinâmico

Antes de poder usar uma mesa, deve defini-la. Pode definir tabelas utilizando um esquema estático (onde define as colunas no esquema) ou dinamicamente (onde o SDK controla o esquema com base em pedidos de entrada). Além disso, pode controlar aspetos específicos da API Web adicionando o código JavaScript à definição.

Como uma boa prática, deve definir cada tabela num ficheiro JavaScript no diretório e, em tables seguida, usar o tables.import() método para importar as tabelas. Estendendo a amostra de aplicação básica, ajustaria o ficheiro app.js:

var express = require('express'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Define the database schema that is exposed.
mobile.tables.import('./tables');

// Provide initialization of any tables that are statically defined.
mobile.tables.initialize().then(function () {
    // Add the Mobile API so it is accessible as a Web API.
    app.use(mobile);

    // Start listening on HTTP.
    app.listen(process.env.PORT || 3000);
});

Defina a tabela em ./tables/TodoItem.js:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Additional configuration for the table goes here.

module.exports = table;

As tabelas utilizam um esquema dinâmico por defeito. Para desligar o esquema dinâmico globalmente, defina a definição da MS_DynamicSchema aplicação como falsa no portal do Azure.

Pode encontrar um exemplo completo na amostra de todo GitHub.

Defina tabelas usando um esquema estático

Pode definir explicitamente as colunas para expor através da API Web. As aplicações azure-mobile Node.js SDK adicionam automaticamente quaisquer colunas extra necessárias para sincronização de dados offline na lista que fornece. Por exemplo, as aplicações de cliente quickstart requerem uma tabela com duas colunas: text (uma corda) e complete (um Boolean).
A tabela pode ser definida na definição de tabela Ficheiro JavaScript (localizado no diretório) da tables seguinte forma:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

module.exports = table;

Se definir tabelas estáticas, também deve ligar para o tables.initialize() método para criar o esquema de base de dados no arranque. O tables.initialize() método devolve uma promessa para que o serviço web não atende pedidos antes da base de dados ser inicializada.

Utilize SQL Server Express como uma loja de dados de desenvolvimento na sua máquina local

O Mobile Apps Node.js SDK oferece três opções para servir dados fora da caixa:

Utilize o controlador de memória para fornecer uma loja de exemplo não persistente.
Utilize o controlador mssql para fornecer uma SQL Server Express loja de dados para o desenvolvimento.
Utilize o controlador mssql para fornecer uma Base de Dados SQL do Azure loja de dados para produção.

O Node.js SDK de Aplicações Móveis utiliza o pacote mssql Node.js para estabelecer e utilizar uma ligação tanto SQL Server Express como Base de Dados SQL. Este pacote requer que você ative as ligações TCP no seu SQL Server Express exemplo.

Dica

O controlador de memória não fornece um conjunto completo de instalações para testes. Se quiser testar a sua parte traseira localmente, recomendamos a utilização de uma loja de dados SQL Server Express e do controlador mssql.

Faça o download e instale Microsoft SQL Server Express 2014. Certifique-se de que instala o SQL Server edição Express 2014 com Ferramentas. A menos que exija explicitamente suporte de 64 bits, a versão de 32 bits consome menos memória ao correr.
Executar SQL Server Configuration Manager 2014:

a. Expanda o nó de configuração de rede SQL Server no menu da árvore.

b. Selecione Protocolos para SQLEXPRESS.

c. Clique com o botão direito TCP/IP e selecione Enable. Selecione OK na caixa de diálogo pop-up.

d. Clique com o botão direito TCP/IP e selecione Propriedades.

e. Selecione o separador endereços IP .

f. Encontre o nó IPAll . No campo TCP Port , entre em 1433.

exemplo, Selecione OK. Selecione OK na caixa de diálogo pop-up.

h. Selecione SQL Server Serviços no menu de árvores.

i. Clique SQL Server à direita (SQLEXPRESS) e selecione Restart.

j. Feche SQL Server Configuration Manager de 2014.
Executar SQL Server Management Studio 2014 e ligar-se ao seu SQL Server Express local:
1. Clique com o botão direito no seu caso em Object Explorer e selecione Propriedades.
2. Selecione a página De Segurança .
3. Certifique-se de que o modo de autenticação SQL Server e Windows está selecionado.
4. Selecione OK.
5. Expandirlogins desegurança> em Object Explorer.
6. Clique em Logins com direito e selecione Novo Login.
7. Insira um nome de login. Selecione SQL Server autenticação. Introduza uma palavra-passe e introduza a mesma palavra-passe na palavra-passe Confirm. A palavra-passe deve satisfazer Windows requisitos de complexidade.
8. Selecione OK.
9. Clique com o botão direito no seu novo login e selecione Propriedades.
10. Selecione a página 'Funções do Servidor '.
11. Selecione a caixa de verificação para a função do servidor do dbcreator .
12. Selecione OK.
13. Management Studio de encerramento SQL Server 2015.

Certifique-se de gravar o nome de utilizador e a palavra-passe que selecionou. Poderá necessitar de atribuir funcionalidades ou permissões adicionais do servidor, dependendo dos requisitos da sua base de dados.

A aplicação Node.js lê a SQLCONNSTR_MS_TableConnectionString variável ambiental para a cadeia de ligação desta base de dados. Pode definir esta variável no seu ambiente. Por exemplo, pode utilizar o PowerShell para definir esta variável ambiental:

$env:SQLCONNSTR_MS_TableConnectionString = "Server=127.0.0.1; Database=mytestdatabase; User Id=azuremobile; Password=T3stPa55word;"

Aceda à base de dados através de uma ligação TCP/IP. Forneça um nome de utilizador e senha para a ligação.

Configure o seu projeto para o desenvolvimento local

Mobile Apps lê um ficheiro JavaScript chamado azureMobile.js do sistema de ficheiros local. Não utilize este ficheiro para configurar o SDK de aplicações móveis em produção. Em vez disso, utilize as definições de App no portal do Azure.

O ficheiro azureMobile.js deve exportar um objeto de configuração. As definições mais comuns são:

Definições de base de dados
Definições de registo de diagnóstico
Configurações alternativas do CORS

Este exemplo azureMobile.js ficheiro implementa as definições anteriores da base de dados:

module.exports = {
    cors: {
        origins: [ 'localhost' ]
    },
    data: {
        provider: 'mssql',
        server: '127.0.0.1',
        database: 'mytestdatabase',
        user: 'azuremobile',
        password: 'T3stPa55word'
    },
    logging: {
        level: 'verbose'
    }
};

Recomendamos que adicione azureMobile.js ao seu ficheiro .gitignore (ou outro ficheiro de controlo de código fonte) para evitar que as palavras-passe sejam armazenadas na nuvem. Configurar sempre as definições de produção nas definições da App dentro do portal do Azure.

Configurar configurações de aplicativos para a sua aplicação móvel

A maioria das configurações no ficheiro azureMobile.js têm uma definição de aplicação equivalente no portal do Azure. Utilize a seguinte lista para configurar a sua aplicação nas definições da App:

Definição de aplicativo	azureMobile.js definição	Description	Valores válidos
MS_MobileAppName	name	Nome da app	string
MS_MobileLoggingLevel	logging.level	Nível mínimo de registo de mensagens para registar	erro, aviso, informação, verbose, depurar, tolo
MS_DebugMode	depurar	Ativa ou desativa o modo de depuração	TRUE, false
MS_TableSchema	data.schema	Nome de esquema padrão para tabelas SQL	cadeia (padrão: dbo)
MS_DynamicSchema	data.dynamicSchema	Ativa ou desativa o modo de depuração	TRUE, false
MS_DisableVersionHeader	versão (definida para indefinida)	Desativa o cabeçalho versão X-ZUMO-Server	TRUE, false
MS_SkipVersionCheck	skipversãocheck	Desativa a verificação da versão API do cliente	TRUE, false

Para definir uma definição de aplicativo:

Inicie sessão no portal do Azure.
Selecione todos os recursos ou Serviços de Aplicações e, em seguida, selecione o nome da sua aplicação móvel.
O painel de Definições abre por defeito. Se não, selecione Definições.
No menu GENERAL , selecione Definições de Aplicação.
Percorra a secção de definições da App .
Se a definição da sua aplicação já existir, selecione o valor da definição da aplicação para editar o valor. Se a definição da sua aplicação não existir, insira a definição da aplicação na caixa Chave e o valor na caixa Valor .
Selecione Guardar.

Alterar a maioria das definições de aplicações requer um reinício do serviço.

Utilize Base de Dados SQL como loja de dados de produção

A utilização de Base de Dados SQL do Azure como loja de dados é idêntica em todos os tipos de aplicações Serviço de Aplicações do Azure. Se ainda não o fez, siga estes passos para criar um final de Apps Móveis:

Inicie sessão no portal do Azure.
Na parte superior esquerda da janela, selecione o botão >+NEWWeb + Mobile>Mobile App e, em seguida, forneça um nome para as suas Aplicações Móveis de volta.
Na caixa do Grupo de Recursos , insira o mesmo nome da sua aplicação.
O plano de Serviço de Aplicações predefinido é selecionado. Se quiser mudar o seu plano de Serviço de Aplicações:

a. Selecione Serviço de Aplicações Plano>+Criar Novo.

b. Forneça o nome do novo plano de Serviço de Aplicações e selecione uma localização apropriada.

c. Selecione um nível de preços apropriado para o serviço. Selecione Ver tudo para ver mais opções de preços, como Grátis e Compartilhado.

d. Clique no botão Seleção .

e. De volta ao painel de planos Serviço de Aplicações, selecione OK.
Selecione Criar.

A disponibilização de uma aplicação móvel pode demorar alguns minutos. Depois de as Aplicações Móveis voltarem a ser a provisionadas, o portal abre o painel de Definições para o back end das Aplicações Móveis.

Pode optar por ligar uma base de dados SQL existente às suas Aplicações Móveis ou criar uma nova base de dados SQL. Nesta secção, criamos uma base de dados SQL.

Nota

Se já tiver uma base de dados no mesmo local que as Aplicações Móveis, pode em vez disso selecionar Utilize uma base de dados existente e, em seguida, selecione essa base de dados. Não recomendamos o uso de uma base de dados num local diferente por causa de latências mais altas.

No final das novas Aplicações Móveis, selecione Definições>Mobile App>Data>+Add.
No painel de ligação de dados Adicionar, selecione Base de Dados SQL - Configurar as definições necessáriasCriar uma nova base de dados>. Introduza o nome da nova base de dados na caixa 'Nome '.
Selecione Servidor. No painel de servidor Novo , insira um nome de servidor único na caixa de nome do Servidor e forneça um login e senha de administração de servidor adequados. Certifique-se de que é selecionado um serviço de azure para aceder ao servidor . Selecione OK.
No painel de base de dados Novo , selecione OK.
De volta ao painel de ligação de dados Adicionar , selecione a cadeia de ligação e introduza o login e a palavra-passe que forneceu quando criou a base de dados. Se utilizar uma base de dados existente, forneça as credenciais de login para essa base de dados. Selecione OK.
De volta ao painel de ligação de dados Adicionar novamente, selecione OK para criar a base de dados.

A criação da base de dados pode demorar alguns minutos. Utilize a área de Notificações para monitorizar o progresso da implantação. Não progrida até que a base de dados seja implantada com sucesso. Após a implementação da base de dados, é criada uma cadeia de ligação para a Base de Dados SQL instância nas definições de aplicações traseiras das suas Aplicações Móveis. Pode ver esta definição de aplicação em Definições>Finas> deAplicação Ligam as cordas.

Exigir autenticação para acesso a mesas

Se pretender utilizar Serviço de Aplicações Autenticação com o tables ponto final, tem de configurar Serviço de Aplicações Autenticação no portal do Azure primeiro. Para mais informações, consulte o guia de configuração do fornecedor de identidade que pretende utilizar:

Cada mesa tem uma propriedade de acesso que pode usar para controlar o acesso à mesa. A amostra que se segue mostra uma tabela estática definida com a autenticação necessária.

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

A propriedade de acesso pode ter um de três valores:

Anónimo indica que a aplicação do cliente é permitida a leitura de dados sem autenticação.
Autenticado indica que o pedido do cliente deve enviar um sinal de autenticação válida com o pedido.
desativado indica que esta tabela está atualmente desativada.

Se a propriedade de acesso for indefinida, é permitido o acesso não autenticado.

Utilize reclamações de autenticação com as suas tabelas

Pode configurar várias reclamações que são solicitadas quando a autenticação é configurada. Estas alegações não estão normalmente disponíveis através do context.user objeto. No entanto, pode recuperá-los utilizando o context.user.getIdentity() método. O getIdentity() método devolve uma promessa que resolve um objeto. O objeto é entamido pelo método de autenticação (facebook, google, twitter, , microsoftaccount, ou aad.

Por exemplo, se configurar a autenticação da conta microsoft e solicitar a reclamação de endereços de e-mail, pode adicionar o endereço de e-mail ao registo com o seguinte controlador de tabela:

var azureMobileApps = require('azure-mobile-apps');

// Create a new table definition.
var table = azureMobileApps.table();

table.columns = {
    "emailAddress": "string",
    "text": "string",
    "complete": "boolean"
};
table.dynamicSchema = false;
table.access = 'authenticated';

/**
* Limit the context query to those records with the authenticated user email address
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function queryContextForEmail(context) {
    return context.user.getIdentity().then((data) => {
        context.query.where({ emailAddress: data.microsoftaccount.claims.emailaddress });
        return context.execute();
    });
}

/**
* Adds the email address from the claims to the context item - used for
* insert operations
* @param {Context} context the operation context
* @returns {Promise} context execution Promise
*/
function addEmailToContext(context) {
    return context.user.getIdentity().then((data) => {
        context.item.emailAddress = data.microsoftaccount.claims.emailaddress;
        return context.execute();
    });
}

// Configure specific code when the client does a request.
// READ: only return records that belong to the authenticated user.
table.read(queryContextForEmail);

// CREATE: add or overwrite the userId based on the authenticated user.
table.insert(addEmailToContext);

// UPDATE: only allow updating of records that belong to the authenticated user.
table.update(queryContextForEmail);

// DELETE: only allow deletion of records that belong to the authenticated user.
table.delete(queryContextForEmail);

module.exports = table;

Para ver quais as reclamações disponíveis, use um navegador web para ver o /.auth/me ponto final do seu site.

Desativar o acesso a operações específicas de tabela

Além de aparecer em cima da mesa, a propriedade de acesso pode ser usada para controlar operações individuais. Há quatro operações:

read é a operação RESTful GET sobre a mesa.
insert é a operação RESTful POST em cima da mesa.
update é a operação RESTful PATCH sobre a mesa.
delete é a operação RESTful DELETE em cima da mesa.

Por exemplo, é melhor fornecer uma tabela não autenticada apenas para leitura:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Read-only table. Only allow READ operations.
table.read.access = 'anonymous';
table.insert.access = 'disabled';
table.update.access = 'disabled';
table.delete.access = 'disabled';

module.exports = table;

Ajuste a consulta que é usada com operações de mesa

Um requisito comum para as operações de mesa é fornecer uma visão restrita dos dados. Por exemplo, pode fornecer uma tabela que esteja marcada com o ID do utilizador autenticado de modo a que só possa ler ou atualizar os seus próprios registos. A seguinte definição de tabela fornece esta funcionalidade:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define a static schema for the table.
table.columns = {
    "userId": "string",
    "text": "string",
    "complete": "boolean"
};
table.dynamicSchema = false;

// Require authentication for this table.
table.access = 'authenticated';

// Ensure that only records for the authenticated user are retrieved.
table.read(function (context) {
    context.query.where({ userId: context.user.id });
    return context.execute();
});

// When adding records, add or overwrite the userId with the authenticated user.
table.insert(function (context) {
    context.item.userId = context.user.id;
    return context.execute();
});

module.exports = table;

As operações que normalmente executam uma consulta têm uma propriedade de consulta que pode ajustar usando uma where cláusula. A propriedade de consulta é um objeto QueryJS que é usado para converter uma consulta OData para algo que o back end de dados pode processar. Para casos simples de igualdade (como o anterior), pode utilizar um mapa. Também pode adicionar cláusulas de SQL específicas:

context.query.where('myfield eq ?', 'value');

Configure uma exclusão suave em uma mesa

Uma eliminação suave não apaga registos. Em vez disso, marca-as como eliminadas dentro da base de dados, definindo a coluna eliminada como verdadeira. O Mobile Apps SDK remove automaticamente os registos eliminados de resultados, a menos que o Cliente Móvel SDK utilize IncludeDeleted(). Para configurar uma tabela para uma eliminação suave, coloque a softDelete propriedade no ficheiro de definição de tabela:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Turn on soft delete.
table.softDelete = true;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

Deve estabelecer um mecanismo para eliminar registos: uma aplicação do cliente, um WebJob, uma função Azure ou uma API personalizada.

Semeia a sua base de dados com dados

Quando está a criar uma nova aplicação, talvez queira semear uma tabela com dados. Pode fazê-lo dentro da definição de tabela Ficheiro JavaScript da seguinte forma:

var azureMobileApps = require('azure-mobile-apps');

var table = azureMobileApps.table();

// Define the columns within the table.
table.columns = {
    "text": "string",
    "complete": "boolean"
};
table.seed = [
    { text: 'Example 1', complete: false },
    { text: 'Example 2', complete: true }
];

// Turn off the dynamic schema.
table.dynamicSchema = false;

// Require authentication to access the table.
table.access = 'authenticated';

module.exports = table;

A sementeira de dados só acontece quando se utiliza o SDK de Aplicações Móveis para criar a tabela. Se a tabela já existir na base de dados, nenhum dado é injetado na tabela. Se o esquema dinâmico for ligado, o esquema é deduzido a partir dos dados semeados.

Recomendamos que ligue explicitamente para o tables.initialize() método para criar a tabela quando o serviço começar a funcionar.

Ativar o suporte da Swagger

Mobile Apps vem com suporte swagger incorporado. Para ativar o suporte da Swagger, instale primeiro o swagger-ui como dependência:

npm install --save swagger-ui

Em seguida, pode ativar o suporte da Swagger no construtor de Aplicações Móveis:

var mobile = azureMobileApps({ swagger: true });

Provavelmente só quer permitir o apoio da Swagger nas edições de desenvolvimento. Pode fazê-lo utilizando a definição da NODE_ENV aplicação:

var mobile = azureMobileApps({ swagger: process.env.NODE_ENV !== 'production' });

O swagger ponto final está localizado em http:// yoursite.azurewebsites.net/swagger. Pode aceder à UI swagger através do /swagger/ui ponto final. Se optar por exigir autenticação em toda a sua aplicação, a Swagger produz um erro. Para obter melhores resultados, opte por permitir pedidos não autenticados nas definições de Autenticação/Autorização Serviço de Aplicações do Azure e, em seguida, controlar a autenticação utilizando o table.access imóvel.

Também pode adicionar a opção Swagger ao seu ficheiro azureMobile.js se apenas quiser apoio da Swagger para desenvolver localmente.

Notificações push

As Aplicações Móveis integram-se com os Azure Notification Hubs para que possa enviar notificações push direcionadas para milhões de dispositivos em todas as principais plataformas. Ao utilizar os Centros de Notificações, pode enviar notificações push para iOS, Android e Windows dispositivos. Para saber mais sobre tudo o que pode fazer com os Centros de Notificação, consulte a visão geral dos Centros de Notificação.

Enviar notificações push

O seguinte código mostra como usar o push objeto para enviar uma notificação de transmissão push para dispositivos iOS registados:

// Create an APNS payload.
var payload = '{"aps": {"alert": "This is an APNS payload."}}';

// Only do the push if configured.
if (context.push) {
    // Send a push notification by using APNS.
    context.push.apns.send(null, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Ao criar um registo de impulso de modelo do cliente, pode, em vez disso, enviar uma mensagem de impulso de modelo para dispositivos em todas as plataformas suportadas. O seguinte código mostra como enviar uma notificação de modelo:

// Define the template payload.
var payload = '{"messageParam": "This is a template payload."}';

// Only do the push if configured.
if (context.push) {
    // Send a template notification.
    context.push.send(null, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Envie notificações push a um utilizador autenticado usando tags

Quando um utilizador autenticado se regista para notificações push, uma etiqueta de identificação do utilizador é automaticamente adicionada ao registo. Ao utilizar esta etiqueta, pode enviar notificações push a todos os dispositivos registados por um utilizador específico. O seguinte código obtém o SID do utilizador que está a fazer o pedido e envia uma notificação de impulso de modelo a cada registo do dispositivo para esse utilizador:

// Only do the push if configured.
if (context.push) {
    // Send a notification to the current user.
    context.push.send(context.user.id, payload, function (error) {
        if (error) {
            // Do something or log the error.
        }
    });
}

Quando estiver a registar notificações push de um cliente autenticado, certifique-se de que a autenticação está completa antes de tentar o registo.

APIs Personalizadas

Definir uma API personalizada

Além da API de Acesso a Dados através do ponto final, as /tables Aplicações Móveis podem fornecer cobertura API personalizada. As APIs personalizadas são definidas de forma semelhante às definições de tabela e podem aceder a todas as mesmas instalações, incluindo a autenticação.

Se pretender utilizar Serviço de Aplicações Autenticação com uma API personalizada, tem de configurar Serviço de Aplicações Autenticação no portal do Azure primeiro. Para mais informações, consulte o guia de configuração do fornecedor de identidade que pretende utilizar:

As APIs personalizadas são definidas da mesma forma que as Tabelas API:

Criar um diretório api .
Crie um ficheiro JavaScript de definição API no api diretório.
Utilize o método de importação para importar o api diretório.

Aqui está a definição de API do protótipo baseada na amostra de aplicações básicas que usamos anteriormente:

var express = require('express'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Import the custom API.
mobile.api.import('./api');

// Add the Mobile API so it is accessible as a Web API.
app.use(mobile);

// Start listening on HTTP
app.listen(process.env.PORT || 3000);

Vejamos um exemplo de API que devolve a data do servidor utilizando o Date.now() método. Aqui está o ficheiro api/date.js:

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    });
};

module.exports = api;

Cada parâmetro é um dos verbos RESTful padrão: GET, POST, PATCH ou DELETE. O método é uma função de middleware ExpressJS padrão que envia a saída necessária.

Requera autenticação para acesso a uma API personalizada

O Mobile Apps SDK implementa a autenticação da mesma forma tanto para as APIs de tables ponta e para as APIs personalizadas. Para adicionar autenticação à API desenvolvida na secção anterior, adicione um imóvel access :

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    });
};
// All methods must be authenticated.
api.access = 'authenticated';

module.exports = api;

Também pode especificar a autenticação em operações específicas:

var api = {
    get: function (req, res, next) {
        var date = { currentTime: Date.now() };
        res.status(200).type('application/json').send(date);
    }
};
// The GET methods must be authenticated.
api.get.access = 'authenticated';

module.exports = api;

O mesmo token que é usado para o tables ponto final deve ser usado para APIs personalizados que requerem autenticação.

Lidar com grandes uploads de ficheiros

O Mobile Apps SDK utiliza o middleware body-parser para aceitar e descodificar o conteúdo do corpo na sua submissão. Pode pré-configurar o body-parser para aceitar uploads de ficheiros maiores:

var express = require('express'),
    bodyParser = require('body-parser'),
    azureMobileApps = require('azure-mobile-apps');

var app = express(),
    mobile = azureMobileApps();

// Set up large body content handling.
app.use(bodyParser.json({ limit: '50mb' }));
app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));

// Import the custom API.
mobile.api.import('./api');

// Add the Mobile API so it is accessible as a Web API.
app.use(mobile);

// Start listening on HTTP.
app.listen(process.env.PORT || 3000);

O ficheiro está codificado antes da transmissão. Esta codificação aumenta o tamanho do upload real (e o tamanho que deve explicar).

Execute declarações de SQL personalizadas

O Mobile Apps SDK permite o acesso a todo o contexto através do objeto de pedido. Pode executar facilmente declarações de SQL para o fornecedor de dados definidos:

var api = {
    get: function (request, response, next) {
        // Check for parameters. If not there, pass on to a later API call.
        if (typeof request.params.completed === 'undefined')
            return next();

        // Define the query. Anything that the mssql
        // driver can handle is allowed.
        var query = {
            sql: 'UPDATE TodoItem SET complete=@completed',
            parameters: [{
                completed: request.params.completed
            }]
        };

        // Execute the query. The context for Mobile Apps is available through
        // request.azureMobile. The data object contains the configured data provider.
        request.azureMobile.data.execute(query)
        .then(function (results) {
            response.json(results);
        });
    }
};

api.get.access = 'authenticated';
module.exports = api;

Depurar

Depurar, diagnosticar e resolver problemas aplicações móveis

Serviço de Aplicações do Azure fornece várias técnicas de depuração e resolução de problemas para aplicações Node.js. Para começar a resolver problemas na resolução de problemas do seu Node.js Mobile Apps, consulte os seguintes artigos:

Node.js aplicações têm acesso a uma vasta gama de ferramentas de registo de diagnóstico. Internamente, o Node.js de Aplicações Móveis SDK utiliza o Winston para a sessão de diagnóstico. O registo é automaticamente ativado quando ativa o modo de depurar ou define a definição da MS_DebugMode aplicação de forma verdadeira no portal do Azure. Os registos gerados aparecem nos registos de diagnóstico do portal do Azure.