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 corporativos e de consumidores. Aqui estão alguns exemplos de cenários:

• Para enviar notificações sobre as novidades para milhões de pessoas com baixa latência.
• Para enviar cupons baseados na localização para segmentos de usuários interessados.
• Para enviar notificações de eventos para usuários ou grupos em aplicativos de mídia/esportes/finanças/jogos.
• Para enviar por push conteúdos promocionais para aplicativos com o objetivo de atrair e vender para os clientes.
• Para notificar os usuários sobre eventos empresariais, como novas mensagens e itens de trabalho.
• Para enviar códigos para Autenticação Multifator.

Links principais:

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

OBSERVAÇÃO: se você estiver vindo do uso do azure-sb pacote, consulte o migration guide to move from azure-sb to @azure/notification-hubs

Introdução

Ambientes com suporte no momento

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

Confira nossa política de suporte para mais detalhes.

Instalar o pacote

npm install @azure/notification-hubs

Pré-requisitos

• Uma assinatura do Azure
• Um recurso hubs de notificação de aplicativo.

Create 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. CLI do Azure
3. Bicep
4. Modelo do ARM

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

Importando o cliente

Esse 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 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 e escolha quais funções importar à medida que cada método é exposto individualmente. Essa abordagem usa as 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 usa o client como o primeiro parâmetro e o restante dos parâmetros permanecem inalterados.

Os seguintes subcaminhos são expostos:

• @azure/notification-hubs/api- O ponto de entrada main para o cliente por meio createClientContext de métodos de cliente e como getInstallation ousendNotification
• @azure/notification-hubs/models - Os modelos de Hubs de Notificação e os métodos de fábrica.

Em seguida, o snippet de código acima se torna o seguinte:

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

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 NotificationHubsClient cadeias de conexão de Assinatura de Acesso Compartilhado. Isso inclui os seguintes níveis de permissão: Escutar, Gerenciar, Enviar.

A escuta 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 o 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 por meio do "@azure/notification-hubs/api" subcaminho.

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

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

Principais conceitos

Depois que o NotificationHubClient tiver sido inicializado, os conceitos a seguir poderão ser explorados.

• Gerenciamento de Dispositivos por meio de Instalações e RegistroDescriptions
• Enviar notificações para dispositivos

Gerenciamento de dispositivo

O gerenciamento de dispositivos é um conceito fundamental para que os Hubs de Notificação possam armazenar o identificador exclusivo do PNS (Serviço de Notificação de Plataforma) nativo, como APNs ou Firebase, e metadados associados, como marcas usadas para enviar notificações por push para públicos. Isso é feito com duas APIs, a API de Instalação, que é o mecanismo mais recente e preferencial, e 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 o público-alvo. A API de instalações tem algumas vantagens em relação às APIs de Registro existentes das seguintes maneiras:

• API totalmente idempotente, portanto, chamar create na instalação, para que uma operação possa ser repetida sem preocupações com duplicações.
• Suporte para userId propriedades e installationId que podem ser usadas em expressões de marca, 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 por nome como uma marca para envio.
• Há suporte para atualizações parciais por meio do Patch Standard JSON, que permite adicionar marcas 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";
import { v4 as uuid } from "uuid";

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

// Create an installation for APNs
let installation = createAppleInstallation({
  installationId: uuid(), // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

installation = 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/models";
import { v4 as uuid } from "uuid";

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

// Create an installation for APNs
let installation = createAppleInstallation({
  installationId: uuid(), // Must be unique
  pushChannel: "00fc13adff785122b4ad28809a3420982341241421348097878e577c991de8f0", // PNS specific handle
  tags: ["likes_hockey", "likes_football"],
});

installation = await createOrUpdateInstallation(context, installation);

Uma atualização para uma instalação pode ser feita por meio do esquema de Patch JSON, como adicionar uma marca e uma 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/models";

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, assim como a instalação acima, com o identificador de dispositivo exclusivo do PNS e marcas 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 uma 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>");

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

registration = await client.createRegistration(registration);

console.log(`New Registration ID: ${registration.registrationId}`);

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

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

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

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

registration = await createRegistration(context, registration);

console.log(`New Registration ID: ${registration.registrationId}`);

Atualizações pode ser feito por meio do método , mas, ao contrário das updateRegistration instalações, não dá 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>";

let registration = await client.getRegistration(registrationId);

registration.tags.push("likes_sports");

registration = 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>";

let registration = await getRegistration(context, registrationId);

registration.tags.push("likes_sports");

registration = await updateRegistration(context, registration);

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

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

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

const registrations = await 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 dão suporte ao envio de notificações para dispositivos usando diretamente o identificador exclusivo fornecido pelo PNS, usando marcas para envio de audiência ou uma transmissão geral para todos os dispositivos. Usar o SKU Standard 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 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 telemetria de notificação por meio do getNotificationOutcomeDetails método .

Para fins de depuração, as enableTestSend opções podem ser definidas para true as quais os comentários imediatos do PNS sobre o sendNotification método, no entanto, não têm suporte em cenários de produção. Não há suporte para isso 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çã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 nenhuma suposição sobre quais campos estão disponíveis para cada PNS.

// Using the class-based approach
import { createAppleNotificationBody } from "@azure/notification-hubs";

// Using the modular approach
import { createAppleNotification, createAppleNotificationBody } from "@azure/notification-hubs/models";

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
})

const result = await sendNotification(context, notification);

Envio de Difusão

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

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

const context = createClientContext(connectionString, hubName);

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

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

const result = await client.sendNotification(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, sendNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext(connectionString, hubName);

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

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

const result = await sendNotification(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 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(connectionString, hubName);

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, sendDirectNotification } from "@azure/notification-hubs/api";
import { createAppleNotification } from "@azure/notification-hubs/models";

const context = createClientContext(connectionString, hubName);

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 direcionar um único dispositivo, um usuário pode direcionar vários dispositivos usando marcas. Essas marcas podem ser fornecidas como uma lista de marcas, que, em seguida, cria uma expressão de marca para corresponder a dispositivos registrados ou por meio de uma expressão de marca que pode usar a lógica booliana para direcionar o público-alvo certo. Para obter mais informações sobre marcas e expressões de marcas, consulte Roteamento e expressões de marca.

Se você quiser criar uma expressão de marca de uma matriz de marcas, há um Construtor de Expressões de Marca 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 marca" das marcas.

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

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

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

console.log(tagExpression);
// likes_football||likes_hockey

Mensagens de expressão de marca 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/models";

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 scheduleBroadcastNotification método para enviar para dispositivos com marcas ou uma transmissão geral. 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/models";

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 React Native

React Native atualmente 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.

import 'url-search-params-polyfill';

Também precisamos fornecer polyfill para TextEncoder API e API de iterador assíncrono. Confira nosso exemplo de React Native com a 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.

Há suporte para envio de teste no sendNotification método com a opção enableTestSend :

// Using the client
const result = await client.sendNotification(notification, { tags, enableTestSend: true });

// Using the modular approach
const result = await sendNotification(context, notification, { tags, enableTestSend: true });

Registro em log

A habilitação do 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 log pode ser habilitado no runtime chamando setLogLevel em @azure/logger:

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

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

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
  • instalação Create ou atualização
  • Atualizar instalação
• API de registro
  • registro de Create
  • Create ou atualizar o registro
  • Atualizar registro
  • Listar registros
  • Listar registro por marca

Operações de envio:

• Envio de Difusão
• Envio Direto
• Lista De Envio de Público com Marcas
• Enviar público-alvo com expressão de marca
• Envio de Transmissão Agendado
• Envio agendado

Operações de gerenciamento:

• Exportar registros
• Importar registros

Contribuição

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

Os testes deste módulo são uma combinação 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. rush update
2. rush build -t @azure/notification-hubs
3. Create 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. rushx test.

Exiba nossa pasta de testes para obter mais detalhes.

Projetos relacionados

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