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

Article
05/21/2024

Azure Notification Hubs fournit un moteur Push avec montée en puissance qui vous permet d’envoyer des notifications à n’importe quelle plateforme (Apple, Amazon Kindle, Firebase, Baidu, Odbc, Web, Windows, etc.) à partir de n’importe quel serveur principal (cloud ou local). Notification Hubs fonctionne bien pour les scénarios d’entreprise et de consommateur. Voici quelques exemples de scénarios :

envoyer des notifications de dernières nouvelles à des millions de personnes avec une faible latence ;
envoyer des coupons basés sur la localisation aux segments d’utilisateurs intéressés ;
envoyer des notifications d’événements à des utilisateurs ou des groupes pour des applications de médias/sport/finance/jeux ;
envoyer des notifications Push de contenu promotionnel vers les applications pour engager et toucher les clients ;
informer les utilisateurs d’événements d’entreprise tels que des nouveaux messages et des éléments de travail ;
envoyer des codes pour l’authentification MFA.

Liens clés :

REMARQUE : Si vous utilisez le azure-sb package, consultez migration guide to move from azure-sb to @azure/notification-hubs

Prise en main

Environnements actuellement pris en charge

Versions LTS de Node.js
Dernières versions de Safari, Chrome, Edge et Firefox.

Pour plus d’informations, consultez notre politique de support .

Installer le package

npm install @azure/notification-hubs

Prérequis

Un abonnement Azure
Une ressource App Notification Hubs .

Create une ressource Azure Notification Hubs

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

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

Importation du client

Ce Kit de développement logiciel (SDK) pour JavaScript offre deux façons d’interagir avec Azure Notification Hubs, soit par le biais d’une approche basée sur la classe, soit par une approche de conception modulaire. L’approche basée sur la classe est cohérente entre 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 à mesure que chaque méthode est exposée individuellement. Cette approche utilise des sous-exportations avec ES-Modules pour exposer les méthodes via des importations directes. Avec les exportations individuelles, cela crée une meilleure expérience de tremblement 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 "@azure/notification-hubs/api" sous-chemin et que toutes les méthodes clientes sont exposées via le "@azure/notification-hubs/api" sous-chemin. Chaque fonction exportée prend comme client premier paramètre et le reste des paramètres reste inchangé.

Les sous-chemins suivants sont exposés :

@azure/notification-hubs/api- Point d’entrée main pour le client via createClientContext les méthodes clientes et telles que getInstallation ousendNotification
@azure/notification-hubs/models - Modèles notification Hubs et méthodes d’usine.

L’extrait de code ci-dessus devient alors le suivant :

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

Authentifier le client

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

Listen permet à un client de s’inscrire lui-même via l’API d’inscription et d’installation. Envoyer 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’inscription et de l’installation, par exemple des requêtes.

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

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

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

À l’aide de 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 installations et registrationDescriptions
Envoyer des notifications aux appareils

Gestion des appareils

La gestion des appareils est un concept fondamental pour Notification Hubs pour pouvoir stocker l’identificateur unique à partir du service de notification de plateforme (PNS) natif, tel que les APN ou Firebase, et les métadonnées associées, telles que les balises utilisées pour envoyer des notifications Push aux audiences. Cela est effectué avec deux API, l’API d’installation, qui est le mécanisme le plus récent et préféré, et Les inscriptions.

Installations API

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 aux audiences. L’API d’installation présente quelques avantages par rapport aux API d’inscription existantes des manières suivantes :

L’API entièrement idempotente appelle donc create lors de l’installation, de sorte qu’une opération peut être retentée sans se soucier des duplications.
Prise en charge des userId propriétés et installationId qui peuvent ensuite être utilisées dans les 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’une inscription distincte et peuvent être référencés par un nom en tant que balise pour l’envoi.
Les mises à jour partielles sont prises en charge par le biais du correctif JSON Standard, qui permet d’ajouter des balises et de modifier d’autres données sans avoir à interroger d’abord l’installation.

Les installations peuvent être créées à l’aide de la createOrUpdateInstallation méthode suivante :

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

À l’aide de l’approche modulaire, le code serait le suivant :

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

Une mise à jour d’une installation peut être effectuée via le schéma de correctif JSON, comme l’ajout d’une balise et d’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);

À l’aide de l’approche modulaire, le code serait le suivant :

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

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

À l’aide de 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 Inscriptions

Une inscription est associée à un PNS comme l’installation ci-dessus, avec l’identificateur d’appareil unique du PNS et les balises associées. Les inscriptions 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 l’une des deux manières suivantes : d’abord en obtenant un ID d’inscription auprès du serveur à l’aide getInstallationId de , puis createOrUpdateRegistration ou via la createRegistration méthode .

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

À l’aide de l’approche modulaire, le code serait le suivant :

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

Mises à jour peut être effectué via la updateRegistration méthode , mais contrairement aux installations, ne prend pas en charge les mises à jour incrémentielles. L’interrogation d’une inscription existante peut être effectuée avec la getRegistration méthode .

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

À l’aide de 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>";

let registration = await getRegistration(context, registrationId);

registration.tags.push("likes_sports");

registration = await updateRegistration(context, registration);

Contrairement aux installations, les inscriptions peuvent être interrogées pour obtenir toutes les inscriptions, les inscriptions correspondant à une condition ou par des balises. Les inscriptions peuvent être interrogées à l’aide de la listRegistrationsméthode , listRegistrationsByChannel et listRegistrationsByTag . Toutes les méthodes prennent en charge la limitation via l’option top et prennent en charge la pagination asynchrone.

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

À l’aide de 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 à l’aide de l’identificateur PNS unique fourni, à l’aide de balises pour l’envoi d’audience ou d’une diffusion générale à tous les appareils. À l’aide de la référence SKU Standard et des versions ultérieures, l’envoi planifié permet à l’utilisateur de planifier des notifications jusqu’à sept jours à l’avance. Toutes les opérations d’envoi retournent 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 les versions ultérieures, un ID de notification est également retourné, qui 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 sur true lesquelles les commentaires immédiats du PNS sur la sendNotification méthode ne sont toutefois pas pris en charge dans les scénarios de production. Cela n’est pas pris en charge sur les méthodes d’envoi planifiées.

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

Envoi de diffusion

Notification Hubs peut être utilisé pour envoyer des notifications à tous les appareils inscrits par plateforme à l’aide de l’envoi de diffusion via la sendNotification méthode .

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

À l’aide de l’approche modulaire, le code serait le suivant :

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

Envoi direct

Pour envoyer directement un appareil, l’utilisateur peut envoyer à l’aide de l’identificateur unique fourni par la plateforme, 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(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}`);
}

À l’aide de l’approche modulaire, le code se présente comme suit :

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

Envoi d’audience

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 inscrits, 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 au niveau supérieur de l’importation ou @azure/notification-hubs/models/tagExpressionBuilder de l’importation modulaire qui crée une « ou expression de balise » à partir des balises.

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

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

À l’aide de l’approche modulaire, le code se présente comme suit :

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

Envoi planifié

Les notifications Push peuvent être planifiées jusqu’à sept jours à l’avance avec les espaces de noms de référence SKU Standard et au-dessus à l’aide de la scheduleBroadcastNotification méthode d’envoi aux appareils avec des balises ou une diffusion générale. Cette opération retourne 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}`);

À l’aide de l’approche modulaire, le code se présente comme suit :

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

Dépannage

Support React Native

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

import 'url-search-params-polyfill';

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

Diagnostiquer les notifications supprimées

Azure Notification Hubs propose un guide complet pour résoudre les problèmes liés aux notifications supprimées dans le Guide Diagnostiquer les notifications supprimées dans Azure Notification Hubs.

L’envoi de test est pris en charge dans la sendNotification méthode avec l’option 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 });

Journalisation

L’activation de la journalisation peut vous aider à mieux comprendre les échecs. Pour avoir 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 @azure/logger :

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

setLogLevel("info");

Pour obtenir des instructions plus détaillées sur l’activation des journaux, consultez les documents relatifs au package @azure/logger.

Étapes suivantes

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

Gestion des appareils :

Installations API
- installation Create ou mettre à jour
- Mettre à jour l’installation
API d’inscription

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 en direct et unitaires, qui vous obligent à disposer d’une instance Azure Notification Hubs. Pour exécuter les tests, vous devez exécuter :

rush update
rush build -t @azure/notification-hubs
Create 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
cd sdk\notificationhubs\notification-hubs
rushx test.

Pour plus d’informations, consultez notre dossier de tests .

Impressions

Partager via

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

Prise en main

Environnements actuellement pris en charge

Installer le package

Prérequis

Create une ressource Azure Notification Hubs

Importation du client

Authentifier le client

Concepts clés

Gestion des appareils

Installations API

API Inscriptions

Opérations d’envoi

Envoi de diffusion

Envoi direct

Envoi d’audience

Envoi planifié

Dépannage

Support React Native

Diagnostiquer les notifications supprimées

Journalisation

Étapes suivantes

Contribution

Ressources supplémentaires

Partager via

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

Prise en main

Environnements actuellement pris en charge

Installer le package

Prérequis

Create une ressource Azure Notification Hubs

Importation du client

Authentifier le client

Concepts clés

Gestion des appareils

Installations API

API Inscriptions

Opérations d’envoi

Envoi de diffusion

Envoi direct

Envoi d’audience

Envoi planifié

Dépannage

Support React Native

Diagnostiquer les notifications supprimées

Journalisation

Étapes suivantes

Contribution

Projets associés

Ressources supplémentaires