Azure Notification Hubs SDK per JavaScript

Hub di notifica di Azure offre un motore push con scalabilità orizzontale che consente di inviare notifiche a qualsiasi piattaforma (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows e così via) da qualsiasi back-end (cloud o locale). Hub di notifica funziona bene sia per gli scenari aziendali che per quelli consumer. Ecco alcuni scenari di esempio:

• Invia notifiche delle ultime notizie a milioni di persone con bassa latenza.
• Invia coupon basati sulla posizione ai segmenti di utenti interessati.
• Invia notifiche relative agli eventi a utenti o gruppi per applicazioni multimediali/sportive/finanziarie/di gioco.
• Invia contenuti promozionali alle applicazioni per coinvolgere e commercializzare i clienti.
• Notificare agli utenti eventi aziendali, ad esempio nuovi messaggi ed elementi di lavoro.
• Invia codici per l'autenticazione a più fattori.

Collegamenti chiave:

• Codice sorgente
• Pacchetto (npm)
• Documentazione del prodotto
• esempi di

NOTA: Se si proviene dall'utilizzo del azure-sb pacchetto, vedere il migration guide to move from azure-sb to @azure/notification-hubs

Come iniziare

Ambienti attualmente supportati

• Versioni LTS di Node.js
• Versioni più recenti di Safari, Chrome, Edge e Firefox.

Per altri dettagli, vedere i criteri di supporto .

Installare il pacchetto

npm install @azure/notification-hubs

Prerequisiti

• Una sottoscrizione di Azure
• Una risorsa di Hub di notifica app .

Creare una risorsa di Hub di notifica di Azure

Un hub di notifica di Azure può essere creato usando i metodi seguenti:

1. Portale di Azure
2. CLI di Azure
3. Bicipite
4. Modello ARM

Una volta creato, l'hub di notifica può essere configurato usando il portale di Azure o l'interfaccia della riga di comando di Azure.

Importazione del client

Questo SDK per JavaScript offre due modi per interagire con Hub di notifica di Azure, tramite l'approccio basato su classi o con un approccio di progettazione modulare. L'approccio basato su classi è coerente in tutti i pacchetti per creare un client e quindi interagire con i metodi sul client.

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

L'approccio modulare consente allo sviluppatore di scegliere quali funzioni importare man mano che ogni metodo viene esposto singolarmente. Questo approccio utilizza le esportazioni di percorsi secondari con ES-Modules per esporre i metodi tramite importazioni dirette. Con le singole esportazioni, si crea una migliore esperienza di scuotimento dell'albero e pacchetti di dimensioni ridotte che lo sviluppatore può sfruttare.

Si noti che la creazione di un client viene esposta tramite il "@azure/notification-hubs/api" percorso secondario e tutti i metodi client vengono esposti tramite il "@azure/notification-hubs/api" percorso secondario. Ogni funzione esportata prende il client come primo parametro e il resto dei parametri rimane invariato.

Vengono esposti i seguenti sottotracciati:

• @azure/notification-hubs/api - Il punto di ingresso principale per il client tramite createClientContext e i metodi client, ad esempio getInstallation o sendNotification
• @azure/notification-hubs/models - I modelli e i metodi di fabbrica di Hub di notifica.

Il frammento di codice precedente diventa quindi il seguente:

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

Autenticare il client

L'interazione con un hub di notifica di Azure inizia con il che supporta le NotificationHubsClientstringhe di connessione della firma di accesso condiviso. Sono inclusi i seguenti livelli di autorizzazione: Ascolto, Gestione, Invio.

L'ascolto consente a un client di registrarsi tramite l'API di registrazione e installazione. L'invio consente al client di inviare notifiche ai dispositivi usando le API di invio. Infine, Manage consente all'utente di eseguire la gestione della registrazione e dell'installazione, ad esempio le query.

È possibile creare un nuovo NotificationHubsClient client usando il costruttore con la stringa di connessione e il nome dell'hub di notifica.

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

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

Utilizzando l'approccio modulare, può createClientContext essere importato tramite il "@azure/notification-hubs/api" sottopercorso.

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

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

Concetti chiave

NotificationHubClient Una volta inizializzato, è possibile esplorare i seguenti concetti.

• Gestione dei dispositivi tramite installazioni e registrazioniDescrizioni
• Invio di notifiche ai dispositivi

Gestione dei dispositivi

La gestione dei dispositivi è un concetto fondamentale di Hub di notifica per essere in grado di archiviare l'identificatore univoco dal servizio di notifica della piattaforma nativo, ad esempio APNs o Firebase, e i metadati associati, ad esempio i tag usati per l'invio di notifiche push ai gruppi di destinatari. Questa operazione viene eseguita con due API, l'API di installazione, che è il meccanismo più recente e preferito, e le registrazioni.

API di installazione

Le installazioni sono un approccio JSON più recente e nativo alla gestione dei dispositivi che contiene proprietà aggiuntive, ad esempio un ID di installazione e un ID utente, che possono essere utilizzati per l'invio ai gruppi di destinatari. L'API di installazione presenta alcuni vantaggi rispetto alle API di registrazione esistenti nei seguenti modi:

• API completamente idempotente in modo da chiamare create sull'installazione, in modo che un'operazione possa essere ritentata senza preoccuparsi di duplicazioni.
• Supporto per userId e installationId proprietà che possono essere utilizzate in espressioni di tag come $InstallationId:{myInstallId} e $UserId:{bob@contoso.com}.
• I modelli fanno ora parte dell'installazione invece di una registrazione separata e possono essere citati per nome come tag per l'invio.
• Gli aggiornamenti parziali sono supportati tramite il JSON Patch Standard, che consente di aggiungere tag e modificare altri dati senza dover prima interrogare l'installazione.

Le installazioni possono essere create con il createOrUpdateInstallation seguente metodo:

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Un aggiornamento di un'installazione può essere effettuato tramite lo schema JSON Patch, ad esempio aggiungendo un tag e un ID utente utilizzando il updateInstallation metodo.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Per recuperare un'installazione esistente, utilizzare il metodo con l'ID getInstallation di installazione univoco esistente.

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

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

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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 per le registrazioni

Una registrazione è associata a un PNS proprio come l'installazione precedente, con l'identificatore univoco del dispositivo dal PNS e i tag associati. Le registrazioni dei modelli sono un modo per creare modelli di corpo predefiniti che possono essere personalizzati al momento dell'invio con le proprietà da compilare per il messaggio. Per ulteriori informazioni sui modelli, vedere la documentazione relativa ai modelli.

Un'installazione può essere creata in due modi, prima ottenendo un ID di registrazione dal server utilizzando getInstallationId e poi createOrUpdateRegistration o tramite il createRegistration metodo.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Gli aggiornamenti possono essere eseguiti tramite il metodo ma, a differenza delle updateRegistration installazioni, non supporta gli aggiornamenti incrementali. L'esecuzione di query per una registrazione esistente può essere eseguita con il getRegistration metodo.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Le registrazioni, a differenza delle installazioni, possono essere interrogate per ottenere tutte le registrazioni, abbinando le registrazioni a una condizione o tramite tag. È possibile eseguire query sulle registrazioni utilizzando il listRegistrationsmetodo e listRegistrationsByChannellistRegistrationsByTag . Tutti i metodi supportano la limitazione tramite l'opzione e supportano il top paging asincrono.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Operazioni di invio

Hub di notifica supporta l'invio di notifiche ai dispositivi direttamente tramite l'identificatore PNS univoco fornito, l'uso di tag per l'invio da parte del pubblico o una trasmissione generale a tutti i dispositivi. Utilizzando lo SKU Standard e versioni successive, l'invio programmato consente all'utente di pianificare le notifiche fino a sette giorni in anticipo. Tutte le operazioni di invio restituiscono un ID di rilevamento e un ID di correlazione che possono essere usati per i casi di supporto di Hub di notifica. Con lo SKU Standard e versioni successive, viene restituito anche un ID notifica che può essere usato per ottenere i dati di telemetria delle notifiche tramite il getNotificationOutcomeDetails metodo.

Ai fini del debug, è possibile impostare le enableTestSend opzioni su true cui si ottiene un feedback immediato dal PNS sul sendNotification metodo, ma non è supportato negli scenari di produzione. Questa opzione non è supportata nei metodi di invio pianificati.

Le stringhe JSON o XML non elaborate possono essere inviate ai metodi di invio o di invio pianificato, oppure è possibile utilizzare i generatori di notifiche che aiutano a costruire messaggi per PNS come APNs, Firebase, Baidu, ADM e WNS. Questi generatori costruiranno il formato nativo del messaggio in modo che non sia necessario indovinare quali campi sono disponibili per ogni 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,
});

Trasmissione Invio

Gli hub di notifica possono essere usati per inviare notifiche a tutti i dispositivi registrati per piattaforma usando l'invio broadcast tramite il sendBroadcastNotification metodo.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Invio diretto

Per inviare direttamente un dispositivo, l'utente può inviare utilizzando l'identificatore univoco fornito dalla piattaforma, ad esempio il token del dispositivo APNs, chiamando il sendNotification metodo con un deviceHandle parametro.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Invio pubblico

Oltre a scegliere come target un singolo dispositivo, un utente può scegliere come target più dispositivi utilizzando i tag. Questi tag possono essere forniti come un elenco di tag, che quindi crea un'espressione tag per abbinare i dispositivi registrati, o tramite un'espressione tag che può quindi utilizzare la logica booleana per indirizzare il pubblico giusto. Per ulteriori informazioni sui tag e sulle espressioni tag, vedere Routing ed espressioni tag.

Se si desidera creare un'espressione di tag da un array di tag, è disponibile un Tag Expression Builder con il createTagExpression metodo che viene esposto all'importazione di livello superiore o @azure/notification-hubs/models/tagExpressionBuilder all'importazione modulare che crea un'espressione di tag "or" dai tag.

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

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

console.log(tagExpression);

I messaggi di espressione tag possono essere inviati utilizzando il seguente codice:

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Invio programmato

Le notifiche push possono essere pianificate fino a sette giorni in anticipo con gli spazi dei nomi SKU standard e superiori utilizzando il metodo per l'invio scheduleNotification a dispositivi con tag o una trasmissione generale con scheduleBroadcastNotification. In questo modo viene restituito un ID di notifica che può essere utilizzato per annullare, se necessario, tramite il cancelScheduledNotification metodo.

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

Utilizzando l'approccio modulare, il codice sarebbe il seguente:

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

Risoluzione dei problemi

Supporto nativo di React

React Native attualmente non supporta [URLSearchParams], che viene usato da Hub di notifica di Azure SDK. Per utilizzare l'SDK in React Native, è necessario installare il url-search-params-polyfill pacchetto e importarlo prima di utilizzare l'SDK.

Dobbiamo anche fornire polyfill per TextEncoder l'API e l'API iteratore asincrono. Per maggiori dettagli, consulta il nostro esempio React Native con Expo .

Diagnostica notifiche eliminate

Hub di notifica di Azure include una guida completa per la risoluzione dei problemi relativi alle notifiche eliminate nella Guida alla diagnosi delle notifiche eliminate in Hub di notifica di Azure.

L'inviosendNotification di prova è supportato supportato nei metodi e sendBroadcastNotification con l'opzione enableTestSend :

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

Registrazione

L'abilitazione della registrazione può aiutare a individuare informazioni utili sugli errori. Per visualizzare un log di richieste e risposte HTTP, impostare la variabile di ambiente AZURE_LOG_LEVEL su info. In alternativa, la registrazione può essere abilitata in fase di esecuzione chiamando setLogLevel nel @azure/logger:

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

setLogLevel("info");

Per istruzioni più dettagliate su come abilitare i log, vedere la documentazione del pacchetto @azure/logger.

Passaggi successivi

Gli esempi seguenti illustrano i vari modi in cui è possibile interagire con Hub di notifica di Azure:

Gestione dei dispositivi:

• API di installazione
  • Creare o aggiornare l'installazione
  • Aggiorna installazione
• API di registrazione
  • Crea registraziones
  • Crea o aggiorna la registrazione
  • Aggiorna registrazione
  • Elenco Iscrizioni
  • Registrazione elenco per tag

Operazioni di invio:

• Trasmissione Invio
• Invio diretto
• Elenco Pubblico Invia con tag
• Invio del pubblico con espressione tag
• Invio trasmissione programmata
• Invio programmato

Operazioni di gestione:

• Esporta registrazioni
• Importa registrazioni

Contributing

Per contribuire a questa libreria, leggere la guida per i contributi per altre informazioni su come compilare e testare il codice.

I test di questo modulo sono una combinazione di test live e unit test, che richiedono la presenza di un'istanza di Hub di notifica di Azure. Per eseguire i test è necessario eseguire:

1. pnpm install
2. pnpm build --filter @azure/notification-hubs...
3. Creare un file con estensione env con i seguenti contenuti nella sdk\notificationhubs\notification-hubs cartella: 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.

Per maggiori dettagli, consulta la nostra cartella dei test .

Progetti correlati

• Microsoft Azure SDK per JavaScript
• Hub di notifica di Azure