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:
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:
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éscreateClientContext
de métodos de cliente, comogetInstallation
ousendNotification
@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
userId
installationId
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 listRegistrations
método e listRegistrationsByTag
listRegistrationsByChannel
. 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
- API de Registo
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:
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:
rush update
rush build -t @azure/notification-hubs
- Create um ficheiro .env com estes conteúdos na
sdk\notificationhubs\notification-hubs
pasta:NOTIFICATIONHUBS_CONNECTION_STRING=connection string for your Notification Hubs instance
NOTIFICATION_HUB_NAME=Notification Hub name
cd sdk\notificationhubs\notification-hubs
rushx test
.
Veja a nossa pasta de testes para obter mais detalhes.
Projetos relacionados
Azure SDK for JavaScript