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

Os Hubs de Notificação do Azure fornecem um mecanismo de push escalonado 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 empresariais e de consumo. Aqui estão alguns exemplos de cenários:

• 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.
• Empurre conteúdos promocionais 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.

Ligações principais:

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

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

Como Começar

Ambientes atualmente suportados

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

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

Instale o pacote

npm install @azure/notification-hubs

Pré-requisitos

• Uma Subscrição do Azure
• Um recurso de Hubs de Notificação de Aplicativo .

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. da CLI do Azure
3. Bíceps
4. Modelo ARM

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

Importando o cliente

Este SDK para JavaScript oferece duas maneiras de interagir com os Hubs de Notificação do Azure, seja 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 subpath-exports 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 árvores e tamanhos de pacotes menores que o desenvolvedor pode aproveitar.

Observe que a criação de um cliente é exposta através do "@azure/notification-hubs/api" subcaminho e todos os métodos de cliente são expostos através do "@azure/notification-hubs/api" subcaminho. Cada função exportada toma o client como o primeiro parâmetro e o resto dos parâmetros permanecem inalterados.

Os seguintes subcaminhos são expostos:

• @azure/notification-hubs/api - O principal ponto de entrada para o cliente através createClientContext e métodos do cliente, tais 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 às cadeias de conexão de Assinatura de NotificationHubsClient Acesso Compartilhado. Isso inclui os seguintes níveis de permissão: Ouvir, Gerenciar, Enviar.

O Listen permite que um cliente se registe através da API de Registo 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 createClientContext pode ser importado através do "@azure/notification-hubs/api" subcaminho.

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

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

Conceitos-chave

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

• Gestão de Dispositivos através de Instalações e RegistoDescrições
• Enviar notificações para dispositivos

Gestão 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 tags usadas para enviar notificações por push para audiências. 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 nativa e mais recente para o gerenciamento de dispositivos que contém propriedades adicionais, como um ID de instalação e um ID de usuário, que podem ser usados para enviar para audiências. A API de instalações tem algumas vantagens sobre as APIs de registro existentes das seguintes maneiras:

• API totalmente idempotente, chamando criar na instalação, para que uma operação possa ser repetida sem se preocupar 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 através do JSON Patch Standard, que permite adicionar tags e alterar outros dados sem ter que consultar primeiro a instalação.

As instalações podem ser criadas através 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 para uma instalação pode ser feita por meio do esquema de patch JSON, 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 método com sua getInstallation 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 Inscrições

Um registro é associado a um PNS assim como a instalação acima, com o identificador de dispositivo exclusivo do PNS e 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 para preencher 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 através 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 através do método, mas, ao contrário das updateRegistration instalações, não suporta 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 os registros com uma condição, ou por tags. Os registros podem ser consultados usando o listRegistrationsmétodo e listRegistrationsByChannellistRegistrationsByTag . Todos os métodos suportam limitação através da top opção e suportam 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));
  }
}

Enviar Operações

Os Hubs de Notificação suportam o envio de notificações para dispositivos diretamente usando o identificador exclusivo fornecido pelo PNS, usando tags para envio de audiência ou uma transmissão geral para todos os dispositivos. Usando o SKU padrão e acima, 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 Acompanhamento e uma ID de Correlação, que podem ser usadas para casos de suporte dos Hubs de Notificação. Com o SKU padrão e acima, um ID de notificação também é retornado que pode ser usado para obter telemetria de notificação através do getNotificationOutcomeDetails método.

Para fins de depuração, as enableTestSend opções podem ser definidas para true obter feedback imediato do PNS sobre o método, no entanto, não é suportado sendNotification em cenários de produção. Isso não é suportado nos métodos de envio agendados.

Cadeias de caracteres JSON ou XML brutas podem ser enviadas para os métodos de envio ou envio agendado, ou os construtores de notificações podem ser usados, o que ajuda a construir mensagens por PNS, como APNs, Firebase, Baidu, ADM e WNS. Esses construtores construirão o formato de mensagem nativa 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,
});

Transmissão Enviar

Os Hubs de Notificação podem ser usados para enviar notificações para todos os dispositivos registrados por plataforma usando o envio de transmissão através 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

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 atingir o público certo. Para obter mais informações sobre tags e expressões de tags, consulte Roteamento e expressões de tag.

Se você deseja criar uma expressão de tag a partir de uma matriz de tags, há um Tag Expression Builder 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 "ou tag" 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 SKU padrão e acima usando o scheduleNotification método para enviar para dispositivos com tags ou uma transmissão geral com scheduleBroadcastNotification. Isso retorna um ID de notificação que pode ser usado para cancelar, se necessário, através 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}`);

Solução de problemas

Suporte nativo do React

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 iterador assíncrono. Consulte a nossa amostra 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 no Guia de Hubs de Notificação do Azure.

O envio de teste é suportado sendNotification nos 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,
});

Exploração Florestal

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 tempo de execução chamando setLogLevel no @azure/logger:

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

setLogLevel("info");

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

Próximos passos

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

Gestão de Dispositivos:

• API de instalações
  • Criar ou atualizar a instalação
  • Instalação da atualização
• API de registo
  • Criar Inscriçõess
  • Criar ou atualizar registro
  • Atualizar Registo
  • Listar Inscrições
  • Listar registro por tag

Operações de envio:

• Transmissão Enviar
• Envio Direto
• Público Enviar com lista de tags
• Público Enviar com expressão de tag
• Envio de transmissão agendada
• Envio agendado

Operações de Gestão:

• Registos de Exportação
• Registos de Importação

Contributing

Se você quiser contribuir para esta 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 ao vivo 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 estes conteúdos 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 a nossa pasta de testes para obter mais detalhes.

Projetos relacionados

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