Partager via

Kit de développement logiciel (SDK) Azure Notification Hubs pour JavaScript

Azure Notification Hubs fournit un moteur push scale-out qui vous permet d’envoyer des notifications à n’importe quelle plateforme (Apple, Amazon Kindle, Firebase, Baidu, Xiaomi, Web, Windows, etc.) à partir de n’importe quel back-end (cloud ou local). Notification Hubs fonctionne bien pour les scénarios d’entreprise et de grand public. Voici quelques exemples de scénarios :

  • Envoyez des notifications d’actualités à des millions de personnes avec une faible latence.
  • Envoyez des coupons basés sur la localisation aux segments d’utilisateurs intéressés.
  • Envoyez des notifications liées à des événements à des utilisateurs ou à des groupes pour des applications multimédias/sportives/financières/de jeux.
  • Diffusez des contenus promotionnels vers des applications pour les engager et les commercialiser auprès des clients.
  • Informez les utilisateurs des événements d’entreprise tels que les nouveaux messages et les éléments de travail.
  • Envoyez des codes pour l’authentification multifacteur.

Liens clés :

REMARQUE : Si vous venez d’utiliser le package, consultez le azure-sbmigration guide to move from azure-sb to @azure/notification-hubs

Mise en route

Environnements actuellement pris en charge

Pour plus d’informations, consultez notre de stratégie de support .

Installer le package

npm install @azure/notification-hubs

Prerequisites

Créer une ressource Azure Notification Hubs

Un hub de notification Azure peut être créé à l’aide des méthodes suivantes :

  1. Portail Azure
  2. Azure CLI
  3. Bicep
  4. Modèle ARM

Une fois créé, le hub de notification peut être configuré à l’aide du portail Azure ou d’Azure CLI.

Importation du client

Ce SDK pour JavaScript offre deux façons d’interagir avec Azure Notification Hubs : par le biais de l’approche basée sur les classes ou d’une approche de conception modulaire. L’approche basée sur les classes est cohérente dans tous les packages pour créer un client, puis interagir avec les méthodes sur le 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’approche modulaire permet au développeur de choisir les fonctions à importer, car chaque méthode est exposée individuellement. Cette approche utilise des exportations de sous-chemins avec ES-Modules pour exposer les méthodes via des importations directes. Avec les exportations individuelles, cela crée une meilleure expérience de secousse d’arbre et des tailles de bundle plus petites dont le développeur peut tirer parti.

Notez que la création d’un client est exposée via le sous-chemin d’accès "@azure/notification-hubs/api" et que toutes les méthodes du client sont exposées via le "@azure/notification-hubs/api" sous-chemin. Chaque fonction exportée prend le client comme premier paramètre et le reste des paramètres reste inchangé.

Les sous-chemins suivants sont exposés :

  • @azure/notification-hubs/api - Le point d’entrée principal pour le client via createClientContext et les méthodes du client telles que getInstallation ou sendNotification
  • @azure/notification-hubs/models - Les modèles et les méthodes d’usine de Notification Hubs.

L’extrait de code ci-dessus devient alors ce qui suit :

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

Authentifier le client

L’interaction avec un hub de notification Azure commence par le qui prend en charge les chaînes de connexion de signature d’accèsNotificationHubsClient partagé. Cela inclut les niveaux d’autorisation suivants : Écouter, Gérer, Envoyer.

Listen permet à un client de s’enregistrer via l’API d’enregistrement et d’installation. Send permet au client d’envoyer des notifications aux appareils à l’aide des API d’envoi. Enfin, Gérer permet à l’utilisateur d’effectuer la gestion de l’enregistrement et de l’installation, comme les requêtes.

Un client NotificationHubsClient peut être créé à l’aide du constructeur avec la chaîne de connexion et le nom du concentrateur de notification.

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

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

En utilisant l’approche modulaire, le createClientContext peut être importé via le "@azure/notification-hubs/api" sous-chemin.

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

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

Concepts clés

Une fois initialisé NotificationHubClient , les concepts suivants peuvent être explorés.

  • Gestion des appareils via l’installation et l’enregistrementDescriptions
  • Envoyer des notifications aux appareils

Gestion des appareils

La gestion des appareils est un concept fondamental de Notification Hubs pour pouvoir stocker l’identifiant unique du service de notification de plate-forme (PNS) natif, tel que APNs ou Firebase, et les métadonnées associées, telles que les balises utilisées pour l’envoi de notifications push aux audiences. Cela se fait avec deux API, l’API d’installation qui est le mécanisme le plus récent et préféré, et les enregistrements.

API d’installation

Les installations sont une approche JSON plus récente et native de la gestion des appareils qui contient des propriétés supplémentaires telles qu’un ID d’installation et un ID utilisateur qui peuvent être utilisés pour l’envoi à des audiences. L’API d’installation présente quelques avantages par rapport aux API d’inscription existantes de la manière suivante :

  • API totalement idempotente donc appelant create sur l’installation, de sorte qu’une opération peut être réessayée sans se soucier des doublons.
  • userId Prise en charge de et installationId qui peuvent ensuite être utilisées dans des expressions de balise telles que $InstallationId:{myInstallId} et $UserId:{bob@contoso.com}.
  • Les modèles font désormais partie de l’installation au lieu d’un enregistrement séparé et peuvent être référencés par leur nom sous forme de balise pour l’envoi.
  • Les mises à jour partielles sont prises en charge par le JSON Patch Standard, qui permet d’ajouter des balises et de modifier d’autres données sans avoir à interroger au préalable l’installation.

Les installations peuvent être créées par la createOrUpdateInstallation méthode suivante :

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Une mise à jour d’une installation peut être effectuée via le schéma de correctif JSON, par exemple en ajoutant une balise et un ID utilisateur à l’aide de la updateInstallation méthode.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Pour récupérer une installation existante, utilisez la getInstallation méthode avec votre ID d’installation unique existant.

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

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

const installationId = "<unique installation ID>";

const installation = client.getInstallation(installationId);

En utilisant l’approche modulaire, le code serait le suivant :

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 d’inscription

Un enregistrement est associé à un PNS tout comme l’installation ci-dessus, avec l’identifiant unique de l’appareil du PNS et les balises associées. Les enregistrements de modèles sont un moyen de créer des modèles de corps prédéfinis qui peuvent ensuite être personnalisés au moment de l’envoi avec des propriétés à remplir pour le message. Pour plus d’informations sur les modèles, consultez la documentation sur les modèles.

Une installation peut être créée de deux manières, d’abord en obtenant un ID d’enregistrement du serveur à l’aide getInstallationId de la méthode, puis via createOrUpdateRegistration la createRegistration méthode.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Les mises à jour peuvent être effectuées via la updateRegistration méthode mais, contrairement aux installations, ne prend pas en charge les mises à jour incrémentielles. La recherche d’un enregistrement existant peut se faire avec la getRegistration méthode.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Les enregistrements, contrairement aux installations, peuvent être interrogés pour obtenir tous les enregistrements, en faisant correspondre les enregistrements à une condition ou par balises. Les enregistrements peuvent être interrogés à l’aide de la listRegistrationsméthode et listRegistrationsByChannellistRegistrationsByTag . Toutes les méthodes prennent en charge la limitation via l’option et la top pagination asynchrone.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Opérations d’envoi

Notification Hubs prend en charge l’envoi de notifications aux appareils, soit directement à l’aide de l’identifiant unique fourni par PNS, soit à l’aide de balises pour l’envoi d’audience, soit à l’aide d’une diffusion générale à tous les appareils. À l’aide de la référence SKU Standard et ultérieure, l’envoi programmé permet à l’utilisateur de programmer des notifications jusqu’à sept jours à l’avance. Toutes les opérations d’envoi renvoient un ID de suivi et un ID de corrélation qui peuvent être utilisés pour les cas de support Notification Hubs. Avec la référence SKU Standard et ultérieure, un ID de notification est également renvoyé et peut être utilisé pour obtenir des données de télémétrie de notification via la getNotificationOutcomeDetails méthode.

À des fins de débogage, les enableTestSend options peuvent être définies pour true obtenir un retour immédiat du PNS sur la sendNotification méthode, mais elles ne sont pas prises en charge dans les scénarios de production. Cette méthode n’est pas prise en charge par les méthodes d’envoi planifié.

Des chaînes JSON ou XML brutes peuvent être envoyées aux méthodes d’envoi ou d’envoi planifié, ou les constructeurs de notifications peuvent être utilisés pour aider à construire des messages par PNS tels que APNs, Firebase, Baidu, ADM et WNS. Ces constructeurs construiront le format de message natif afin qu’il n’y ait pas de devinettes sur les champs disponibles pour chaque 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,
});

Diffusion Envoyer

Les concentrateurs de notification peuvent être utilisés pour envoyer des notifications à tous les appareils enregistrés par plate-forme à l’aide de l’envoi de diffusion via la sendBroadcastNotification méthode.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Envoi direct

Pour envoyer directement un appareil, l’utilisateur peut l’envoyer à l’aide de l’identifiant unique fourni par la plate-forme, tel que le jeton d’appareil APN, en appelant la sendNotification méthode avec un deviceHandle paramètre.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Audience Envoyer

En plus de cibler un seul appareil, un utilisateur peut cibler plusieurs appareils à l’aide de balises. Ces balises peuvent être fournies sous la forme d’une liste de balises, qui crée ensuite une expression de balise pour correspondre aux appareils enregistrés, ou via une expression de balise qui peut ensuite utiliser la logique booléenne pour cibler le bon public. Pour plus d’informations sur les balises et les expressions de balises, consultez Routage et expressions de balise.

Si vous souhaitez créer une expression de balise à partir d’un tableau de balises, il existe un générateur d’expressions de balise disponible avec la createTagExpression méthode qui est exposée à l’importation de niveau supérieur ou @azure/notification-hubs/models/tagExpressionBuilder l’importation modulaire qui crée une « expression de balise ou de balise » à partir des balises.

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

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

console.log(tagExpression);

Les messages d’expression de balise peuvent être envoyés à l’aide du code suivant :

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Envoi programmé

Les notifications push peuvent être programmées jusqu’à sept jours à l’avance avec les espaces de noms SKU Standard et supérieurs à l’aide de la méthode d’envoi scheduleNotification à des appareils avec des balises ou une diffusion générale avec scheduleBroadcastNotification. Cela renvoie un ID de notification qui peut ensuite être utilisé pour annuler si nécessaire via la cancelScheduledNotification méthode.

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

En utilisant l’approche modulaire, le code serait le suivant :

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

Résolution des problèmes

Prise en charge de React Native

React Native ne prend actuellement pas en charge [URLSearchParams] qui est utilisé par le SDK Azure Notification Hubs. Pour utiliser le SDK dans React Native, vous devez installer le url-search-params-polyfill package et l’importer avant d’utiliser le SDK.

Nous devons également fournir polyfill pour TextEncoder l’API et l’API d’itérateur asynchrone. Pour plus de détails, veuillez consulter notre exemple de React Native avec Expo .

Diagnostiquer les notifications abandonnées

Azure Notification Hubs dispose d’un guide complet pour résoudre les problèmes de notifications abandonnées dans le Guide Diagnostiquer les notifications supprimées dans Azure Notification Hubs.

Test send est pris en charge par les sendNotification méthodes et sendBroadcastNotification avec l’option 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,
});

Logging

L’activation de la journalisation peut vous aider à découvrir des informations utiles sur les échecs. Pour afficher un journal des requêtes et réponses HTTP, définissez la variable d’environnement AZURE_LOG_LEVEL sur info. Vous pouvez également activer la journalisation au moment de l’exécution en appelant setLogLevel dans la @azure/logger:

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

setLogLevel("info");

Pour obtenir des instructions plus détaillées sur l’activation des journaux, vous pouvez consulter la documentationdu package @azure/enregistreur d’événements.

Étapes suivantes

Les exemples suivants vous montrent les différentes façons dont vous pouvez interagir avec Azure Notification Hubs :

Gestion des appareils :

Opérations d’envoi :

Opérations de gestion :

Contribution

Si vous souhaitez contribuer à cette bibliothèque, lisez le guide de contribution pour en savoir plus sur la génération et le test du code.

Les tests de ce module sont un mélange de tests réels et unitaires, qui nécessitent que vous disposiez d’une instance Azure Notification Hubs. Pour exécuter les tests, vous devez exécuter :

  1. pnpm install
  2. pnpm build --filter @azure/notification-hubs...
  3. Créez un fichier .env avec le contenu suivant dans le sdk\notificationhubs\notification-hubs dossier : 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.

Consultez notre dossier de tests pour plus de détails.

  • Last updated on