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

Os Hubs de Notificação do Azure fornecem um motor push de escalamento horizontal que lhe permite enviar notificações para qualquer plataforma (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows, etc.) a partir de qualquer back-end (cloud ou no local). Os Hubs de Notificação funcionam bem para cenários empresariais e de consumidor. Eis alguns exemplos de cenários:

• Enviar notificações de notícias de última hora para milhões com baixa latência.
• Enviar cupões com base na localização a segmentos de utilizadores interessados.
• Enviar notificações relacionadas com eventos a utilizadores ou grupos para aplicações de multimédia/desporto/finanças/jogos.
• Enviar conteúdos promocionais às aplicações, para interação e comercialização junto dos clientes.
• Notifique os utilizadores de eventos empresariais, como novas mensagens e itens de trabalho.
• Enviar códigos para a autenticação multifator.

Ligações principais:

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

NOTA: se estiver a utilizar o azure-sb pacote, consulte a secção migration guide to move from azure-sb to @azure/notification-hubs

Introdução

Ambientes atualmente suportados

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

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

Instalar o pacote

npm install @azure/notification-hubs

Pré-requisitos

• Uma Subscrição do Azure
• Um recurso dos Hubs de Notificação de Aplicações .

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

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

1. Portal do Azure
2. CLI do Azure
3. Bicep
4. Modelo do ARM

Depois de criado, o Notification Hub pode ser configurado com o Portal do Azure ou a CLI do Azure.

Importar o Cliente

Este SDK para JavaScript oferece duas formas de interagir com os Hubs de Notificação do Azure, seja através da abordagem baseada na classe ou com uma abordagem de design modular. A abordagem baseada na 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 ao programador escolher as funções a importar à medida que cada método é exposto individualmente. Esta abordagem utiliza subpath-exports com ES-Modules para expor os métodos através de importações diretas. Com as exportações individuais, isto cria uma melhor experiência de agitação de árvores e tamanhos de pacotes mais pequenos dos quais o programador pode tirar partido.

Tenha em atenção 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 assume o client como primeiro parâmetro e os restantes parâmetros permanecem inalterados.

Os seguintes subcaminhos são expostos:

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

Em seguida, o fragmento de código acima torna-se 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 suporta cadeias NotificationHubsClient de ligação de Assinatura de Acesso Partilhado. Isto inclui os seguintes níveis de permissão: Escutar, Gerir, Enviar.

O serviço de escuta permite que um cliente se registe através da API de Registo e Instalações. O envio permite que o cliente envie notificações para dispositivos com as APIs de envio. Por fim, Gerir permite que o utilizador faça a gestão de Registo e Instalação, como consultas.

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

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

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

Com 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

Depois de inicializado NotificationHubClient , os seguintes conceitos podem ser explorados.

• Gestão de Dispositivos através de Instalações e RegistrationDescriptions
• Enviar Notificações para Dispositivos

Gestão de Dispositivos

A gestão de dispositivos é um conceito fundamental para os Hubs de Notificação para poder armazenar o identificador exclusivo do PNS (Platform Notification Service) nativo, como APNs ou Firebase, e metadados associados, como etiquetas utilizadas para enviar notificações push para audiências. Isto é feito com duas APIs, a API de Instalação, que é o mecanismo mais recente e preferencial, e os Registos.

API de Instalações

As instalações são uma abordagem JSON mais recente e nativa para a gestão de dispositivos que contém propriedades adicionais, como um ID de instalação e ID de utilizador, que podem ser utilizados para enviar para audiências. A API de instalações tem algumas vantagens sobre as APIs de Registo existentes das seguintes formas:

• API totalmente idempotente para que a chamada crie na instalação, para que uma operação possa ser repetida sem se preocupar com duplicações.
• Suporte para userIdinstallationId e propriedades que podem ser utilizadas em expressões de etiquetas como $InstallationId:{myInstallId} e $UserId:{bob@contoso.com}.
• Os modelos fazem agora parte da instalação em vez de um registo separado e podem ser referenciados pelo nome como uma etiqueta para envio.
• As atualizações parciais são suportadas através do Patch Standard JSON, que permite adicionar etiquetas e alterar outros dados sem ter de 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";
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);

Com 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 efetuada através do esquema de Patch JSON, como adicionar uma etiqueta e um ID de utilizador com 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);

Com 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 obter uma instalação existente, utilize o método com o getInstallation ID de instalação exclusivo 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);

Com 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 Registos

Um registo está associado a um PNS tal como a instalação acima, com o identificador de dispositivo exclusivo do PNS e etiquetas associadas. Os registos de modelos são uma forma de criar modelos de corpo predefinidos que podem ser personalizados no momento do envio com propriedades para preencher para a mensagem. Para obter mais informações sobre modelos, veja a Documentação de modelos.

Uma instalação pode ser criada de uma de duas formas, primeiro ao obter um ID de registo do servidor com 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>");

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

registration = await client.createRegistration(registration);

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

Com 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 através do updateRegistration método, mas, ao contrário das instalações, não suporta atualizações incrementais. A consulta de um registo 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);

Com 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 registos, ao contrário das instalações, podem ser consultados para obter todos os registos, registos correspondentes a uma condição ou por etiquetas. Os registos podem ser consultados com o listRegistrationsmétodo e listRegistrationsByTaglistRegistrationsByChannel . Todos os métodos suportam a limitação através da opção top e suportam a 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));
  }
}

Com 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 Notification Hubs suportam o envio de notificações para dispositivos diretamente utilizando o identificador PNS exclusivo fornecido, utilizando etiquetas para envio de audiência ou uma difusão geral para todos os dispositivos. Com o SKU Standard e superior, o envio agendado permite ao utilizador agendar notificações com um máximo de sete dias de antecedência. Todas as operações de envio devolvem um ID de Controlo e um ID de Correlação que podem ser utilizados para casos de suporte dos Hubs de Notificação. Com o SKU Standard e superior, também é devolvido um ID de Notificação que pode ser utilizado para obter telemetria de notificação através do getNotificationOutcomeDetails método .

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

As cadeias XML ou JSON não processadas podem ser enviadas para os métodos de envio ou envio agendado ou os construtores de notificações podem ser utilizados, o que ajuda a construir mensagens por PNS, como APNs, Firebase, Baidu, ADM e WNS. Estes construtores irão criar o formato de mensagem nativo para que não existam estimativas sobre que 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 Notification Hubs podem ser utilizados para enviar notificações para todos os dispositivos registados por plataforma através do envio de difusão através 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}`);
}

Com 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 utilizador pode enviar através do 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(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}`);
}

Com 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 da Audiência

Além de direcionar um único dispositivo, um utilizador pode direcionar vários dispositivos através de etiquetas. Estas etiquetas podem ser fornecidas como uma lista de etiquetas, o que cria uma expressão de etiqueta para corresponder a dispositivos registados ou através de uma expressão de etiqueta que, em seguida, pode utilizar a lógica booleana para direcionar a audiência certa. Para obter mais informações sobre expressões de etiquetas e etiquetas, veja Encaminhamento e Expressões de Etiquetas.

Se quiser criar uma expressão de etiqueta a partir de uma matriz de etiquetas, existe um Construtor de Expressões de Etiquetas disponível com o createTagExpression método que é exposto ao nível superior de importação ou @azure/notification-hubs/models/tagExpressionBuilder importação modular que cria uma "expressão ou expressão de etiqueta" a partir das etiquetas.

// 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

As mensagens de expressão de etiqueta podem ser enviadas com 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}`);
}

Com 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 push podem ser agendadas com um máximo de sete dias de antecedência com espaços de nomes de SKU Standard e superiores através do scheduleBroadcastNotification método para enviar para dispositivos com etiquetas ou uma difusão geral. Isto devolve um ID de notificação que pode ser utilizado 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}`);

Com 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}`);

Resolução de problemas

Suporte React Native

React Native atualmente não tem suporte para [URLSearchParams] que é utilizado pelo SDK dos Hubs de Notificação do Azure. Para utilizar o SDK no React Native, terá de instalar o url-search-params-polyfill pacote e importá-lo antes de utilizar o SDK.

import 'url-search-params-polyfill';

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

Diagnosticar Notificações Removidas

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

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

Registo

Ativar o registo pode ajudar a descobrir informações úteis sobre falhas. Para ver um registo de pedidos HTTP e respostas, defina a variável de AZURE_LOG_LEVEL ambiente como info. Em alternativa, o registo pode ser ativado no runtime ao chamar setLogLevel no @azure/logger:

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

setLogLevel("info");

Para obter instruções mais detalhadas sobre como ativar registos, pode ver os documentos do pacote de @azure/logger.

Passos seguintes

Os exemplos seguintes mostram-lhe as várias formas de interagir com os Hubs de Notificação do Azure:

Gestão de Dispositivos:

• API de Instalações
  • instalação de Create ou atualização
  • Atualizar Instalação
• API de Registo
  • Create Registos
  • Create ou Atualizar Registo
  • Atualizar Registo
  • Listar Registos
  • Listar Registo por Etiqueta

Operações de Envio:

• Envio de Difusão
• Envio Direto
• Lista Enviar Com Etiquetas da Audiência
• Enviar por Audiência com Expressão de Etiqueta
• Envio de Transmissão Agendada
• Envio Agendado

Operações de Gestão:

• Exportar Registos
• Importar Registos

Contribuir

Se 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 dinâmicos e de unidades, que exigem que tenha uma instância dos Hubs de Notificação do Azure. Para executar os testes, terá de executar:

1. rush update
2. rush build -t @azure/notification-hubs
3. Create um ficheiro .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. rushx 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