SDK dos Hubs de Notificação do Azure para JavaScript

Os Hubs de Notificação do Azure fornecem um mecanismo de push dimensionado que permite enviar notificações para qualquer plataforma (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows etc.) de qualquer back-end (nuvem ou local). Os Hubs de Notificação funcionam bem para cenários corporativos e de consumidor. Eis alguns cenários de exemplo:

• Envie notificações de notícias de última hora para milhões com baixa latência.
• Envie cupons baseados em localização para segmentos de usuários interessados.
• Envie notificações relacionadas a eventos para usuários ou grupos para aplicativos de mídia/esportes/finanças/jogos.
• Envie conteúdo promocional para aplicativos para envolver e comercializar para os clientes.
• Notifique os usuários sobre eventos corporativos, como novas mensagens e itens de trabalho.
• Envie códigos para autenticação multifator.

Links de chave:

• código-fonte
• Pacote (npm)
• Documentação do produto
• Amostras

NOTA: Se você estiver usando o azure-sb pacote, consulte o migration guide to move from azure-sb to @azure/notification-hubs

Como começar

Ambientes com suporte no momento

• Versões LTS do Node.js
• Versões mais recentes do Safari, Chrome, Edge e Firefox.

Consulte nossa política de suporte para obter mais detalhes.

Instalar o pacote

npm install @azure/notification-hubs

Pré-requisitos

• Uma assinatura do Azure
• Um recurso dos Hubs de Notificação de Aplicativos .

Criar um recurso dos Hubs de Notificação do Azure

Um Hub de Notificação do Azure pode ser criado usando os seguintes métodos:

1. Portal do Azure
2. Azure CLI
3. Bíceps
4. Modelo do ARM

Depois de criado, o Hub de Notificação pode ser configurado usando o Portal do Azure ou a CLI.

Importando o cliente

Este SDK para JavaScript oferece duas maneiras de interagir com os Hubs de Notificação do Azure, por meio da abordagem baseada em classe ou com uma abordagem de design modular. A abordagem baseada em classe é consistente em todos os pacotes para criar um cliente e, em seguida, interagir com os métodos no cliente.

import { NotificationHubsClient, createAppleInstallation } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installation = createAppleInstallation({
  installationId: "<installation-id>",
  pushChannel: "<push-channel>",
  tags: ["likes_javascript"],
});

const result = await client.createOrUpdateInstallation(installation);

A abordagem modular permite que o desenvolvedor escolha quais funções importar, pois cada método é exposto individualmente. Essa abordagem usa exportações de subcaminho com ES-Modules para expor os métodos por meio de importações diretas. Com as exportações individuais, isso cria uma melhor experiência de agitação de árvore e tamanhos de pacote menores que o desenvolvedor pode aproveitar.

Observe que a criação de um cliente é exposta por meio do "@azure/notification-hubs/api" subcaminho e todos os métodos do cliente são expostos por meio do "@azure/notification-hubs/api" subcaminho. Cada função exportada recebe o client como o primeiro parâmetro e o restante dos parâmetros permanece inalterado.

Os seguintes subcaminhos são expostos:

• @azure/notification-hubs/api - O principal ponto de entrada para o cliente via createClientContext e métodos de cliente, como getInstallation ou sendNotification
• @azure/notification-hubs/models - Os modelos e métodos de fábrica dos Hubs de Notificação.

O trecho de código acima se torna o seguinte:

import { createClientContext, createOrUpdateInstallation } from "@azure/notification-hubs/api";
import { createAppleInstallation } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const installation = createAppleInstallation({
  installationId: "<installation-id>",
  pushChannel: "<push-channel>",
  tags: ["likes_javascript"],
});

const result = await createOrUpdateInstallation(context, installation);

Autenticar o cliente

A interação com um Hub de Notificação do Azure começa com o que dá suporte a cadeias de conexão de Assinatura deNotificationHubsClient Acesso Compartilhado. Isso inclui os seguintes níveis de permissão: Ouvir, Gerenciar, Enviar.

O Listen permite que um cliente se registre por meio da API de Registro e Instalações. Enviar permite que o cliente envie notificações para dispositivos usando as APIs de envio. Por fim, Gerenciar permite que o usuário faça o gerenciamento de Registro e Instalação, como consultas.

Um novo NotificationHubsClient cliente pode ser criado usando o construtor com a cadeia de conexão e o nome do Hub de Notificação.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

Usando a abordagem modular, o pode createClientContext ser importado por meio do "@azure/notification-hubs/api" subcaminho.

import { createClientContext } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

Conceitos principais

NotificationHubClient Uma vez inicializado, os seguintes conceitos podem ser explorados.

• Gerenciamento de dispositivos por meio de instalações e registroDescrições
• Enviar notificações para dispositivos

Gerenciamento de dispositivos

O gerenciamento de dispositivos é um conceito central para os Hubs de Notificação para poder armazenar o identificador exclusivo do Serviço de Notificação de Plataforma (PNS) nativo, como APNs ou Firebase, e metadados associados, como marcas usadas para enviar notificações por push para públicos-alvo. Isso é feito com duas APIs, a API de instalação, que é o mecanismo mais recente e preferido, e os registros.

API de instalações

As instalações são uma abordagem JSON mais recente e nativa para o gerenciamento de dispositivos que contém propriedades adicionais, como uma ID de instalação e uma ID de usuário, que podem ser usadas para enviar para públicos-alvo. A API de instalações tem algumas vantagens sobre as APIs de registro existentes das seguintes maneiras:

• API totalmente idempotente, chamando create na instalação, para que uma operação possa ser repetida sem preocupações com duplicações.
• Suporte para userId e installationId propriedades que podem ser usadas em expressões de tag como $InstallationId:{myInstallId} e $UserId:{bob@contoso.com}.
• Os modelos agora fazem parte da instalação em vez de um registro separado e podem ser referenciados pelo nome como uma tag para envio.
• As atualizações parciais são suportadas por meio do JSON Patch Standard, que permite adicionar tags e alterar outros dados sem precisar primeiro consultar a instalação.

As instalações podem ser criadas por meio do createOrUpdateInstallation método, como o seguinte:

import { NotificationHubsClient, createAppleInstallation } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

// Create an installation for APNs
const installation = createAppleInstallation({
  installationId: "0d8ab095-c449-493f-9195-17e4917806c4", // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

const response = await client.createOrUpdateInstallation(installation);

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, createOrUpdateInstallation } from "@azure/notification-hubs/api";
import { createAppleInstallation } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

// Create an installation for APNs
const installation = createAppleInstallation({
  installationId: "0d8ab095-c449-493f-9195-17e4917806c4", // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

const response = await createOrUpdateInstallation(context, installation);

Uma atualização em uma instalação pode ser feita por meio do esquema JSON Patch, como adicionar uma tag e um ID de usuário usando o updateInstallation método.

import { NotificationHubsClient, JsonPatch } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";
const updates: JsonPatch[] = [
  { op: "add", path: "/tags", value: "likes_baseball" },
  { op: "add", path: "/userId", value: "bob@contoso.com" },
];

const installation = await client.updateInstallation(installationId, updates);

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, updateInstallation } from "@azure/notification-hubs/api";
import { JsonPatch } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const updates: JsonPatch[] = [
  { op: "add", path: "/tags", value: "likes_baseball" },
  { op: "add", path: "/userId", value: "bob@contoso.com" },
];

const installation = await updateInstallation(context, installationId, updates);

Para recuperar uma instalação existente, use o getInstallation método com sua ID de instalação exclusiva existente.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, getInstallation } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const installationId = "<unique installation ID>";

const installation = getInstallation(context, installationId);

API de registros

Um registro é associado a um PNS da mesma forma que a instalação acima, com o identificador exclusivo do dispositivo do PNS e as tags associadas. Os registros de modelos são uma maneira de criar modelos de corpo predefinidos que podem ser personalizados no momento do envio com propriedades a serem preenchidas para a mensagem. Para obter mais informações sobre modelos, consulte Documentação de modelos.

Uma instalação pode ser criada de duas maneiras, primeiro obtendo um ID de registro do servidor usando getInstallationId e, em seguida createOrUpdateRegistration , ou por meio do createRegistration método.

import {
  NotificationHubsClient,
  createAppleRegistrationDescription,
} from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const registration = createAppleRegistrationDescription({
  deviceToken: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0",
  tags: ["likes_hockey", "likes_football"],
});
const updatedRegistration = await client.createRegistration(registration);

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, createRegistration } from "@azure/notification-hubs/api";
import { createAppleRegistrationDescription } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const registration = createAppleRegistrationDescription({
  deviceToken: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0",
  tags: ["likes_hockey", "likes_football"],
});

const updatedRegistration = await createRegistration(context, registration);

As atualizações podem ser feitas por meio do método, mas, ao contrário das updateRegistration instalações, não oferece suporte a atualizações incrementais. A consulta de um registro existente pode ser feita com o getRegistration método.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const registrationId = "<unique Registration ID>";

const registration = await client.getRegistration(registrationId);

if (registration.tags) {
  registration.tags.push("likes_sports");
} else {
  registration.tags = ["likes_sports"];
}

const updatedRegistration = await client.updateRegistration(registration);

Usando a abordagem modular, o código seria o seguinte:

import {
  createClientContext,
  getRegistration,
  updateRegistration,
} from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const registrationId = "<unique Registration ID>";

const registration = await getRegistration(context, registrationId);

if (registration.tags) {
  registration.tags.push("likes_sports");
} else {
  registration.tags = ["likes_sports"];
}

const updatedRegistration = await updateRegistration(context, registration);

Os registros, ao contrário das instalações, podem ser consultados para obter todos os registros, combinando registros com uma condição ou por tags. Os registros podem ser consultados usando o método e listRegistrationsByChannellistRegistrationsByTag .listRegistrations Todos os métodos dão suporte à limitação por meio da top opção e dão suporte à paginação assíncrona.

import { NotificationHubsClient } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const registrations = client.listRegistrationsByTag("likes_hockey");

let page = 0;
for await (const pages of registrations.byPage()) {
  console.log(`Page number ${page++}`);
  for (const item of pages) {
    console.log(JSON.stringify(item, null, 2));
  }
}

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, listRegistrationsByTag } from "@azure/notification-hubs/api";

const context = createClientContext("<connection string>", "<hub name>");

const registrations = await listRegistrationsByTag(context, "likes_hockey");

let page = 0;
for await (const pages of registrations.byPage()) {
  console.log(`Page number ${page++}`);
  for (const item of pages) {
    console.log(JSON.stringify(item, null, 2));
  }
}

Operações de envio

Os Hubs de Notificação dão suporte ao envio de notificações para dispositivos diretamente usando o identificador exclusivo fornecido pelo PNS, usando marcas para envio de audiência ou uma transmissão geral para todos os dispositivos. Usando o SKU Standard e superior, o envio agendado permite que o usuário agende notificações com até sete dias de antecedência. Todas as operações de envio retornam uma ID de Rastreamento e uma ID de Correlação que podem ser usadas para casos de suporte dos Hubs de Notificação. Com o SKU Standard e superior, uma ID de Notificação também é retornada, que pode ser usada para obter a telemetria de notificação por meio do getNotificationOutcomeDetails método.

Para fins de depuração, as enableTestSend opções podem ser definidas para true obter comentários imediatos do PNS sobre o sendNotification método, no entanto, não há suporte em cenários de produção. Não há suporte para isso nos métodos de envio agendados.

Strings JSON ou XML brutas podem ser enviadas para os métodos de envio ou envio agendado, ou os construtores de notificação podem ser usados, o que ajuda a construir mensagens por PNS, como APNs, Firebase, Baidu, ADM e WNS. Esses construtores criarão o formato de mensagem nativo para que não haja adivinhação sobre quais campos estão disponíveis para cada PNS.

import { createAppleNotificationBody, createAppleNotification } from "@azure/notification-hubs";

const apnsBody = createAppleNotificationBody({
  alert: {
    title: "Notification Title",
    subtitle: "Notification Subtitle",
    body: "Notification body goes here",
  },
  sound: "default",
  interruptionLevel: "time-sensitive",
});

// Send the message using the modular approach
const notification = createAppleNotification({
  body: apnsBody,
});

Envio de transmissão

Os Hubs de Notificação podem ser usados para enviar notificações para todos os dispositivos registrados por plataforma usando o envio de difusão por meio do sendBroadcastNotification método.

import { NotificationHubsClient, createAppleNotification } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendBroadcastNotification(message);

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, sendBroadcastNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendBroadcastNotification(context, message);

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Envio direto

Para enviar diretamente um dispositivo, o usuário pode enviar usando o identificador exclusivo fornecido pela plataforma, como o token de dispositivo APNs, chamando o sendNotification método com um deviceHandle parâmetro.

import { NotificationHubsClient, createAppleNotification } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const deviceHandle = "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(message, { deviceHandle });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const deviceHandle = "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, message, { deviceHandle });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Envio de público-alvo

Além de segmentar um único dispositivo, um usuário pode segmentar vários dispositivos usando tags. Essas tags podem ser fornecidas como uma lista de tags, que cria uma expressão de tag para corresponder aos dispositivos registrados, ou por meio de uma expressão de tag que pode usar a lógica booleana para segmentar o público certo. Para obter mais informações sobre tags e expressões de tags, consulte Roteamento e expressões de tags.

Se você deseja criar uma expressão de tag a partir de uma matriz de tags, há um Construtor de Expressões de Tag disponível com o createTagExpression método que é exposto na importação de nível superior ou @azure/notification-hubs/models/tagExpressionBuilder importação modular que cria uma "expressão de tag ou" a partir das tags.

import { createTagExpression } from "@azure/notification-hubs";

const tags = ["likes_football", "likes_hockey"];
const tagExpression = createTagExpression(tags);

console.log(tagExpression);

As mensagens de expressão de tag podem ser enviadas usando o seguinte código:

import { NotificationHubsClient, createAppleNotification } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(notification, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, notification, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Only available in Standard SKU and above
if (result.notificationId) {
  console.log(`Notification ID: ${result.notificationId}`);
}

Envio agendado

As notificações por push podem ser agendadas com até sete dias de antecedência com namespaces de SKU Standard e superiores usando o scheduleNotification método para enviar para dispositivos com marcas ou uma transmissão geral com scheduleBroadcastNotification. Isso retorna uma ID de notificação que pode ser usada para cancelar, se necessário, por meio do cancelScheduledNotification método.

import { NotificationHubsClient, createAppleNotification } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

// Schedule 8 hours from now
const scheduledTime = new Date(Date.now() + 8 * 60 * 60 * 1000);

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.scheduleNotification(scheduledTime, message, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Can be used to cancel via the cancelScheduledSend method
console.log(`Notification ID: ${result.notificationId}`);

Usando a abordagem modular, o código seria o seguinte:

import { createClientContext, scheduleNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

// Schedule 8 hours from now
const scheduledTime = new Date(Date.now() + 8 * 60 * 60 * 1000);

const message = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await scheduleNotification(context, scheduledTime, message, { tagExpression });

console.log(`Tracking ID: ${result.trackingId}`);
console.log(`Correlation ID: ${result.correlationId}`);

// Can be used to cancel via the cancelScheduledSend method
console.log(`Notification ID: ${result.notificationId}`);

Resolução de problemas

Suporte React Native

Atualmente, o React Native não tem suporte para [URLSearchParams], que é usado pelo SDK dos Hubs de Notificação do Azure. Para usar o SDK no React Native, você precisará instalar o url-search-params-polyfill pacote e importá-lo antes de usar o SDK.

Também precisamos fornecer polyfill para TextEncoder API e API de iterador assíncrono. Consulte nosso exemplo React Native com Expo para obter mais detalhes.

Diagnosticar notificações descartadas

Os Hubs de Notificação do Azure têm um guia completo para solucionar problemas com notificações descartadas no Guia Diagnosticar notificações descartadas nos Hubs de Notificação do Azure.

O envio de teste é suportado nos sendNotification métodos e sendBroadcastNotification com a enableTestSend opção:

import { NotificationHubsClient, createAppleNotification } from "@azure/notification-hubs";

const client = new NotificationHubsClient("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await client.sendNotification(notification, {
  tagExpression,
  enableTestSend: true,
});

import { createClientContext, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs";

const context = createClientContext("<connection string>", "<hub name>");

const tagExpression = "likes_hockey && likes_football";
const messageBody = `{ "aps" : { "alert" : "Hello" } }`;

const notification = createAppleNotification({
  body: messageBody,
  headers: {
    "apns-priority": "10",
    "apns-push-type": "alert",
  },
});

const result = await sendNotification(context, notification, {
  tagExpression,
  enableTestSend: true,
});

Registro em log

Habilitar o registro em log pode ajudar a descobrir informações úteis sobre falhas. Para ver um log de solicitações e respostas HTTP, defina a variável de ambiente AZURE_LOG_LEVEL como info. Como alternativa, o registro em log pode ser habilitado em runtime chamando setLogLevel no @azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

Para obter instruções mais detalhadas sobre como habilitar logs, você pode examinar os documentos do pacote de @azure/agente.

Próximas etapas

Os exemplos a seguir mostram as várias maneiras de interagir com os Hubs de Notificação do Azure:

Gerenciamento de dispositivos:

• API de instalações
  • Criar ou atualizar instalação
  • Instalação da atualização
• API de registro
  • Criar registros
  • Criar ou atualizar registro
  • Atualizar Registro
  • Listar registros
  • Registro de lista por tag

Operações de envio:

• Envio de transmissão
• Envio direto
• Envio de público-alvo com lista de tags
• Envio de público-alvo com expressão de tag
• Envio de transmissão agendada
• Envio agendado

Operações de gerenciamento:

• Registros de exportação
• Registros de importação

Contributing

Se você quiser contribuir com essa biblioteca, leia o guia de contribuição para saber mais sobre como criar e testar o código.

Os testes deste módulo são uma mistura de testes dinâmicos e de unidade, que exigem que você tenha uma instância dos Hubs de Notificação do Azure. Para executar os testes, você precisará executar:

1. pnpm install
2. pnpm build --filter @azure/notification-hubs...
3. Crie um arquivo .env com este conteúdo na sdk\notificationhubs\notification-hubs pasta: NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instanceNOTIFICATION_HUB_NAME=Notification Hub name
4. cd sdk\notificationhubs\notification-hubs
5. npm run test.

Veja nossa pasta de testes para obter mais detalhes.

Projetos relacionados

• do SDK do Microsoft Azure para JavaScript
• Hubs de Notificação do Azure