Envoyer des modèles de message WhatsApp via Advanced Messages

Cet article explique comment envoyer des modèles de message WhatsApp à l’aide du kit SDK Advanced Communication Messages.

Prérequis

• Inscrire un compte WhatsApp Business auprès de votre ressource Azure Communication Services.
• Créer un message modèle WhatsApp.
• Numéro de téléphone WhatsApp actif devant recevoir des messages.

Modèle objet

Les classes et interfaces suivantes prennent en charge certaines des principales fonctionnalités du kit SDK Azure Communication Services Messages pour .NET.

Nom de la classe	Description
NotificationMessagesClient	Se connecte à votre ressource Azure Communication Services. Elle envoie les messages.
MessageTemplate	Définit le modèle à utiliser ainsi que le contenu des propriétés du modèle pour votre message.
TemplateNotificationContent	Définit le « qui » et le « quoi » du modèle de message que vous avez l’intention d’envoyer.

Remarque

Pour plus d’informations, consultez la documentation de référence du kit Azure SDK pour .NET : Espace de noms Azure.Communication.Messages.

Types de modèles WhatsApp pris en charge

Type de modèle	Description
Modèles de message basés sur du texte	Les modèles de message WhatsApp sont des formats de message spécifiques avec ou sans paramètres.
Modèles de message basés sur des éléments multimédias	Modèles de message WhatsApp avec des paramètres multimédias pour les composants d’en-tête.
Modèles de message interactif	Les modèles de message interactif permettent d’étendre le contenu que vous pouvez envoyer aux destinataires, en incluant des boutons interactifs à l’aide de l’objet components. Les appels à l’action et les réponses rapides sont pris en charge.
Modèles de message basés sur la localisation	Modèles de message WhatsApp avec des paramètres de localisation exprimés en longitude et latitude pour les composants d’en-tête.

Configuration commune

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction Main de votre fichier Program.cs.

• Créer et gérer un modèle de message WhatsApp.
• Authentifier le client.
• Définir l’ID d’inscription de canal.
• Définir la liste de destinataires.

Créer et gérer un modèle de message WhatsApp

Les modèles de message WhatsApp sont des formats de message spécifiques que les entreprises utilisent pour envoyer des notifications ou des messages de support client aux personnes qui ont choisi de recevoir des notifications. Les messages peuvent inclure des rappels de rendez-vous, des informations d’expédition, une résolution de problème ou des notifications relatives aux paiements. Avant de commencer à utiliser le kit SDK de messagerie avancée pour envoyer des messages basés sur un modèle, l’utilisateur doit créer les modèles nécessaires sur la plateforme WhatsApp Business.

Pour plus d’informations sur les exigences de WhatsApp relatives aux modèles, consultez la documentation de référence sur les API de la plateforme WhatsApp Business :

• Créer et gérer des modèles.
• Voir les composants du modèle.
• Envoyer des messages issus d’un modèle.
• Les entreprises doivent également respecter les exigences d’adhésion avant d’envoyer des messages aux utilisateurs WhatsApp.

Authentifier le client

Le kit SDK Messages utilise NotificationMessagesClient pour envoyer des messages. La méthode NotificationMessagesClient s’authentifie à l’aide de votre chaîne de connexion acquise à partir de la ressource Azure Communication Services dans le portail Azure. Pour plus d’informations sur les chaînes de connexion, consultez Accéder à vos chaînes de connexion et points de terminaison de service.

Chaîne de connexion

Par souci de simplicité, ce guide de démarrage rapide utilise une chaîne de connexion pour s’authentifier. Dans les environnements de production, nous vous recommandons d’utiliser des principaux de service.

Obtenez la chaîne de connexion de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le champ Connection string de la clé primaire. La chaîne de connexion est au format endpoint=https://{your Azure Communication Services resource name}.communication.azure.com/;accesskey={secret key}.

Définissez la variable d’environnement COMMUNICATION_SERVICES_CONNECTION_STRING sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_CONNECTION_STRING "<your connection string>"

Après avoir ajouté la variable d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront la lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode Main :

// Retrieve connection string from environment variable
string connectionString = 
    Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");

// Instantiate the client
var notificationMessagesClient = new NotificationMessagesClient(connectionString);

Microsoft Entra ID

Vous pouvez vous authentifier auprès de Microsoft Entra ID à l’aide de la bibliothèque Azure Identity.

Le package Azure.Identity fournit divers types d’informations d’identification que votre application peut utiliser afin de s’authentifier. Vous pouvez choisir parmi les différentes options permettant d’authentifier le client d’identité détaillées dans Identité Azure – Fournisseurs d’informations d’identification et Identité Azure – Authentifier le client. Cette option présente l’une des manières d’utiliser DefaultAzureCredential.

Le DefaultAzureCredential tente d’effectuer l’authentification via several mechanisms, et peut obtenir ses informations d’identification d’authentification si vous êtes connecté à Visual Studio ou Azure CLI. Toutefois, cette option vous guide tout au long de la configuration avec des variables d’environnement.

Pour créer un objet DefaultAzureCredential :

1. Pour configurer votre application de principal de service, suivez les instructions fournies dans Création d’une application inscrite auprès de Microsoft Entra.

2. Définissez les variables d’environnement AZURE_CLIENT_ID, AZURE_CLIENT_SECRET et AZURE_TENANT_ID à l’aide de la sortie de la création de votre application.
   Ouvrez une fenêtre de console et entrez les commandes suivantes :

   setx AZURE_CLIENT_ID "<your app's appId>"
   setx AZURE_CLIENT_SECRET "<your app's password>"
   setx AZURE_TENANT_ID "<your app's tenant>"
   

   Après avoir ajouté les variables d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront les lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

3. Pour utiliser le fournisseur DefaultAzureCredential, ou d’autres fournisseurs d’informations d’identification fournis avec le kit SDK Azure, installez le package NuGet Azure.Identity et ajoutez la directive using suivante à votre fichier Program.cs.

   using Azure.Identity;
   

4. Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode Main.

   // Configure authentication
   var endpoint = new Uri("https://<resource name>.communication.azure.com");
   var credential = new DefaultAzureCredential();
   
   // Instantiate the client
   var notificationMessagesClient = 
       new NotificationMessagesClient(endpoint, credential);
   

AzureKeyCredential

Vous pouvez également vous authentifier avec un azureKeyCredential.

Obtenez le point de terminaison et la clé de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le Endpoint et le champ Key pour la clé primaire.

Définissez la variable d’environnement COMMUNICATION_SERVICES_KEY sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_KEY "<your key>"

Après avoir ajouté la variable d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront la lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode Main :

// Retrieve key from environment variable
string key = 
    Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_KEY");

// Configure authentication
var endpoint = new Uri("https://<resource name>.communication.azure.com");
var credential = new AzureKeyCredential(key);

// Instantiate the client
var notificationMessagesClient = 
    new NotificationMessagesClient(endpoint, credential);

Définir un ID d’inscription de canal

Vous avez créé le GUID de l’ID d’inscription de canal durant l’inscription du canal. Vous le trouverez dans le portail, sous l’onglet Canaux de votre ressource Azure Communication Services.

Attribuez-le à une variable appelée channelRegistrationId.

var channelRegistrationId = new Guid("<your channel registration ID GUID>");

Définir la liste des destinataires

Vous devez fournir un numéro de téléphone actif associé à un compte WhatsApp. Ce compte WhatsApp reçoit les modèles de messages, les messages multimédias et les SMS envoyés dans ce guide de démarrage rapide.

Pour cet exemple, vous pouvez utiliser votre numéro de téléphone personnel.

Le numéro de téléphone du destinataire ne peut pas être le numéro de téléphone professionnel (ID d’expéditeur) associé à l’inscription du canal WhatsApp. L’ID d’expéditeur s’affiche comme étant l’expéditeur des messages textuels et multimédias envoyés au destinataire.

Le numéro de téléphone doit inclure l’indicatif téléphonique international. Pour plus d’informations sur la mise en forme des numéros de téléphone, consultez la documentation de WhatsApp relative aux formats des numéros de téléphone.

Remarque

Un seul numéro de téléphone est actuellement pris en charge dans la liste des destinataires.

Créez la liste des destinataires de la façon suivante :

var recipientList = new List<string> { "<to WhatsApp phone number>" };

Exemple :

// Example only
var recipientList = new List<string> { "+14255550199" };

Commencer à envoyer des messages entre une entreprise et un utilisateur WhatsApp

Les conversations entre un compte WhatsApp Business et un utilisateur WhatsApp peuvent être lancées de deux manières :

• L’entreprise envoie un message modèle à l’utilisateur WhatsApp.
• L’utilisateur WhatsApp envoie n’importe quel message au numéro professionnel.

Une entreprise ne peut pas lancer une conversation interactive. Une entreprise peut uniquement envoyer un message interactif après avoir reçu un message de l’utilisateur. L’entreprise peut uniquement envoyer des messages interactifs à l’utilisateur durant la conversation active. Une fois la fenêtre de conversation de 24 heures expirée, seul l’utilisateur peut relancer la conversation interactive. Pour plus d’informations sur les conversations, consultez la définition sur le site Plateforme WhatsApp Business.

Pour lancer une conversation interactive à partir de votre compte WhatsApp personnel, envoyez un message à votre numéro professionnel (ID de l’expéditeur).

Configurer l’environnement

Créer le projet .NET

Visual Studio

Pour créer votre projet, suivez le tutoriel Créer une application console .NET à l’aide de Visual Studio.

Pour compiler votre code, appuyez sur Ctrl+F7.

Visual Studio Code

Pour créer votre projet, suivez le tutoriel Créer une application console .NET à l’aide de Visual Studio Code.

Générez et exécutez votre programme en exécutant les commandes suivantes dans le terminal Visual Studio Code (Afficher>Terminal).

dotnet build
dotnet run

CLI .NET

Créer votre projet.

dotnet new console -o AdvancedMessagingQuickstart

Accédez à votre répertoire de projet, puis générez votre projet.

cd AdvancedMessagingQuickstart
dotnet build

Installer le package

Installez le package NuGet Azure.Communication.Messages dans votre projet C#.

Visual Studio

1. Ouvrez le Gestionnaire de package NuGet à Project>Manage NuGet Packages....
2. Recherchez le package Azure.Communication.Messages.
3. Installez la dernière version.

Visual Studio Code

1. Ouvrez le terminal Visual Studio Code ( View>Terminal ).
2. Installez le package en exécutant la commande suivante.

dotnet add package Azure.Communication.Messages

CLI .NET

Installez le package en exécutant la commande suivante.

dotnet add package Azure.Communication.Messages

Configurer le framework d’application

Ouvrez le fichier Program.cs dans un éditeur de texte.

Remplacez le contenu de votre fichier Program.cs par le code suivant :

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure;
using Azure.Communication.Messages;

namespace AdvancedMessagingQuickstart
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            Console.WriteLine("Azure Communication Services - Advanced Messages quickstart samples.");

            // Quickstart code goes here
        }
    }
}

Pour utiliser les fonctionnalités de la messagerie avancée, ajoutez une directive using afin d’inclure l’espace de noms Azure.Communication.Messages.

using Azure.Communication.Messages;

Exemples de code

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction Main de votre fichier Program.cs.

• Lister les modèles WhatsApp dans le portail Azure.
• Envoyer un modèle de message sans paramètres.
• Envoyer un modèle de message avec des paramètres de texte dans le corps.
• Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête.
• Envoyer un modèle de message avec la localisation dans l’en-tête.
• Envoyer un modèle de message avec des boutons de réponse rapide.
• Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique.
• Envoyer un modèle de message avec des boutons d’appel à l’action et un lien statique.

Lister les modèles WhatsApp dans le portail Azure

Vous pouvez voir vos modèles dans le portail Azure en accédant à votre ressource Azure Communication Service >Messagerie avancée>Modèles.

Sélectionnez un modèle pour voir les détails.

Le champ content des détails du modèle peut inclure des liaisons de paramètres. Les liaisons de paramètres peuvent être désignées comme suit :

• Champ format avec une valeur telle que IMAGE.
• Crochets doubles entourant un nombre, tels que {{1}}. Le nombre, indexé à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message.

Vous pouvez également voir et modifier tous les modèles de votre compte WhatsApp Business dans Gestionnaire WhatsApp> Outils du compte >Modèles de message.

Pour lister vos modèles par programmation, vous pouvez récupérer tous les modèles de votre ID de canal comme suit :

MessageTemplateClient messageTemplateClient = new MessageTemplateClient(connectionString);
Pageable<MessageTemplateItem> templates = messageTemplateClient.GetTemplates(channelRegistrationId);

Envoyer un modèle de message sans paramètres

Si le modèle ne nécessite pas de paramètres, vous n’avez pas besoin de fournir de valeurs ou de liaisons au moment de la création de MessageTemplate.

var messageTemplate = new MessageTemplate(templateName, templateLanguage); 

Exemple

sample_template n’accepte aucun paramètre.

Assemblez MessageTemplate en référençant le nom et la langue du modèle cible.

string templateName = "sample_template"; 
string templateLanguage = "en_us"; 

var sampleTemplate = new MessageTemplate(templateName, templateLanguage); 

Envoyer un modèle de message avec des paramètres de texte dans le corps

Utilisez MessageTemplateText pour définir des paramètres dans le corps indiqués avec des crochets doubles entourant un nombre, tels que {{1}}. Le nombre, dont l’index commence à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message. L’inclusion de paramètres qui ne sont pas dans le modèle n’est pas valide.

Définition de modèle avec deux paramètres :

{
  "type": "BODY",
  "text": "Message with two parameters: {{1}} and {{2}}"
}

Exemples

Modèle sample_shipping_confirmation :

Dans cet exemple, le corps du modèle a un paramètre :

{
  "type": "BODY",
  "text": "Your package has been shipped. It will be delivered in {{1}} business days."
},

Les paramètres sont définis avec les valeurs MessageTemplateValue et les liaisons MessageTemplateWhatsAppBindings. Utilisez les valeurs et les liaisons pour assembler le MessageTemplate.

string templateName = "sample_shipping_confirmation"; 
string templateLanguage = "en_us"; 

var threeDays = new MessageTemplateText("threeDays", "3");

WhatsAppMessageTemplateBindings bindings = new();
bindings.Body.Add(new(threeDays.Name));

MessageTemplate shippingConfirmationTemplate  = new(templateName, templateLanguage);
shippingConfirmationTemplate.Bindings = bindings;
shippingConfirmationTemplate.Values.Add(threeDays);

Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête

Utilisez MessageTemplateImage, MessageTemplateVideoou MessageTemplateDocument pour définir le paramètre média dans un en-tête.

Définition de modèle avec un paramètre multimédia d’image dans l’en-tête :

{
  "type": "HEADER",
  "format": "IMAGE"
},

format peut comporter différents types d’éléments multimédias pris en charge par WhatsApp. Dans le kit .NET SDK, chaque type de média utilise un type MessageTemplateValue correspondant.

Mettre en forme	Type MessageTemplateValue	Type de fichier
IMAGE	MessageTemplateImage	png, jpg
VIDEO	MessageTemplateVideo	mp4
DOCUMENT	MessageTemplateDocument	pdf

Pour plus d’informations sur les types de média pris en charge et les limites de taille, consultez Documentation WhatsApp pour le média de message.

Assembly de modèle de message pour média d’image :

var url = new Uri("< Your media URL >");

var media = new MessageTemplateImage("image", url);
WhatsAppMessageTemplateBindings bindings = new();
bindings.Header.Add(new(media.Name));

var messageTemplate = new MessageTemplate(templateName, templateLanguage);
template.Bindings = bindings;
template.Values.Add(media);

Exemples

Modèle sample_movie_ticket_confirmation :

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite quatre paramètres de texte :

{
  "type": "BODY",
  "text": "Your ticket for *{{1}}*\n*Time* - {{2}}\n*Venue* - {{3}}\n*Seats* - {{4}}"
},

Créez une variable MessageTemplateImage et quatre variables MessageTemplateText. Ensuite, assemblez votre liste de MessageTemplateValue et votre MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre dans lequel les paramètres apparaissent dans le contenu du modèle.

string templateName = "sample_movie_ticket_confirmation"; 
string templateLanguage = "en_us"; 
var imageUrl = new Uri("https://aka.ms/acsicon1");

var image = new MessageTemplateImage("image", imageUrl);
var title = new MessageTemplateText("title", "Contoso");
var time = new MessageTemplateText("time", "July 1st, 2023 12:30PM");
var venue = new MessageTemplateText("venue", "Southridge Video");
var seats = new MessageTemplateText("seats", "Seat 1A");

WhatsAppMessageTemplateBindings bindings = new();
bindings.Header.Add(new(image.Name));
bindings.Body.Add(new(title.Name));
bindings.Body.Add(new(time.Name));
bindings.Body.Add(new(venue.Name));
bindings.Body.Add(new(seats.Name));

MessageTemplate movieTicketConfirmationTemplate = new(templateName, templateLanguage);
movieTicketConfirmationTemplate.Values.Add(image);
movieTicketConfirmationTemplate.Values.Add(title);
movieTicketConfirmationTemplate.Values.Add(time);
movieTicketConfirmationTemplate.Values.Add(venue);
movieTicketConfirmationTemplate.Values.Add(seats);
movieTicketConfirmationTemplate.Bindings = bindings;

Plus d'exemples

• VIDÉO : Utiliser un exemple de modèle sample_happy_hour_announcement
• DOCUMENT  :Utiliser un exemple de modèle sample_flight_confirmation

Envoyer un modèle de message avec la localisation dans l’en-tête

Utilisez MessageTemplateLocation pour définir le paramètre d’emplacement dans un en-tête.

Définition de modèle pour le composant d’en-tête nécessitant un emplacement comme suit :

{
  "type": "header",
  "parameters": [
    {
      "type": "location",
      "location": {
        "latitude": "<LATITUDE>",
        "longitude": "<LONGITUDE>",
        "name": "<NAME>",
        "address": "<ADDRESS>"
      }
    }
  ]
}

format peut nécessiter différents types d’éléments multimédias. Dans le kit .NET SDK, chaque type de média utilise un type MessageTemplateValue correspondant.

Propriétés	Description	Type
ADDRESS	Adresse qui apparaît après la valeur NAME, sous la carte générique en haut du message.	string
LATITUDE	Latitude de l’emplacement.	double
LONGITUDE	Longitude de l’emplacement.	double
LOCATIONNAME	Texte qui apparaît juste en dessous de la carte générique en haut du message.	string

Pour plus d’informations sur les modèles basés sur la localisation, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Exemple

Modèle sample_movie_location :

Assembly de modèle de message basé sur l’emplacement :

 var location = new MessageTemplateLocation("location");
 location.LocationName = "Pablo Morales";
 location.Address = "1 Hacker Way, Menlo Park, CA 94025";
 location.Position = new Azure.Core.GeoJson.GeoPosition(longitude: 122.148981, latitude: 37.483307);

 WhatsAppMessageTemplateBindings location_bindings = new();
 location_bindings.Header.Add(new(location.Name));

 var messageTemplateWithLocation = new MessageTemplate(templateNameWithLocation, templateLanguage);
 messageTemplateWithLocation.Values.Add(location);
 messageTemplateWithLocation.Bindings = location_bindings;

Envoyer un modèle de message avec des boutons de réponse rapide

Utilisez MessageTemplateQuickAction pour définir la charge utile des boutons de réponse rapide. Les objets MessageTemplateQuickAction ont les trois attributs suivants.

Propriétés	Description	Type
Nom	name utilisé pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text facultatif de l’action rapide.	string
Charge utile	payload affecté à un bouton disponible dans une réponse à un message si l’utilisateur sélectionne le bouton.	string

Définition de modèle avec des boutons de réponse rapide :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "QUICK_REPLY",
      "text": "Yes"
    },
    {
      "type": "QUICK_REPLY",
      "text": "No"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Pour plus d’informations sur la charge utile des réponses rapides de l’utilisateur, consultez la documentation de WhatsApp relative à un Rappel reçu à partir d’un bouton de réponse rapide.

Exemple

Modèle sample_issue_resolution :

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Hi {{1}}, were we able to solve the issue that you were facing?"
},

Le modèle comprend deux boutons de réponse préremplis, Yes et No.

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "QUICK_REPLY",
      "text": "Yes"
    },
    {
      "type": "QUICK_REPLY",
      "text": "No"
    }
  ]
}

Créez une variable MessageTemplateText et deux variables MessageTemplateQuickAction. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

string templateName = "sample_issue_resolution";
string templateLanguage = "en_us";

var name = new MessageTemplateText(name: "name", text: "Kat");
var yes = new MessageTemplateQuickAction(name: "Yes"){ Payload =  "Kat said yes" };
var no = new MessageTemplateQuickAction(name: "No") { Payload = "Kat said no" };

WhatsAppMessageTemplateBindings bindings = new();
bindings.Body.Add(new(name.Name));
bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.QuickReply.ToString(), yes.Name));
bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.QuickReply.ToString(), no.Name));

MessageTemplate issueResolutionTemplate = new(templateName, templateLanguage);
issueResolutionTemplate.Values.Add(name);
issueResolutionTemplate.Values.Add(yes);
issueResolutionTemplate.Values.Add(no);
issueResolutionTemplate.Bindings = bindings;

Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique

Utilisez MessageTemplateQuickAction pour définir le suffixe d’URL des boutons d’appel à l’action. L’objet MessageTemplateQuickAction a les deux attributs suivants.

Propriétés	Description	Type
Nom	La name est utilisée pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text ajouté à l’URL.	string

Boutons de définition de modèle :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Exemple

Modèle sample_purchase_feedback :

Cet exemple de modèle ajoute un bouton avec un lien d’URL dynamique au message. Il utilise également une image dans l’en-tête et un paramètre de texte dans le corps.

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Thank you for purchasing {{1}}! We value your feedback and would like to learn more about your experience."
},

Le modèle comprend un bouton d’URL dynamique avec un paramètre :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

Créez une variable MessageTemplateImage, une variable MessageTemplateTextet une variable MessageTemplateQuickAction. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

string templateName = "sample_purchase_feedback";
string templateLanguage = "en_us";
var imageUrl = new Uri("https://aka.ms/acsicon1");

var image = new MessageTemplateImage(name: "image", uri: imageUrl);
var product = new MessageTemplateText(name: "product", text: "coffee");
var urlSuffix = new MessageTemplateQuickAction(name: "text") { Text = "survey-code" };

WhatsAppMessageTemplateBindings bindings = new();
bindings.Header.Add(new(image.Name));
bindings.Body.Add(new(product.Name));
bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.Url.ToString(), urlSuffix.Name));

MessageTemplate purchaseFeedbackTemplate = new("sample_purchase_feedback", "en_us");
purchaseFeedbackTemplate.Values.Add(image);
purchaseFeedbackTemplate.Values.Add(product);
purchaseFeedbackTemplate.Values.Add(urlSuffix);
purchaseFeedbackTemplate.Bindings = bindings;

Envoyer un modèle de message avec des boutons d’appel à l’action et un lien statique

Pour les liens statiques, vous n’avez pas besoin d’inclure le modèle MessageTemplateQuickAction, car le modèle WhatsApp comporte un lien CallToAction statique qui ne nécessite pas d’entrée de la part de l’utilisateur.

Boutons de définition de modèle :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

Exemple

Modèle purchase_feedback_static :

Cet exemple de modèle ajoute un bouton avec un lien d’URL statique au message. Il utilise également une image dans l’en-tête et un paramètre de texte dans le corps.

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Hello {{1}}, \nHope you are great day!.\n Please click on given link to explore about our program.."
},

Le modèle comprend un bouton d’URL dynamique avec un paramètre :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/"
    }
  ]
}

Créez un MessageTemplateImage, un MessageTemplateText. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

// Send sample template sample_template
string templateNameWithcta = "purchase_feedback_static";
var bodyParam1 = new MessageTemplateText(name: "customer", text: "Joe");
var image = new MessageTemplateImage("image", new Uri("https://aka.ms/acsicon1"));

WhatsAppMessageTemplateBindings cta_bindings = new();
cta_bindings.Body.Add(new(bodyParam1.Name));
cta_bindings.Header.Add(new(image.Name));

var messageTemplateWithcta = new MessageTemplate(templateNameWithcta, templateLanguage);
messageTemplateWithcta.Values.Add(bodyParam1);
messageTemplateWithcta.Values.Add(image);
messageTemplateWithcta.Bindings = cta_bindings;

TemplateNotificationContent templateContent4 =
    new TemplateNotificationContent(channelRegistrationId, recipientList, messageTemplateWithcta);
Response<SendMessageResult> sendTemplateMessageResult4 =
    notificationMessagesClient.Send(templateContent4);

Exécuter le code

Générez et exécutez votre programme.

Pour envoyer un SMS ou un message multimédia à un utilisateur WhatsApp, il doit y avoir une conversation active entre le compte WhatsApp Business et l’utilisateur WhatsApp.

Si vous n’avez pas de conversation active, pour les besoins de cet exemple, vous pouvez ajouter un délai d’attente entre l’envoi du modèle de message et l’envoi du SMS. Ce délai supplémentaire vous donne suffisamment de temps pour répondre à l’entreprise sur le compte WhatsApp de l’utilisateur. Pour référence, l’exemple donné demande une entrée utilisateur manuelle avant d’envoyer le message suivant. Pour plus d’informations, consultez l’exemple complet dans Exemple de code. En cas de réussite, vous recevez trois messages sur le compte WhatsApp de l’utilisateur.

CLI .NET

Générez et exécutez votre programme.

dotnet build
dotnet run

Visual Studio

1. Pour compiler votre code, appuyez sur Ctrl+F7.
2. Pour exécuter le programme sans débogage, appuyez sur Ctrl+F5.

Visual Studio Code

Générez et exécutez votre programme en utilisant les commandes suivantes dans le terminal Visual Studio Code (Afficher>Terminal).

dotnet build
dotnet run

Exemple de code complet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Azure;
using Azure.Communication.Messages;
using Azure.Communication.Messages.Models.Channels;

namespace SendTemplateMessages
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            Console.WriteLine("Azure Communication Services - Send WhatsApp Template Messages\n");

            string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");

            NotificationMessagesClient notificationMessagesClient = new NotificationMessagesClient(connectionString);

            var channelRegistrationId = new Guid("<Your Channel ID>");
            var recipientList = new List<string> { "<Recipient's WhatsApp Phone Number>" };

            // List out available templates for a channel ID
            MessageTemplateClient messageTemplateClient = new MessageTemplateClient(connectionString);
            Pageable<MessageTemplateItem> templates = messageTemplateClient.GetTemplates(channelRegistrationId);
            foreach (WhatsAppMessageTemplateItem template in templates)
            {
                Console.WriteLine("Name: {0}\tLanguage: {1}\tStatus: {2}\tContent: {3}\n",
                    template.Name, template.Language, template.Status, template.Content);
            }

            // Send Sample Template sample_template
            MessageTemplate sampleTemplate = AssembleSampleTemplate();
            var sampleTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, sampleTemplate);
            var result = await notificationMessagesClient.SendAsync(sampleTemplateContent);
            PrintResponse(result);
           
            // Send sample template sample_shipping_confirmation
            MessageTemplate shippingConfirmationTemplate = AssembleSampleShippingConfirmation();
            var shippingConfirmationTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, shippingConfirmationTemplate);
            result = await notificationMessagesClient.SendAsync(shippingConfirmationTemplateContent);
            PrintResponse(result);

            // Send sample template sample_movie_ticket_confirmation
            MessageTemplate movieTicketConfirmationTemplate = AssembleSampleMovieTicketConfirmation();
            var movieTicketConfirmationTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, movieTicketConfirmationTemplate);
            result = await notificationMessagesClient.SendAsync(movieTicketConfirmationTemplateContent);
            PrintResponse(result);

            // Send sample template sample_happy_hour_announcement
            MessageTemplate happyHourTemplate = AssembleSampleHappyHourAnnouncement();
            var happyHourTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, happyHourTemplate);
            result = await notificationMessagesClient.SendAsync(happyHourTemplateContent);
            PrintResponse(result);

            // Send sample template sample_flight_confirmation
            MessageTemplate flightConfirmationTemplate = AssembleSampleFlightConfirmation();
            var flightConfirmationTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, flightConfirmationTemplate);
            result = await notificationMessagesClient.SendAsync(flightConfirmationTemplateContent);
            PrintResponse(result);

            // Send sample template sample_issue_resolution
            MessageTemplate issueResolutionTemplate = AssembleSampleIssueResolution();
            var issueResolutionTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, issueResolutionTemplate);
            result = await notificationMessagesClient.SendAsync(issueResolutionTemplateContent);
            PrintResponse(result);

            // Send sample template sample_purchase_feedback
            MessageTemplate purchaseFeedbackTemplate = AssembleSamplePurchaseFeedback();
            var purchaseFeedbackTemplateContent = new TemplateNotificationContent(channelRegistrationId, recipientList, purchaseFeedbackTemplate);
            result = await notificationMessagesClient.SendAsync(purchaseFeedbackTemplateContent);
            PrintResponse(result);

            Console.WriteLine("Press any key to exit.");
            Console.ReadKey(true);
        }

        public static MessageTemplate AssembleSampleTemplate()
        {
            string templateName = "sample_template";
            string templateLanguage = "en_us";

            return new MessageTemplate(templateName, templateLanguage);
        }

        public static MessageTemplate AssembleSampleShippingConfirmation()
        {
            string templateName = "sample_shipping_confirmation";
            string templateLanguage = "en_us";

            var threeDays = new MessageTemplateText("threeDays", "3");

            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Body.Add(new(threeDays.Name));

            MessageTemplate shippingConfirmationTemplate = new(templateName, templateLanguage);
            shippingConfirmationTemplate.Bindings = bindings;
            shippingConfirmationTemplate.Values.Add(threeDays);

            return shippingConfirmationTemplate;
        }

        public static MessageTemplate AssembleSampleMovieTicketConfirmation()
        {
            string templateName = "sample_movie_ticket_confirmation"; 
            string templateLanguage = "en_us"; 
            var imageUrl = new Uri("https://aka.ms/acsicon1");

            var image = new MessageTemplateImage("image", imageUrl);
            var title = new MessageTemplateText("title", "Contoso");
            var time = new MessageTemplateText("time", "July 1st, 2023 12:30PM");
            var venue = new MessageTemplateText("venue", "Southridge Video");
            var seats = new MessageTemplateText("seats", "Seat 1A");

            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Header.Add(new(image.Name));
            bindings.Body.Add(new(title.Name));
            bindings.Body.Add(new(time.Name));
            bindings.Body.Add(new(venue.Name));
            bindings.Body.Add(new(seats.Name));

            MessageTemplate movieTicketConfirmationTemplate = new(templateName, templateLanguage);
            movieTicketConfirmationTemplate.Values.Add(image);
            movieTicketConfirmationTemplate.Values.Add(title);
            movieTicketConfirmationTemplate.Values.Add(time);
            movieTicketConfirmationTemplate.Values.Add(venue);
            movieTicketConfirmationTemplate.Values.Add(seats);
            movieTicketConfirmationTemplate.Bindings = bindings;

            return movieTicketConfirmationTemplate;
        }

        public static MessageTemplate AssembleSampleHappyHourAnnouncement()
        {
            string templateName = "sample_happy_hour_announcement";
            string templateLanguage = "en_us";
            var videoUrl = new Uri("< Your .mp4 Video URL >");

            var video = new MessageTemplateVideo("video", videoUrl);
            var venue = new MessageTemplateText("venue", "Fourth Coffee");
            var time = new MessageTemplateText("time", "Today 2-4PM");
            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Header.Add(new(video.Name));
            bindings.Body.Add(new(venue.Name));
            bindings.Body.Add(new(time.Name));

            MessageTemplate happyHourAnnouncementTemplate = new(templateName, templateLanguage);
            happyHourAnnouncementTemplate.Values.Add(venue);
            happyHourAnnouncementTemplate.Values.Add(time);
            happyHourAnnouncementTemplate.Values.Add(video);
            happyHourAnnouncementTemplate.Bindings = bindings;

            return happyHourAnnouncementTemplate;
        }

        public static MessageTemplate AssembleSampleFlightConfirmation()
        {
            string templateName = "sample_flight_confirmation";
            string templateLanguage = "en_us";
            var documentUrl = new Uri("< Your .pdf document URL >");

            var document = new MessageTemplateDocument("document", documentUrl);
            var firstName = new MessageTemplateText("firstName", "Kat");
            var lastName = new MessageTemplateText("lastName", "Larssen");
            var date = new MessageTemplateText("date", "July 1st, 2023");

            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Header.Add(new(document.Name));
            bindings.Body.Add(new(firstName.Name));
            bindings.Body.Add(new(lastName.Name));
            bindings.Body.Add(new(date.Name));

            MessageTemplate flightConfirmationTemplate = new(templateName, templateLanguage);
            flightConfirmationTemplate.Values.Add(document);
            flightConfirmationTemplate.Values.Add(firstName);
            flightConfirmationTemplate.Values.Add(lastName);
            flightConfirmationTemplate.Values.Add(date);
            flightConfirmationTemplate.Bindings = bindings;

            return flightConfirmationTemplate;
        }

        public static MessageTemplate AssembleSampleIssueResolution()
        {
            string templateName = "sample_issue_resolution";
            string templateLanguage = "en_us";

            var name = new MessageTemplateText(name: "name", text: "Kat");
            var yes = new MessageTemplateQuickAction(name: "Yes"){ Payload =  "Kat said yes" };
            var no = new MessageTemplateQuickAction(name: "No") { Payload = "Kat said no" };

            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Body.Add(new(name.Name));
            bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.QuickReply.ToString(), yes.Name));
            bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.QuickReply.ToString(), no.Name));

            MessageTemplate issueResolutionTemplate = new(templateName, templateLanguage);
            issueResolutionTemplate.Values.Add(name);
            issueResolutionTemplate.Values.Add(yes);
            issueResolutionTemplate.Values.Add(no);
            issueResolutionTemplate.Bindings = bindings;

            return issueResolutionTemplate;
        }

        public static MessageTemplate AssembleSamplePurchaseFeedback()
        {
            
            string templateName = "sample_purchase_feedback";
            string templateLanguage = "en_us";
            var imageUrl = new Uri("https://aka.ms/acsicon1");

            var image = new MessageTemplateImage(name: "image", uri: imageUrl);
            var product = new MessageTemplateText(name: "product", text: "coffee");
            var urlSuffix = new MessageTemplateQuickAction(name: "text") { Text = "survey-code"};
            
            WhatsAppMessageTemplateBindings bindings = new();
            bindings.Header.Add(new(image.Name));
            bindings.Body.Add(new(product.Name));
            bindings.Buttons.Add(new(WhatsAppMessageButtonSubType.Url.ToString(), urlSuffix.Name));

            MessageTemplate purchaseFeedbackTemplate = new(templateName, templateLanguage);
            purchaseFeedbackTemplate.Values.Add(image);
            purchaseFeedbackTemplate.Values.Add(product);
            purchaseFeedbackTemplate.Values.Add(urlSuffix);
            purchaseFeedbackTemplate.Bindings = bindings;

            return purchaseFeedbackTemplate;
        }

        public static void PrintResponse(Response<SendMessageResult> response)
        {
            Console.WriteLine($"Response: {response.GetRawResponse().Status} " +
                $"({response.GetRawResponse().ReasonPhrase})");
            Console.WriteLine($"Date: " +
                $"{response.GetRawResponse().Headers.First(header => header.Name == "Date").Value}");
            Console.WriteLine($"ClientRequestId: {response.GetRawResponse().ClientRequestId}");
            Console.WriteLine($"MS-CV: " +
                $"{response.GetRawResponse().Headers.First(header => header.Name == "MS-CV").Value}");
            foreach (var receipts in response.Value.Receipts)
            {
                Console.WriteLine($"MessageId: {receipts.MessageId}");
            }
            Console.WriteLine($"\n");
        }
    }
}

Plus d'exemples

Ces exemples utilisent des échantillons de modèles disponibles pour les comptes WhatsApp Business créés via l’inscription intégrée au portail Azure.

Utiliser un exemple de modèle sample_happy_hour_announcement

Cet exemple de modèle utilise une vidéo dans l’en-tête et deux paramètres de texte dans le corps.

L’en-tête du modèle nécessite une vidéo :

{
  "type": "HEADER",
  "format": "VIDEO"
},

La vidéo doit être une URL vers une vidéo mp4 hébergée.

Pour plus d’informations sur les types d’éléments multimédias pris en charge et les limites de taille, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Le corps du modèle nécessite deux paramètres de texte :

{
  "type": "BODY",
  "text": "Happy hour is here! 🍺😀🍸\nPlease be merry and enjoy the day. 🎉\nVenue: {{1}}\nTime: {{2}}"
},

Créez une variable MessageTemplateVideo et deux variables MessageTemplateText. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle.

string templateName = "sample_happy_hour_announcement";
string templateLanguage = "en_us";
var videoUrl = new Uri("< Your .mp4 Video URL >");

var video = new MessageTemplateVideo("video", videoUrl);
var venue = new MessageTemplateText("venue", "Fourth Coffee");
var time = new MessageTemplateText("time", "Today 2-4PM");
WhatsAppMessageTemplateBindings bindings = new();
bindings.Header.Add(new(video.Name));
bindings.Body.Add(new(venue.Name));
bindings.Body.Add(new(time.Name));

MessageTemplate happyHourAnnouncementTemplate = new(templateName, templateLanguage);
happyHourAnnouncementTemplate.Values.Add(venue);
happyHourAnnouncementTemplate.Values.Add(time);
happyHourAnnouncementTemplate.Values.Add(video);
happyHourAnnouncementTemplate.Bindings = bindings;

Utiliser un exemple de modèle sample_flight_confirmation

Cet exemple de modèle utilise un document dans l’en-tête et trois paramètres de texte dans le corps.

L’en-tête du modèle nécessite un document :

{
  "type": "HEADER",
  "format": "DOCUMENT"
},

Le document doit être une URL vers un document PDF hébergé.

Pour plus d’informations sur les types d’éléments multimédias pris en charge et les limites de taille, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Le corps du modèle nécessite trois paramètres de texte :

{
  "type": "BODY",
  "text": "This is your flight confirmation for {{1}}-{{2}} on {{3}}."
},

Créez une variable MessageTemplateDocument et trois variables MessageTemplateText. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle.

string templateName = "sample_flight_confirmation";
string templateLanguage = "en_us";
var documentUrl = new Uri("< Your .pdf document URL >");

var document = new MessageTemplateDocument("document", documentUrl);
var firstName = new MessageTemplateText("firstName", "Kat");
var lastName = new MessageTemplateText("lastName", "Larssen");
var date = new MessageTemplateText("date", "July 1st, 2023");

WhatsAppMessageTemplateBindings bindings = new();
bindings.Header.Add(new(document.Name));
bindings.Body.Add(new(firstName.Name));
bindings.Body.Add(new(lastName.Name));
bindings.Body.Add(new(date.Name));

MessageTemplate flightConfirmationTemplate = new(templateName, templateLanguage);
flightConfirmationTemplate.Values.Add(document);
flightConfirmationTemplate.Values.Add(firstName);
flightConfirmationTemplate.Values.Add(lastName);
flightConfirmationTemplate.Values.Add(date);
flightConfirmationTemplate.Bindings = bindings;

Prérequis

• Inscrire un compte WhatsApp Business auprès de votre ressource Azure Communication Services.
• Créer un message modèle WhatsApp.
• Numéro de téléphone WhatsApp actif devant recevoir des messages.

Modèle objet

Les classes et interfaces suivantes prennent en charge certaines des principales fonctionnalités du kit SDK Messages d’Azure Communication Services pour Java.

Nom de la classe	Description
NotificationMessagesClient	Se connecte à votre ressource Azure Communication Services. Elle envoie les messages.
MessageTemplate	Définit le modèle à utiliser ainsi que le contenu des propriétés du modèle pour votre message.
TemplateNotificationContent	Définit le « qui » et le « quoi » du modèle de message que vous avez l’intention d’envoyer.

Remarque

Pour plus d’informations, consultez la documentation de référence du kit Azure SDK pour Java sur Package com.azure.communication.messages.

Types de modèles WhatsApp pris en charge

Type de modèle	Description
Modèles de message basés sur du texte	Les modèles de message WhatsApp sont des formats de message spécifiques avec ou sans paramètres.
Modèles de message basés sur des éléments multimédias	Modèles de message WhatsApp avec des paramètres multimédias pour les composants d’en-tête.
Modèles de message interactif	Les modèles de message interactif permettent d’étendre le contenu que vous pouvez envoyer aux destinataires, en incluant des boutons interactifs à l’aide de l’objet components. Les appels à l’action et les réponses rapides sont pris en charge.
Modèles de message basés sur la localisation	Modèles de message WhatsApp avec des paramètres de localisation exprimés en longitude et latitude pour les composants d’en-tête.

Configuration commune

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction main de votre fichier App.java.

• Créer et gérer un modèle de message WhatsApp.
• Authentifier le client.
• Définir l’ID d’inscription de canal.
• Définir la liste de destinataires.

Créer et gérer un modèle de message WhatsApp

Les modèles de message WhatsApp sont des formats de message spécifiques que les entreprises utilisent pour envoyer des notifications ou des messages de support client aux personnes qui ont choisi de recevoir des notifications. Les messages peuvent inclure des rappels de rendez-vous, des informations d’expédition, une résolution de problème ou des notifications relatives aux paiements. Avant de commencer à utiliser le kit SDK de messagerie avancée pour envoyer des messages basés sur un modèle, l’utilisateur doit créer les modèles nécessaires sur la plateforme WhatsApp Business.

Pour plus d’informations sur les exigences de WhatsApp relatives aux modèles, consultez la documentation de référence sur les API de la plateforme WhatsApp Business :

• Créer et gérer des modèles.
• Voir les composants du modèle.
• Envoyer des messages issus d’un modèle.
• Les entreprises doivent également respecter les exigences d’adhésion avant d’envoyer des messages aux utilisateurs WhatsApp.

Commencer à envoyer des messages entre une entreprise et un utilisateur WhatsApp

Les conversations entre un compte WhatsApp Business et un utilisateur WhatsApp peuvent être lancées de deux manières :

• L’entreprise envoie un message modèle à l’utilisateur WhatsApp.
• L’utilisateur WhatsApp envoie n’importe quel message au numéro professionnel.

Quelle que soit la façon dont la conversation a été démarrée, une entreprise ne peut envoyer des modèles de messages qu’une fois que l’utilisateur a envoyé un message à l’entreprise. Ce n’est qu’une fois que l’utilisateur a envoyé un message à l’entreprise que celle-ci est autorisée à lui envoyer des messages multimédias ou des SMS pendant la conversation active. Une fois la fenêtre de conversation de 24 heures expirée, la conversation doit être relancée. Pour en savoir plus sur les conversations, consultez la définition sur le site Plateforme WhatsApp Business.

Authentifier le client

Il existe différentes options disponibles pour authentifier un client de message :

Chaîne de connexion

Pour authentifier un client, vous instanciez un NotificationMessagesClient ou MessageTemplateClient avec votre chaîne de connexion. Vous pouvez aussi initialiser le client avec n’importe quel client HTTP personnalisé qui implémente l’interface com.azure.core.http.HttpClient.

Par souci de simplicité, ce guide de démarrage rapide utilise une chaîne de connexion pour s’authentifier. Dans les environnements de production, nous vous recommandons d’utiliser des principaux de service.

Obtenez la chaîne de connexion de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le champ Connection string pour le Primary key. La chaîne de connexion est au format endpoint=https://{your Azure Communication Services resource name}.communication.azure.com/;accesskey={secret key}.

Définissez la variable d’environnement COMMUNICATION_SERVICES_CONNECTION_STRING sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_CONNECTION_STRING "<your connection string>"

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode main :

// You can get your connection string from your resource in the Azure portal.
String connectionString = System.getenv("COMMUNICATION_SERVICES_CONNECTION_STRING");

NotificationMessagesClient notificationClient = new NotificationMessagesClientBuilder()
    .connectionString(connectionString)
    .buildClient();

Microsoft Entra ID

Vous pouvez vous authentifier auprès de Microsoft Entra ID à l’aide de la bibliothèque Azure Identity.

Le package Azure.Identity fournit divers types d’informations d’identification que votre application peut utiliser afin de s’authentifier. Vous pouvez choisir parmi les différentes options permettant d’authentifier le client d’identité détaillées dans Identité Azure – Fournisseurs d’informations d’identification et Identité Azure – Authentifier le client. Cette option présente l’une des manières d’utiliser DefaultAzureCredential.

DefaultAzureCredential tente d’effectuer l’authentification via several mechanisms, et il se peut qu’il trouve ses informations d’identification d’authentification si vous êtes connecté à Visual Studio ou Azure CLI. Toutefois, cette option vous guide tout au long de la configuration avec des variables d’environnement.

Pour créer un objet DefaultAzureCredential :

1. Pour configurer votre application de principal de service, suivez les instructions fournies dans Création d’une application inscrite auprès de Microsoft Entra.

2. Définissez les variables d’environnement AZURE_CLIENT_ID, AZURE_CLIENT_SECRET et AZURE_TENANT_ID à l’aide de la sortie de la création de votre application.
   Ouvrez une fenêtre de console et entrez les commandes suivantes :

   setx AZURE_CLIENT_ID "<your app's appId>"
   setx AZURE_CLIENT_SECRET "<your app's password>"
   setx AZURE_TENANT_ID "<your app's tenant>"
   

   Après avoir ajouté les variables d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront les lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

3. Pour utiliser le fournisseur DefaultAzureCredential, ou d’autres fournisseurs d’informations d’identification fournis avec le kit SDK Azure, suivez les instructions expliquant comment inclure le package azure-identity dans Identité Azure – Inclure le package.

4. Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode Main.

   String endpoint = "https://<resource name>.communication.azure.com/";
   NotificationMessagesClient notificationClient =  new NotificationMessagesClientBuilder()
       .endpoint(endpoint)
       .credential(new DefaultAzureCredentialBuilder().build())
       .buildClient();
   

   Un objet DefaultAzureCredential doit être passé à ClientBuilder via la méthode credential(). Un point de terminaison doit également être défini via la méthode endpoint().

AzureKeyCredential

Les clients NotificationMessage ou MessageTemplate peuvent également être créés et authentifiés à l’aide du point de terminaison et des informations d’identification de la clé Azure acquis auprès d’une ressource Azure Communication dans le portail Microsoft Azure.

1. Ajouter l’importation

   import com.azure.core.credential.AzureKeyCredential;
   

2. Pour instancier un NotificationMessagesClient, ajoutez le code suivant à la méthode Main.

   String endpoint = "https://<resource name>.communication.azure.com";
   AzureKeyCredential azureKeyCredential = new AzureKeyCredential("<access key>");
   NotificationMessagesClient notificationClient = new NotificationMessagesClientBuilder()
       .endpoint(endpoint)
       .credential(azureKeyCredential)
       .buildClient();
   

Définir un ID d’inscription de canal

Le GUID de l’ID d’inscription de canal a été créé pendant l’inscription du canal. Vous pouvez le rechercher dans le portail sous l’onglet Canaux de votre ressource Azure Communication Services.

Attribuez-le à une variable appelée channelRegistrationId.

String channelRegistrationId = "<your channel registration id GUID>";

Définir la liste des destinataires

Vous devez fournir un numéro de téléphone réel associé à un compte WhatsApp. Ce compte WhatsApp reçoit les messages textuels et multimédias envoyés dans ce guide de démarrage rapide. Pour ce guide de démarrage rapide, ce numéro de téléphone peut être votre numéro de téléphone personnel.

Le numéro de téléphone du destinataire ne peut pas être le numéro de téléphone professionnel (ID d’expéditeur) associé à l’inscription du canal WhatsApp. L’ID d’expéditeur s’affiche comme étant l’expéditeur des messages textuels et multimédias envoyés au destinataire.

Le numéro de téléphone doit inclure le code du pays. Pour plus d’informations sur la mise en forme des numéros de téléphone, consultez la documentation WhatsApp sur les Formats des numéros de téléphone.

Remarque

Un seul numéro de téléphone est actuellement pris en charge dans la liste des destinataires.

Créez la liste des destinataires de la façon suivante :

List<String> recipientList = new ArrayList<>();
recipientList.add("<to WhatsApp phone number>");

Exemple :

// Example only
List<String> recipientList = new ArrayList<>();
recipientList.add("+14255550199");

Configurer l’environnement

Pour configurer un environnement d’envoi de messages, suivez les étapes décrites dans les sections ci-dessous.

Prérequis

• Compte WhatsApp Business inscrit auprès de votre ressource Azure Communication Services.
• Numéro de téléphone WhatsApp actif devant recevoir des messages.
• Kit de développement Java (JDK), version 8 ou ultérieure
• Apache Maven.

Créer une application Java

Ouvrez une fenêtre de terminal ou une fenêtre Commande, puis accédez au répertoire dans lequel vous souhaitez créer votre application Java. Exécutez la commande suivante pour générer le projet Java à partir du modèle maven-archetype-quickstart.

mvn archetype:generate -DgroupId="com.communication.quickstart" -DartifactId="communication-quickstart" -DarchetypeArtifactId="maven-archetype-quickstart" -DarchetypeVersion="1.4" -DinteractiveMode="false"

L’objectif generate crée un répertoire qui porte le même nom que la valeur artifactId. Sous ce répertoire, le répertoire src/main/java contient le code source du projet, le répertoire src/test/java contient la source de test, et le fichier pom.xml correspond au modèle POM (modèle objet de projet) du projet.

Installer le package

Ouvrez le fichier pom.xml dans votre éditeur de texte. Ajoutez l’élément dépendance suivant au groupe de dépendances.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-messages</artifactId>
</dependency>

Configurer le framework d’application

Ouvrez /src/main/java/com/communication/quickstart/App.java dans un éditeur de texte, ajoutez des directives import, puis supprimez l’instruction System.out.println("Hello world!"); :

package com.communication.quickstart;

import com.azure.communication.messages.*;
import com.azure.communication.messages.models.*;

import java.util.ArrayList;
import java.util.List;
public class App
{
    public static void main( String[] args )
    {
        // Quickstart code goes here.
    }
}

Exemples de code

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction main de votre fichier App.java.

• Lister les modèles WhatsApp dans le portail Azure.
• Envoyer un modèle de message avec des paramètres de texte dans le corps.
• Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête.
• Envoyer un modèle de message avec des boutons de réponse rapide.
• Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique.

Lister les modèles WhatsApp dans le portail Azure

Pour voir vos modèles dans le portail Azure, accédez à votre ressource Azure Communication Services >Messagerie avancée>Modèles.

Sélection d’un modèle pour voir les détails du modèle.

Le champ Contenu des détails du modèle peut inclure des liaisons de paramètres. Les liaisons de paramètres peuvent être désignées comme suit :

• Champ "format" avec une valeur telle que IMAGE.
• Crochets doubles entourant un nombre, tels que {{1}}. Le nombre, dont l’index commence à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message.

Vous pouvez également voir et modifier tous les modèles de votre compte WhatsApp Business dans Gestionnaire WhatsApp> Outils du compte >Modèles de message.

Pour lister vos modèles par programmation, vous pouvez récupérer tous les modèles de votre ID de canal à l’aide du code suivant :

public static void getMessageTemplateWithConnectionString() {
    MessageTemplateClient templateClient =
        new MessageTemplateClientBuilder()
            .connectionString(connectionString)
            .buildClient();

    PagedIterable<MessageTemplateItem> response = templateClient.listTemplates(channelRegistrationId);

    response.stream().forEach(t -> {
        WhatsAppMessageTemplateItem template = (WhatsAppMessageTemplateItem) t ;
        System.out.println("===============================");
        System.out.println("Template Name :: "+template.getName());
        System.out.println("Template Language :: "+template.getLanguage());
        System.out.println("Template Status :: "+template.getStatus());
        System.out.println("Template Content :: "+template.getContent());
        System.out.println("===============================");
    });
    }

Envoyer un modèle de message avec des paramètres de texte dans le corps

Si le modèle n’accepte aucun paramètre, vous n’avez pas besoin de fournir de valeurs ou de liaisons au moment de la création de MessageTemplate.

 /*
    * This sample shows how to send template message with below details
    * Name: sample_shipping_confirmation, Language: en_US
    *  [
          {
            "type": "BODY",
            "text": "Your package has been shipped. It will be delivered in {{1}} business days."
          },
          {
            "type": "FOOTER",
            "text": "This message is from an unverified business."
          }
        ]
* */
private static void sendTemplateMessage() {

    //Update Template Name and language according your template associate to your channel.
    MessageTemplate template = new MessageTemplate("sample_shipping_confirmation", "en_US");

    //Update template parameter type and value
    List<MessageTemplateValue> messageTemplateValues = new ArrayList<>();
    messageTemplateValues.add(new MessageTemplateText("Days", "5"));
    template.setValues(messageTemplateValues);

    //Update template parameter binding
    List<WhatsAppMessageTemplateBindingsComponent> components = new ArrayList<>();
    components.add(new WhatsAppMessageTemplateBindingsComponent("Days"));
    MessageTemplateBindings bindings =new WhatsAppMessageTemplateBindings()
        .setBody(components);
    template.setBindings(bindings);

    NotificationMessagesClient client = createClientWithTokenCredential();
    SendMessageResult result = client.send(
        new TemplateNotificationContent(CHANNEL_ID, recipients, template));

    result.getReceipts().forEach(r -> System.out.println("Message sent to:"+r.getTo() + " and message id:"+ r.getMessageId()));
    }

Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête

Utilisez MessageTemplateImage, MessageTemplateVideoou MessageTemplateDocument pour définir le paramètre média dans un en-tête.

Définition de modèle avec un paramètre multimédia d’image dans l’en-tête :

{
  "type": "HEADER",
  "format": "VIDEO"
},

"format" peut correspondre à l’un des quatre types d’éléments multimédias différents pris en charge par WhatsApp. Dans le kit SDK .NET, chaque type d’élément multimédia utilise un type MessageTemplateValue correspondant.

Format	Type MessageTemplateValue	Type de fichier
IMAGE	MessageTemplateImage	png, jpg
VIDÉO	MessageTemplateVideo	mp4
DOCUMENT	MessageTemplateDocument	pdf

Pour plus d’informations sur les types d’éléments multimédias pris en charge et les limites de taille, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Exemple

Modèle sample_happy_hour_announcement :

Ici, l’en-tête du modèle nécessite une vidéo :

{
  "type": "HEADER",
  "format": "VIDEO"
},

La vidéo doit être une URL vers une vidéo mp4 hébergée.

Pour plus d’informations sur les types d’éléments multimédias pris en charge et les limites de taille, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Le corps du modèle nécessite deux paramètres de texte :

{
  "type": "BODY",
  "text": "Happy hour is here! 🍺😀🍸\nPlease be merry and enjoy the day. 🎉\nVenue: {{1}}\nTime: {{2}}"
},

Créez une variable MessageTemplateVideo et quatre variables MessageTemplateText. Ensuite, assemblez votre liste de MessageTemplateValue et votre MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre dans lequel les paramètres apparaissent dans le contenu du modèle.

 /*
    * This sample shows how to send template message with below details
    * Name: sample_happy_hour_announcement, Language: en_US
    *  [
          {
            "type": "HEADER",
            "format": "VIDEO"
          },
          {
            "type": "BODY",
            "text": "Happy hour is here! 🍺😀🍸\nPlease be merry and enjoy the day. 🎉\nVenue: {{1}}\nTime: {{2}}"
          },
          {
            "type": "FOOTER",
            "text": "This message is from an unverified business."
          }
        ]
* */
private static void sendTemplateMessageWithVideo() {

    //Update Template Name and language according your template associate to your channel.
    MessageTemplate template = new MessageTemplate("sample_happy_hour_announcement", "en_US");

    //Add template parameter type with value in a list
    List<MessageTemplateValue> messageTemplateValues = new ArrayList<>();
    messageTemplateValues.add(new MessageTemplateVideo("HeaderVideo", "https://sample-videos.com/video123/mp4/720/big_buck_bunny_720p_1mb.mp4"));
    messageTemplateValues.add(new MessageTemplateText("VenueInfoInBody", "Starbucks"));
    messageTemplateValues.add(new MessageTemplateText("TimeInfoInBody", "Today 2-4PM"));

    // Add parameter binding for template header in a list
    List<WhatsAppMessageTemplateBindingsComponent> templateHeaderBindings = new ArrayList<>();
    templateHeaderBindings.add(new WhatsAppMessageTemplateBindingsComponent("HeaderVideo"));

    // Add parameter binding for template body in a list
    List<WhatsAppMessageTemplateBindingsComponent> templateBodyBindings = new ArrayList<>();
    templateBodyBindings.add(new WhatsAppMessageTemplateBindingsComponent("VenueInfoInBody"));
    templateBodyBindings.add(new WhatsAppMessageTemplateBindingsComponent("TimeInfoInBody"));

    MessageTemplateBindings templateBindings = new WhatsAppMessageTemplateBindings()
        .setHeaderProperty(templateHeaderBindings) // Set the parameter binding for template header
        .setBody(templateBodyBindings); // Set the parameter binding for template body

    template
        .setBindings(templateBindings)
        .setValues(messageTemplateValues);

    NotificationMessagesClient client = createClientWithConnectionString();
    SendMessageResult result = client.send(
        new TemplateNotificationContent(CHANNEL_ID, recipients, template));

    result.getReceipts().forEach(r -> System.out.println("Message sent to:"+r.getTo() + " and message id:"+ r.getMessageId()));
}

Envoyer un modèle de message avec des boutons de réponse rapide

Utilisez MessageTemplateQuickAction pour définir la charge utile des boutons de réponse rapide. Les objets MessageTemplateQuickAction ont les trois attributs suivants.

Propriétés	Description	Type
Nom	name utilisé pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text facultatif de l’action rapide.	string
Charge utile	payload affecté à un bouton disponible dans une réponse à un message si l’utilisateur sélectionne le bouton.	string

Définition de modèle avec des boutons de réponse rapide :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "QUICK_REPLY",
      "text": "Yes"
    },
    {
      "type": "QUICK_REPLY",
      "text": "No"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Pour plus d’informations sur la charge utile des réponses rapides de l’utilisateur, consultez la documentation de WhatsApp relative à un Rappel reçu à partir d’un bouton de réponse rapide.

Exemple

Modèle sample_issue_resolution :

Le corps du modèle nécessite un paramètre de texte :

/*
    * This sample shows how to send template message with below details
    * Name: sample_issue_resolution, Language: en_US
    *  [
          {
            "type": "BODY",
            "text": "Hi {{1}}, were we able to solve the issue that you were facing?"
          },
          {
            "type": "FOOTER",
            "text": "This message is from an unverified business."
          },
          {
            "type": "BUTTONS",
            "buttons": [
              {
                "type": "QUICK_REPLY",
                "text": "Yes"
              },
              {
                "type": "QUICK_REPLY",
                "text": "No"
              }
            ]
          }
        ]
* */
private static void sendTextTemplateMessageWithQuickReply() {

    //Add template parameter type with value in a list
    List<MessageTemplateValue> messageTemplateValues = new ArrayList<>();
    messageTemplateValues.add(new MessageTemplateText("Name", "Arif"));
    messageTemplateValues.add(new MessageTemplateQuickAction("Yes").setPayload("Yes"));
    messageTemplateValues.add(new MessageTemplateQuickAction("No").setPayload("No"));

    // Add parameter binding for template body in a list
    List<WhatsAppMessageTemplateBindingsComponent> templateBodyBindings = new ArrayList<>();
    templateBodyBindings.add(new WhatsAppMessageTemplateBindingsComponent("Name"));

    // Add parameter binding for template buttons in a list
    List<WhatsAppMessageTemplateBindingsButton> templateButtonBindings = new ArrayList<>();
    templateButtonBindings.add( new WhatsAppMessageTemplateBindingsButton(WhatsAppMessageButtonSubType.QUICK_REPLY, "Yes"));
    templateButtonBindings.add( new WhatsAppMessageTemplateBindingsButton(WhatsAppMessageButtonSubType.QUICK_REPLY, "No"));

    MessageTemplateBindings templateBindings = new WhatsAppMessageTemplateBindings()
        .setBody(templateBodyBindings) // Set the parameter binding for template body
        .setButtons(templateButtonBindings); // Set the parameter binding for template buttons

    MessageTemplate messageTemplate = new MessageTemplate("sample_issue_resolution", "en_US")
        .setBindings(templateBindings)
        .setValues(messageTemplateValues);

    NotificationMessagesClient client = createClientWithConnectionString();
    SendMessageResult result = client.send(
        new TemplateNotificationContent(CHANNEL_ID, recipients, messageTemplate));

    result.getReceipts().forEach(r -> System.out.println("Message sent to:"+r.getTo() + " and message id:"+ r.getMessageId()));
}

Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique

Utilisez MessageTemplateQuickAction pour définir le suffixe d’URL des boutons d’appel à l’action. L’objet MessageTemplateQuickAction a les deux attributs suivants.

Propriétés	Description	Type
Nom	name utilisé pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text ajouté à l’URL.	string

Boutons de définition de modèle :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Exemple

Modèle sample_purchase_feedback :

Cet exemple de modèle ajoute un bouton avec un lien d’URL dynamique au message. Il utilise également une image dans l’en-tête et un paramètre de texte dans le corps.

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Thank you for purchasing {{1}}! We value your feedback and would like to learn more about your experience."
},

Le modèle comprend un bouton d’URL dynamique avec un paramètre :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

Créez une variable MessageTemplateImage, une variable MessageTemplateTextet une variable MessageTemplateQuickAction. Ensuite, assemblez votre liste de MessageTemplateValue et votre MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre dans lequel les paramètres apparaissent dans le contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

/*
* This sample shows how to send template message with below details
* Name: sample_purchase_feedback, Language: en_US
*  [
        {
        "type": "HEADER",
        "format": "IMAGE"
        },
        {
        "type": "BODY",
        "text": "Thank you for purchasing {{1}}! We value your feedback and would like to learn more about your experience."
        },
        {
        "type": "FOOTER",
        "text": "This message is from an unverified business."
        },
        {
        "type": "BUTTONS",
        "buttons": [
            {
            "type": "URL",
            "text": "Take Survey",
            "url": "https://www.example.com/"
            }
        ]
        }
    ]
* */
private static void sendTemplateMessageWithImage() {

    //Update Template Name and language according your template associate to your channel.
    MessageTemplate template = new MessageTemplate("sample_purchase_feedback", "en_US");

    //Add template parameter type with value in a list
    List<MessageTemplateValue> messageTemplateValues = new ArrayList<>();
    messageTemplateValues.add(new MessageTemplateImage("HeaderImage", "https://upload.wikimedia.org/wikipedia/commons/3/30/Building92microsoft.jpg"));
    messageTemplateValues.add(new MessageTemplateText("ProductInfoInBody", "Microsoft Office"));

    // Add parameter binding for template header in a list
    List<WhatsAppMessageTemplateBindingsComponent> templateHeaderBindings = new ArrayList<>();
    templateHeaderBindings.add(new WhatsAppMessageTemplateBindingsComponent("HeaderImage"));

    // Add parameter binding for template body in a list
    List<WhatsAppMessageTemplateBindingsComponent> templateBodyBindings = new ArrayList<>();
    templateBodyBindings.add(new WhatsAppMessageTemplateBindingsComponent("ProductInfoInBody"));

    MessageTemplateBindings templateBindings = new WhatsAppMessageTemplateBindings()
        .setHeaderProperty(templateHeaderBindings) // Set the parameter binding for template header
        .setBody(templateBodyBindings); // Set the parameter binding for template body

    template
        .setBindings(templateBindings)
        .setValues(messageTemplateValues);

    NotificationMessagesClient client = createClientWithConnectionString();
    SendMessageResult result = client.send(
        new TemplateNotificationContent(CHANNEL_ID, recipients, template));

    result.getReceipts().forEach(r -> System.out.println("Message sent to:"+r.getTo() + " and message id:"+ r.getMessageId()));
}

Exécuter le code

1. Ouvrez le répertoire qui contient le fichier pom.xml, puis compilez le projet à l’aide de la commande mvn.

   mvn compile
   

2. Exécutez l’application en exécutant la commande mvn suivante.

   mvn exec:java -D"exec.mainClass"="com.communication.quickstart.App" -D"exec.cleanupDaemonThreads"="false"
   

Exemple de code complet

Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.

Prérequis

• Inscrire un compte WhatsApp Business auprès de votre ressource Azure Communication Services.
• Créer un message modèle WhatsApp.
• Numéro de téléphone WhatsApp actif devant recevoir des messages.
• Node.js versions Active LTS et Maintenance LTS (nous recommandons 8.11.1 et 10.14.1).
• Node.js versions Active LTS et Maintenance LTS (8.11.1 et 10.14.1 recommandées).
  • Dans une fenêtre de terminal ou de commande, exécutez node --version pour vérifier que Node.js est installé.

Modèle objet

Les classes et interfaces suivantes prennent en charge certaines des principales fonctionnalités du kit SDK Messages d’Azure Communication Services pour Javascript.

Nom de la classe	Description
NotificationMessagesClient	Se connecte à votre ressource Azure Communication Services. Elle envoie les messages.
MessageTemplate	Définit le modèle à utiliser ainsi que le contenu des propriétés du modèle pour votre message.
TemplateNotificationContent	Définit le « qui » et le « quoi » du modèle de message que vous avez l’intention d’envoyer.

Remarque

Pour plus d’informations, consultez la documentation de référence du kit Azure SDK pour JavaScript sur package @azure-rest/communication-messages

Types de modèles WhatsApp pris en charge

Type de modèle	Description
Modèles de message basés sur du texte	Les modèles de message WhatsApp sont des formats de message spécifiques avec ou sans paramètres.
Modèles de message basés sur des éléments multimédias	Modèles de message WhatsApp avec des paramètres multimédias pour les composants d’en-tête.
Modèles de message interactif	Les modèles de message interactif permettent d’étendre le contenu que vous pouvez envoyer aux destinataires, en incluant des boutons interactifs à l’aide de l’objet components. Les appels à l’action et les réponses rapides sont pris en charge.
Modèles de message basés sur la localisation	Modèles de message WhatsApp avec des paramètres de localisation exprimés en longitude et latitude pour les composants d’en-tête.

Configuration commune

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction main de votre fichier send-messages.js.

• Créer et gérer un modèle de message WhatsApp.
• Authentifier le client.
• Définir l’ID d’inscription de canal.
• Définir la liste de destinataires.

Créer et gérer un modèle de message WhatsApp

Les modèles de message WhatsApp sont des formats de message spécifiques que les entreprises utilisent pour envoyer des notifications ou des messages de support client aux personnes qui ont choisi de recevoir des notifications. Les messages peuvent inclure des rappels de rendez-vous, des informations d’expédition, une résolution de problème ou des notifications relatives aux paiements. Avant de commencer à utiliser le kit SDK de messagerie avancée pour envoyer des messages basés sur un modèle, l’utilisateur doit créer les modèles nécessaires sur la plateforme WhatsApp Business.

Pour plus d’informations sur les exigences de WhatsApp relatives aux modèles, consultez la documentation de référence sur les API de la plateforme WhatsApp Business :

• Créer et gérer des modèles.
• Voir les composants du modèle.
• Envoyer des messages issus d’un modèle.
• Les entreprises doivent également respecter les exigences d’adhésion avant d’envoyer des messages aux utilisateurs WhatsApp.

Commencer à envoyer des messages entre une entreprise et un utilisateur WhatsApp

Les conversations entre un compte WhatsApp Business et un utilisateur WhatsApp peuvent être lancées de deux manières :

• L’entreprise envoie un message modèle à l’utilisateur WhatsApp.
• L’utilisateur WhatsApp envoie n’importe quel message au numéro professionnel.

Quelle que soit la façon dont la conversation a été démarrée, une entreprise ne peut envoyer des modèles de messages qu’une fois que l’utilisateur a envoyé un message à l’entreprise. Ce n’est qu’une fois que l’utilisateur a envoyé un message à l’entreprise que celle-ci est autorisée à lui envoyer des messages multimédias ou des SMS pendant la conversation active. Une fois la fenêtre de conversation de 24 heures expirée, la conversation doit être relancée. Pour en savoir plus sur les conversations, consultez la définition sur le site Plateforme WhatsApp Business.

Authentifier le client

Chaîne de connexion

Le code suivant récupère la chaîne de connexion de la ressource à partir d’une variable d’environnement nommée COMMUNICATION_SERVICES_CONNECTION_STRING en utilisant le package dotenv.

Par souci de simplicité, ce guide de démarrage rapide utilise une chaîne de connexion pour s’authentifier. Dans les environnements de production, nous vous recommandons d’utiliser des principaux de service.

Obtenez la chaîne de connexion de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le champ Connection string pour le Primary key. La chaîne de connexion est au format endpoint=https://{your Azure Communication Services resource name}.communication.azure.com/;accesskey={secret key}.

Définissez la variable d’environnement COMMUNICATION_SERVICES_CONNECTION_STRING sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_CONNECTION_STRING "<your connection string>"

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier NotificationClient, ajoutez le code suivant à la méthode Main :

const NotificationClient = require("@azure-rest/communication-messages").default;

// Set Connection string
const connectionString = process.env["COMMUNICATION_SERVICES_CONNECTION_STRING"];

// Instantiate the client
const client = NotificationClient(connectionString);

Microsoft Entra ID

Vous pouvez vous authentifier auprès de Microsoft Entra ID à l’aide de la bibliothèque Azure Identity.

Le package @azure/identity fournit divers types d’informations d’identification que votre application peut utiliser afin de s’authentifier. Vous pouvez choisir parmi les différentes options permettant d’authentifier le client d’identité détaillées dans Identité Azure – Fournisseurs d’informations d’identification et Identité Azure – Authentifier le client. Cette option présente l’une des manières d’utiliser DefaultAzureCredential.

DefaultAzureCredential tente d’effectuer l’authentification via several mechanisms, et il se peut qu’il trouve ses informations d’identification d’authentification si vous êtes connecté à Visual Studio ou Azure CLI. Toutefois, cette option vous guide tout au long de la configuration avec des variables d’environnement.

Pour créer un objet DefaultAzureCredential :

1. Pour configurer votre application de principal de service, suivez les instructions fournies dans Création d’une application inscrite auprès de Microsoft Entra.

2. Définissez les variables d’environnement AZURE_CLIENT_ID, AZURE_CLIENT_SECRET et AZURE_TENANT_ID à l’aide de la sortie de la création de votre application.
   Ouvrez une fenêtre de console et entrez les commandes suivantes :

   setx AZURE_CLIENT_ID "<your app's appId>"
   setx AZURE_CLIENT_SECRET "<your app's password>"
   setx AZURE_TENANT_ID "<your app's tenant>"
   

   Après avoir ajouté les variables d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront les lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

3. Pour utiliser le fournisseur DefaultAzureCredential, ou d’autres fournisseurs d’informations d’identification fournis avec le kit SDK Azure, installez le package @azure/identity.

   npm install @azure/identity
   

4. Pour instancier un NotificationClient, ajoutez le code suivant à la méthode Main.

   const DefaultAzureCredential = require("@azure/identity").DefaultAzureCredential;
   const NotificationClient = require("@azure-rest/communication-messages").default;
   
   // Configure authentication
   const endpoint = "https://<resource name>.communication.azure.com";
   let credential = new DefaultAzureCredential();
   
   // Instantiate the client
   const client = NotificationClient(endpoint, credential);
   

AzureKeyCredential

Vous pouvez également vous authentifier avec un azureKeyCredential.

Obtenez le point de terminaison et la clé de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le Endpoint et le champ Key pour la clé primaire.

Définissez la variable d’environnement COMMUNICATION_SERVICES_KEY sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_KEY "<your key>"

Après avoir ajouté la variable d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront la lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier un NotificationClient, ajoutez le code suivant à la méthode Main :

const AzureKeyCredential = require("@azure/core-auth").AzureKeyCredential;
const NotificationClient = require("@azure-rest/communication-messages").default;

// Configure authentication
const endpoint = "https://<resource name>.communication.azure.com";
const credential = new AzureKeyCredential("<your key credential>");

// Instantiate the client
const client = NotificationClient(endpoint, credential);

Définir un ID d’inscription de canal

Le GUID de l’ID d’inscription de canal a été créé pendant l’inscription du canal. Vous pouvez le rechercher dans le portail sous l’onglet Canaux de votre ressource Azure Communication Services.

Attribuez-le à une variable appelée channelRegistrationId.

const channelRegistrationId = "<your channel registration id GUID>";

Définir la liste des destinataires

Vous devez fournir un numéro de téléphone réel associé à un compte WhatsApp. Ce compte WhatsApp reçoit les modèles de messages, les messages multimédias et les SMS envoyés dans ce guide de démarrage rapide. Pour ce guide de démarrage rapide, ce numéro de téléphone peut être votre numéro de téléphone personnel.

Le numéro de téléphone du destinataire ne peut pas être le numéro de téléphone professionnel (ID d’expéditeur) associé à l’inscription du canal WhatsApp. L’ID d’expéditeur s’affiche comme étant l’expéditeur des messages textuels et multimédias envoyés au destinataire.

Le numéro de téléphone doit inclure le code du pays. Pour plus d’informations sur la mise en forme des numéros de téléphone, consultez la documentation WhatsApp sur les Formats des numéros de téléphone.

Remarque

Un seul numéro de téléphone est actuellement pris en charge dans la liste des destinataires.

Créez la liste des destinataires de la façon suivante :

const recipientList = ["<to WhatsApp phone number>"];

Exemple :

// Example only
const recipientList = ["+14255550199"];

Configuration

Pour configurer un environnement d’envoi de messages, suivez les étapes décrites dans les sections ci-dessous.

Création d’une application Node.js

1. Créez un répertoire pour votre application, puis ouvrez-le dans une fenêtre de terminal ou une fenêtre Commande.

2. Exécutez la commande suivante :

   mkdir advance-messages-quickstart && cd advance-messages-quickstart
   

3. Exécutez la commande suivante pour créer un fichier package.json avec les paramètres par défaut.

   npm init -y
   

4. Utilisez un éditeur de texte pour créer un fichier appelé send-messages.js dans le répertoire racine du projet.

5. Ajoutez l’extrait de code suivant au fichier send-messages.js.

   async function main() {
       // Quickstart code goes here.
   }
   
   main().catch((error) => {
       console.error("Encountered an error while sending message: ", error);
       process.exit(1);
   });
   

Suivez la section ci-dessous pour ajouter le code source de cet exemple au fichier send-messages.js que vous avez créé.

Installer le package

Utilisez la commande npm install pour installer le kit SDK Messagerie avancée Azure Communication Services pour JavaScript.

npm install @azure-rest/communication-messages --save

L’option --save liste la bibliothèque comme dépendance dans votre fichier package.json.

Exemples de code

Suivez ces étapes pour ajouter les extraits de code nécessaires à la fonction main de votre fichier send-messages.js.

• Lister les modèles WhatsApp dans le portail Azure.
• Envoyer un modèle de message avec des paramètres de texte dans le corps.

Lister les modèles WhatsApp dans le portail Azure

Pour voir vos modèles dans le portail Azure, accédez à votre ressource Azure Communication Services >Messagerie avancée>Modèles.

Sélection d’un modèle pour voir les détails du modèle.

Le champ Contenu des détails du modèle peut inclure des liaisons de paramètres. Les liaisons de paramètres peuvent être désignées comme suit :

• Champ "format" avec une valeur telle que IMAGE.
• Crochets doubles entourant un nombre, tels que {{1}}. Le nombre, dont l’index commence à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message.

Vous pouvez également voir et modifier tous les modèles de votre compte WhatsApp Business dans Gestionnaire WhatsApp> Outils du compte >Modèles de message.

Pour lister vos modèles par programmation, vous pouvez récupérer tous les modèles de votre ID de canal à l’aide du code suivant :

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

/**
 * @summary Get Template list for a channel
 */

const MessageTemplateClient = require("@azure-rest/communication-messages").default,
  { isUnexpected } = require("@azure-rest/communication-messages");

// Load the .env file if it exists
require("dotenv").config();

async function main() {
  const connectionString = process.env.COMMUNICATION_LIVETEST_STATIC_CONNECTION_STRING || "";
  const client = MessageTemplateClient(connectionString);
  console.log("Fetch Templates...");
  const response = await client
    .path("/messages/channels/{channelId}/templates", process.env.CHANNEl_ID || "")
    .get({
      queryParameters: { maxPageSize: 2 },
    });

  if (isUnexpected(response)) {
    throw new Error("Failed to get template for the channel.");
  }

  // The paginate helper creates a paged async iterator using metadata from the first page.
  const items = paginate(client, response);

  // We get an PageableAsyncIterator so we need to do `for await`.
  for await (const item of items) {
    console.log(JSON.stringify(item, null, 2));
  }
}

main().catch((error) => {
  console.error("Encountered an error while sending message: ", error);
  throw error;
});

Envoyer un modèle de message avec des paramètres de texte dans le corps

Modèle sample_shipping_confirmation :

Dans cet exemple, le corps du modèle a un paramètre :

{
  "type": "BODY",
  "text": "Your package has been shipped. It will be delivered in {{1}} business days."
},

Les paramètres sont définis avec les valeurs values et les liaisons bindings. Utilisez les valeurs et les liaisons pour assembler l’objet template.

 /*
    * This sample shows how to send template message with below details
    * Name: sample_shipping_confirmation, Language: en_US
    *  [
          {
            "type": "BODY",
            "text": "Your package has been shipped. It will be delivered in {{1}} business days."
          },
          {
            "type": "FOOTER",
            "text": "This message is from an unverified business."
          }
        ]
* */
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

/**
 * @summary Use AAD token credentials when sending a whatsapp template message.
 */

const { isNode } = require("@azure/core-util");
const { ClientSecretCredential, DefaultAzureCredential } = require("@azure/identity");
const NotificationClient = require("@azure-rest/communication-messages").default,
  { isUnexpected } = require("@azure-rest/communication-messages");

// Load the .env file if it exists
require("dotenv").config();

async function main() {
  // You will need to set this environment variable or edit the following values
  const endpoint = process.env.ACS_URL || "";

  // Azure AD Credential information is required to run this sample:
  if (
    !process.env.AZURE_TENANT_ID ||
    !process.env.AZURE_CLIENT_ID ||
    !process.env.AZURE_CLIENT_SECRET
  ) {
    console.error(
      "Azure AD authentication information not provided, but it is required to run this sample. Exiting.",
    );
    return;
  }

  // get credentials
  const credential = isNode
    ? new DefaultAzureCredential()
    : new ClientSecretCredential(
        process.env.AZURE_TENANT_ID,
        process.env.AZURE_CLIENT_ID,
        process.env.AZURE_CLIENT_SECRET,
      );

  const client = NotificationClient(endpoint, credential);

  const DaysTemplateValue = {
    kind: "text",
    name: "Days",
    text: "5",
  };

  const templateBindings = {
    kind: "whatsApp",
    body: [
      {
        refValue: "Days",
      },
    ],
  };

  const template = {
    name: "sample_shipping_confirmation",
    language: "en_US",
    bindings: templateBindings,
    values: [DaysTemplateValue],
  };

  const result = await client.path("/messages/notifications:send").post({
    contentType: "application/json",
    body: {
      channelRegistrationId: process.env.CHANNEL_ID || "",
      to: [process.env.RECIPIENT_PHONE_NUMBER || ""],
      kind: "template",
      template: template,
    },
  });

  console.log("Response: " + JSON.stringify(result, null, 2));

  if (isUnexpected(result)) {
    throw new Error("Failed to send message");
  }

  const response = result;
  response.body.receipts.forEach((receipt) => {
    console.log("Message sent to:" + receipt.to + " with message id:" + receipt.messageId);
  });
}

main().catch((error) => {
  console.error("Encountered an error while sending message: ", error);
  throw error;
});

module.exports = { main };

Exécuter le code

Utilisez la commande node pour exécuter le code que vous avez ajouté au fichier send-messages.js.

node ./send-messages.js

Exemple de code complet

Vous trouverez le code finalisé de cet exemple sur GitHub.

Prérequis

• Inscrire un compte WhatsApp Business auprès de votre ressource Azure Communication Services.
• Créer un message modèle WhatsApp.
• Numéro de téléphone WhatsApp actif devant recevoir des messages.

Modèle objet

Les classes et les interfaces suivantes gèrent certaines des principales fonctionnalités du SDK Azure Communication Services Messages pour Python.

Nom de la classe	Description
NotificationMessagesClient	Se connecte à votre ressource Azure Communication Services. Elle envoie les messages.
MessageTemplate	Définit le modèle à utiliser ainsi que le contenu des propriétés du modèle pour votre message.
TemplateNotificationContent	Définit le « qui » et le « quoi » du modèle de message que vous avez l’intention d’envoyer.

Remarque

Pour plus d’informations, consultez la documentation de référence du kit Azure SDK pour Python sur Package messages.

Types de modèles WhatsApp pris en charge

Type de modèle	Description
Modèles de message basés sur du texte	Les modèles de message WhatsApp sont des formats de message spécifiques avec ou sans paramètres.
Modèles de message basés sur des éléments multimédias	Modèles de message WhatsApp avec des paramètres multimédias pour les composants d’en-tête.
Modèles de message interactif	Les modèles de message interactif permettent d’étendre le contenu que vous pouvez envoyer aux destinataires, en incluant des boutons interactifs à l’aide de l’objet components. Les appels à l’action et les réponses rapides sont pris en charge.
Modèles de message basés sur la localisation	Modèles de message WhatsApp avec des paramètres de localisation exprimés en longitude et latitude pour les composants d’en-tête.

Configuration commune

Suivez ces étapes pour ajouter les extraits de code nécessaires au programme Python messages-quickstart.py.

• Créer et gérer un modèle de message WhatsApp.
• Authentifier le client.
• Définir l’ID d’inscription de canal.
• Définir la liste de destinataires.

Créer et gérer un modèle de message WhatsApp

Les modèles de message WhatsApp sont des formats de message spécifiques que les entreprises utilisent pour envoyer des notifications ou des messages de support client aux personnes qui ont choisi de recevoir des notifications. Les messages peuvent inclure des rappels de rendez-vous, des informations d’expédition, une résolution de problème ou des notifications relatives aux paiements. Avant de commencer à utiliser le kit SDK de messagerie avancée pour envoyer des messages basés sur un modèle, l’utilisateur doit créer les modèles nécessaires sur la plateforme WhatsApp Business.

Pour plus d’informations sur les exigences de WhatsApp relatives aux modèles, consultez la documentation de référence sur les API de la plateforme WhatsApp Business :

• Créer et gérer des modèles.
• Voir les composants du modèle.
• Envoyer des messages issus d’un modèle.
• Les entreprises doivent également respecter les exigences d’adhésion avant d’envoyer des messages aux utilisateurs WhatsApp.

Authentifier le client

L’envoi de messages est effectué à l’aide de NotificationMessagesClient. NotificationMessagesClient est authentifié à l’aide de la chaîne de connexion acquise à partir d’une ressource Azure Communication Services dans le portail Azure. Pour plus d’informations sur les chaînes de connexion, consultez Accéder à vos chaînes de connexion et points de terminaison de service à l’aide d’Azure CLI.

Chaîne de connexion

Obtenez la chaîne de connexion à la ressource de communication Azure à partir du Portail Microsoft Azure comme indiqué dans la capture d’écran. Sur la gauche, accédez à l’onglet Keys. Copiez le champ Connection string de la clé primaire. La chaîne de connexion est au format endpoint=https://{your Azure Communication Services resource name}.communication.azure.com/;accesskey={secret key}.

Définissez la variable d’environnement COMMUNICATION_SERVICES_CONNECTION_STRING sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_CONNECTION_STRING "<your connection string>"

Après avoir ajouté la variable d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront la lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

    # Get a connection string to our Azure Communication Services resource.
    connection_string = os.getenv("COMMUNICATION_SERVICES_CONNECTION_STRING")
    
    def send_template_message(self):
        from azure.communication.messages import NotificationMessagesClient

        # Create NotificationMessagesClient Client
        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

Microsoft Entra ID

NotificationMessagesClient est également authentifié à l’aide de Microsoft Entra ID/TokenCredentials. Pour plus d'informations, consultez access-Azure-Communication-Resources-using-TokenCredentials.

Le package azure.identity fournit divers types d’informations d’identification que votre application peut utiliser afin de s’authentifier. Vous pouvez choisir parmi les différentes options permettant d’authentifier le client d’identité détaillées dans Identité Azure – Fournisseurs d’informations d’identification et Identité Azure – Authentifier le client. Cette option présente l’une des manières d’utiliser DefaultAzureCredential.

DefaultAzureCredential tente d’effectuer l’authentification via several mechanisms, et il se peut qu’il trouve ses informations d’identification d’authentification si vous êtes connecté à Visual Studio ou Azure CLI. Toutefois, cette option vous guide tout au long de la configuration avec des variables d’environnement.

Pour créer un objet DefaultAzureCredential :

1. Pour configurer votre application de principal de service, suivez les instructions fournies dans Création d’une application inscrite auprès de Microsoft Entra.

2. Définissez les variables d’environnement AZURE_CLIENT_ID, AZURE_CLIENT_SECRET et AZURE_TENANT_ID à l’aide de la sortie de la création de votre application.
   Ouvrez une fenêtre de console et entrez les commandes suivantes :

   setx COMMUNICATION_SERVICES_ENDPOINT_STRING "<https://<resource name>.communication.azure.com>"
   setx AZURE_CLIENT_ID "<your app's appId>"
   setx AZURE_CLIENT_SECRET "<your app's password>"
   setx AZURE_TENANT_ID "<your app's tenant>"
   

   Après avoir ajouté les variables d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront les lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

3. Pour utiliser le fournisseur DefaultAzureCredential, ou d’autres fournisseurs d’informations d’identification fournis avec le kit SDK Azure, installez le package python azure.identity puis instanciez le client.

    # Get a connection string to our Azure Communication Services resource.
    endpoint_string = os.getenv("COMMUNICATION_SERVICES_ENDPOINT_STRING")
    
    def send_template_message(self):
        from azure.communication.messages import NotificationMessagesClient
        from azure.identity import DefaultAzureCredential

        # Create NotificationMessagesClient Client
        messaging_client = NotificationMessagesClient(endpoint=self.endpoint_string,
                                                    credential=DefaultAzureCredential())

AzureKeyCredential

Vous pouvez également vous authentifier avec un azureKeyCredential.

Obtenez le point de terminaison et la clé de votre ressource Azure Communication Services dans le portail Azure. Sur la gauche, accédez à l’onglet Keys. Copiez le Endpoint et le champ Key pour la clé primaire.

Définissez la variable d’environnement COMMUNICATION_SERVICES_KEY sur la valeur de votre chaîne de connexion.
Ouvrez une fenêtre de console et entrez la commande suivante :

setx COMMUNICATION_SERVICES_ENDPOINT_STRING "<https://<resource name>.communication.azure.com>"
setx COMMUNICATION_SERVICES_KEY "<your key>"

Après avoir ajouté la variable d’environnement, vous devrez peut-être redémarrer tous les programmes en cours d’exécution qui devront la lire, y compris la fenêtre de console. Par exemple, si vous utilisez Visual Studio comme éditeur, redémarrez Visual Studio avant d’exécuter l’exemple.

Pour plus d’informations sur la façon de définir une variable d’environnement pour votre système, suivez les étapes décrites dans Stocker votre chaîne de connexion dans une variable d’environnement.

Pour instancier un NotificationMessagesClient, ajoutez le code suivant :

    # Get a connection string to our Azure Communication Services resource.
    endpoint_string = os.getenv("COMMUNICATION_SERVICES_ENDPOINT_STRING")
    key = os.getenv("COMMUNICATION_SERVICES_KEY")

    def send_template_message(self):
        from azure.core.credentials import AzureKeyCredential
        from azure.communication.messages import NotificationMessagesClient

        # Create NotificationMessagesClient Client
        messaging_client = NotificationMessagesClient(endpoint=self.endpoint_string,
                                                    credential=AzureKeyCredential(self.key))

Définir un ID d’inscription de canal

Vous avez créé le GUID de l’ID d’inscription de canal durant l’inscription du canal. Vous le trouverez dans le portail, sous l’onglet Canaux de votre ressource Azure Communication Services.

Attribuez-le à une variable appelée channelRegistrationId.

    channelRegistrationId = os.getenv("WHATSAPP_CHANNEL_ID_GUID")

Définir la liste des destinataires

Vous devez fournir un numéro de téléphone actif associé à un compte WhatsApp. Ce compte WhatsApp reçoit les modèles de messages, les messages multimédias et les SMS envoyés dans ce guide de démarrage rapide.

Pour cet exemple, vous pouvez utiliser votre numéro de téléphone personnel.

Le numéro de téléphone du destinataire ne peut pas être le numéro de téléphone professionnel (ID d’expéditeur) associé à l’inscription du canal WhatsApp. L’ID d’expéditeur s’affiche comme étant l’expéditeur des messages textuels et multimédias envoyés au destinataire.

Le numéro de téléphone doit inclure l’indicatif téléphonique international. Pour plus d’informations sur la mise en forme des numéros de téléphone, consultez la documentation de WhatsApp relative aux formats des numéros de téléphone.

Remarque

Un seul numéro de téléphone est actuellement pris en charge dans la liste des destinataires.

Définissez la liste des destinataires de la façon suivante :

    phone_number = os.getenv("RECIPIENT_WHATSAPP_PHONE_NUMBER")

Exemple d’utilisation :

    # Example only
    to=[self.phone_number],

Commencer à envoyer des messages entre une entreprise et un utilisateur WhatsApp

Les conversations entre un compte WhatsApp Business et un utilisateur WhatsApp peuvent être lancées de deux manières :

• L’entreprise envoie un message modèle à l’utilisateur WhatsApp.
• L’utilisateur WhatsApp envoie n’importe quel message au numéro professionnel.

Une entreprise ne peut pas lancer une conversation interactive. Une entreprise peut uniquement envoyer un message interactif après avoir reçu un message de l’utilisateur. L’entreprise peut uniquement envoyer des messages interactifs à l’utilisateur durant la conversation active. Une fois la fenêtre de conversation de 24 heures expirée, seul l’utilisateur peut relancer la conversation interactive. Pour plus d’informations sur les conversations, consultez la définition sur le site Plateforme WhatsApp Business.

Pour lancer une conversation interactive à partir de votre compte WhatsApp personnel, envoyez un message à votre numéro professionnel (ID de l’expéditeur).

Configurer l’environnement

Créer une application Python

Dans une fenêtre de terminal ou de console, créez un dossier pour votre application, puis ouvrez-le.

mkdir messages-quickstart && cd messages-quickstart

Installer le package

Utilisez la bibliothèque de client Azure Communication Messages pour Python 1.1.0 ou une version ultérieure.

À partir d’une invite de console, exécutez la commande suivante :

pip install azure-communication-messages

Pour InteractiveMessages, Reactions et Stickers, utilisez la version bêta ci-dessous :

pip install azure-communication-messages==1.2.0b1

Configurer le framework d’application

Créez un nouveau fichier appelé messages-quickstart.py et ajoutez la structure de programme de base.

type nul > messages-quickstart.py   

Structure de programme basique

import os

class MessagesQuickstart(object):
    print("Azure Communication Services - Advanced Messages SDK Quickstart")

if __name__ == '__main__':
    messages = MessagesQuickstart()

Structure de programme basique

import os

class MessagesQuickstart(object):
    print("Azure Communication Services - Advanced Messages SDK Quickstart")

if __name__ == '__main__':
    messages = MessagesQuickstart()

Exemples de code

Suivez ces étapes pour ajouter les extraits de code nécessaires au programme Python messages-quickstart.py.

• Lister les modèles WhatsApp dans le portail Azure.
• Envoyer un modèle de message sans paramètres.
• Envoyer un modèle de message avec des paramètres de texte dans le corps.
• Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête.
• Envoyer un modèle de message avec la localisation dans l’en-tête.
• Envoyer un modèle de message avec des boutons de réponse rapide.
• Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique.

Lister les modèles WhatsApp dans le portail Azure

Vous pouvez voir vos modèles dans le portail Azure en accédant à votre ressource Azure Communication Service >Messagerie avancée>Modèles.

Sélectionnez un modèle pour voir les détails du modèle.

Le champ content des détails du modèle peut inclure des liaisons de paramètres. Les liaisons de paramètres peuvent être désignées comme suit :

• Champ format avec une valeur telle que IMAGE.
• Crochets doubles entourant un nombre, tels que {{1}}. Le nombre, dont l’index commence à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message.

Vous pouvez également afficher et modifier tous les modèles de votre compte WhatsApp Business dans les outils WhatsApp Manager> Compte >Modèles de message.

Pour lister vos modèles par programmation, vous pouvez récupérer tous les modèles de votre ID de canal comme suit :

def get_templates_list(self):

    from azure.communication.messages import MessageTemplateClient
    message_template_client = MessageTemplateClient.from_connection_string(self.connection_string)
    # calling send() with whatsapp message details
    template_list = message_template_client.list_templates(self.channel_id)
    count_templates = len(list(template_list))
    print("Successfully retrieved {} templates from channel_id {}.".format(count_templates, self.channel_id))

Envoyer un modèle de message sans paramètres

Si le modèle ne nécessite pas de paramètres, vous n’avez pas besoin de fournir de valeurs ou de liaisons au moment de la création de MessageTemplate.

Exemple

sample_template n’a pas de paramètres.

Assemblez MessageTemplate en référençant le nom et la langue du modèle cible.

input_template: MessageTemplate = MessageTemplate(name="gathering_invitation", language="ca")  # Name of the WhatsApp Template

Envoyer un modèle de message avec des paramètres de texte dans le corps

Utilisez MessageTemplateText pour définir des paramètres dans le corps indiqués avec des crochets doubles entourant un nombre, tels que {{1}}. Le nombre, dont l’index commence à 1, indique l’ordre dans lequel les valeurs de liaison doivent être fournies pour créer le modèle de message. L’inclusion de paramètres qui ne sont pas dans le modèle n’est pas valide.

Définition de modèle avec deux paramètres :

{
  "type": "BODY",
  "text": "Message with two parameters: {{1}} and {{2}}"
}

Exemples

Modèle sample_shipping_confirmation :

Dans cet exemple, le corps du modèle a un paramètre :

{
  "type": "BODY",
  "text": "Your package has been shipped. It will be delivered in {{1}} business days."
},

Définissez les paramètres à l’aide des valeurs MessageTemplateValue et des liaisons MessageTemplateWhatsAppBindings. Utilisez les valeurs et les liaisons pour assembler le MessageTemplate.

# Setting template options
templateName = "sample_shipping_confirmation"
templateLanguage = "en_us" 
shippingConfirmationTemplate: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
threeDays = MessageTemplateText(name="threeDays", text="3")
bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=threeDays.name)])
shippingConfirmationTemplate.bindings = bindings
shippingConfirmationTemplate.template_values=[threeDays]
template_options = TemplateNotificationContent(
    channel_registration_id=self.channel_id, to=[self.phone_number], template=shippingConfirmationTemplate
)

Envoyer un modèle de message avec un paramètre multimédia dans l’en-tête

Utilisez MessageTemplateImage, MessageTemplateVideoou MessageTemplateDocument pour définir le paramètre média dans un en-tête.

Définition de modèle avec un paramètre multimédia d’image dans l’en-tête :

{
  "type": "HEADER",
  "format": "IMAGE"
},

format peut comporter différents types d’éléments multimédias pris en charge par WhatsApp. Dans le kit SDK .NET, chaque type d’élément multimédia utilise un type MessageTemplateValue correspondant.

Format	Type MessageTemplateValue	Type de fichier
IMAGE	MessageTemplateImage	png, jpg
VIDÉO	MessageTemplateVideo	mp4
DOCUMENT	MessageTemplateDocument	pdf

Pour plus d’informations sur les types d’éléments multimédias pris en charge et les limites de taille, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Exemples

Modèle sample_movie_ticket_confirmation :

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite quatre paramètres de texte :

{
  "type": "BODY",
  "text": "Your ticket for *{{1}}*\n*Time* - {{2}}\n*Venue* - {{3}}\n*Seats* - {{4}}"
},

Créez une variable MessageTemplateImage et quatre variables MessageTemplateText. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle.

 # Setting template options
templateName = "sample_movie_ticket_confirmation"
templateLanguage = "en_us" 
imageUrl = "https://aka.ms/acsicon1"
sample_movie_ticket_confirmation: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
image = MessageTemplateImage(name="image", url=imageUrl)
title = MessageTemplateText(name="title", text="Contoso")
time = MessageTemplateText(name="time", text="July 1st, 2023 12:30PM")
venue = MessageTemplateText(name="venue", text="Southridge Video")
seats = MessageTemplateText(name="seats", text="Seat 1A")

bindings = WhatsAppMessageTemplateBindings(header=[WhatsAppMessageTemplateBindingsComponent(ref_value=image.name)],
                                            body=[WhatsAppMessageTemplateBindingsComponent(ref_value=title.name),
                                                    WhatsAppMessageTemplateBindingsComponent(ref_value=time.name),
                                                    WhatsAppMessageTemplateBindingsComponent(ref_value=venue.name),
                                                    WhatsAppMessageTemplateBindingsComponent(ref_value=seats.name)])
sample_movie_ticket_confirmation.bindings = bindings
sample_movie_ticket_confirmation.template_values=[image,title,time,venue,seats]
template_options = TemplateNotificationContent(
    channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_movie_ticket_confirmation)

Envoyer un modèle de message avec des boutons de réponse rapide

Utilisez MessageTemplateQuickAction pour définir la charge utile des boutons de réponse rapide. Les objets MessageTemplateQuickAction ont les trois attributs suivants.

Propriétés	Description	Type
Nom	name pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text facultatif de l’action rapide.	string
Charge utile	payload affecté à un bouton disponible dans une réponse à un message si l’utilisateur sélectionne le bouton.	string

Définition de modèle avec des boutons de réponse rapide :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "QUICK_REPLY",
      "text": "Yes"
    },
    {
      "type": "QUICK_REPLY",
      "text": "No"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Pour plus d’informations sur la charge utile des réponses rapides de l’utilisateur, consultez la documentation de WhatsApp relative à un Rappel reçu à partir d’un bouton de réponse rapide.

Exemple

Modèle sample_issue_resolution :

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Hi {{1}}, were we able to solve the issue that you were facing?"
},

Le modèle comprend deux boutons de réponse préremplis, Yes et No.

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "QUICK_REPLY",
      "text": "Yes"
    },
    {
      "type": "QUICK_REPLY",
      "text": "No"
    }
  ]
}

Créez une variable MessageTemplateText et deux variables MessageTemplateQuickAction. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

# Setting template options
templateName = "sample_issue_resolution"
templateLanguage = "en_us" 
shippingConfirmationTemplate: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
name = MessageTemplateText(name="first", text="Joe")
yes = MessageTemplateQuickAction(name="Yes", payload="Joe said yes")
no = MessageTemplateQuickAction(name="No", payload = "Joe said no")
bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)])
bindings.buttons = [WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.QUICK_REPLY, ref_value=yes.name),
                    WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.QUICK_REPLY, ref_value=no.name)]
shippingConfirmationTemplate.bindings = bindings
shippingConfirmationTemplate.template_values=[name,yes,no]
template_options = TemplateNotificationContent(
    channel_registration_id=self.channel_id, to=[self.phone_number], template=shippingConfirmationTemplate
)

Envoyer un modèle de message avec la localisation dans l’en-tête

Utilisez MessageTemplateLocation pour définir le paramètre d’emplacement dans un en-tête.

Définition de modèle pour le composant d’en-tête nécessitant un emplacement comme suit :

{
  "type": "header",
  "parameters": [
    {
      "type": "location",
      "location": {
        "latitude": "<LATITUDE>",
        "longitude": "<LONGITUDE>",
        "name": "<NAME>",
        "address": "<ADDRESS>"
      }
    }
  ]
}

format peut nécessiter différents types d’éléments multimédias. Dans le kit SDK .NET, chaque type d’élément multimédia utilise un type MessageTemplateValue correspondant.

Propriétés	Description	Type
ADDRESS	Adresse qui apparaît après la valeur NAME, sous la carte générique en haut du message.	string
LATITUDE	Latitude de l’emplacement.	double
LONGITUDE	Longitude de l’emplacement.	double
LOCATIONNAME	Texte qui apparaît juste en dessous de la carte générique en haut du message.	string

Pour plus d’informations sur les modèles basés sur la localisation, consultez la documentation de WhatsApp relative aux types d’éléments multimédias inclus dans les messages.

Exemple

Modèle sample_movie_location :

Assembly de modèle de message basé sur la localisation :

 # Setting template options
        templateName = "sample_movie_location"
        templateLanguage = "en_us" 
        sample_movie_location: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        name = MessageTemplateText(name="first", text="Joe")
        location = MessageTemplateLocation(name="location", location_name="Pablo Morales",
                                            address="1 Hacker Way, Menlo Park, CA 94025",
                                            latitude=37.483307,longitude=122.148981)
        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)],
                                                    header=[WhatsAppMessageTemplateBindingsComponent(ref_value=location.name)])
        sample_movie_location.bindings = bindings
        sample_movie_location.template_values=[name,location]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_movie_location)

Envoyer un modèle de message avec des boutons d’appel à l’action et un lien dynamique

Utilisez MessageTemplateQuickAction pour définir le suffixe d’URL des boutons d’appel à l’action. L’objet MessageTemplateQuickAction a les deux attributs suivants.

Propriétés	Description	Type
Nom	name utilisé pour rechercher la valeur dans MessageTemplateWhatsAppBindings.	string
Text	text ajouté à l’URL.	string

Boutons de définition de modèle :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

L’ordre dans lequel les boutons apparaissent dans la définition de modèle doit correspondre à l’ordre dans lequel les boutons sont définis au moment de la création des liaisons avec MessageTemplateWhatsAppBindings.

Exemple

Modèle sample_purchase_feedback :

Cet exemple de modèle ajoute un bouton avec un lien d’URL dynamique au message. Il utilise également une image dans l’en-tête et un paramètre de texte dans le corps. Créez des modèles de bouton d’appel à l’action avec le type d’URL Dynamic pour le type d’action View website.

Dans cet exemple, l’en-tête du modèle nécessite une image :

{
  "type": "HEADER",
  "format": "IMAGE"
},

Le corps du modèle nécessite un paramètre de texte :

{
  "type": "BODY",
  "text": "Thank you for purchasing {{1}}! We value your feedback and would like to learn more about your experience."
},

Le modèle comprend un bouton d’URL dynamique avec un paramètre :

{
  "type": "BUTTONS",
  "buttons": [
    {
      "type": "URL",
      "text": "Take Survey",
      "url": "https://www.example.com/{{1}}"
    }
  ]
}

Créez une variable MessageTemplateImage, une variable MessageTemplateTextet une variable MessageTemplateQuickAction. Assemblez ensuite la liste de MessageTemplateValue et MessageTemplateWhatsAppBindings en fournissant les paramètres dans l’ordre où ils apparaissent au sein du contenu du modèle. L’ordre est également important quand vous définissez les boutons des liaisons.

# Setting template options
        templateName = "sample_purchase_feedback"
        templateLanguage = "en_us"
        imageUrl = "https://aka.ms/acsicon1" 
        sample_purchase_feedback: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        name = MessageTemplateText(name="first", text="Joe")
        image = MessageTemplateImage(name="image", url=imageUrl)
        uri_to_click = MessageTemplateQuickAction(name="url", text="questions")

        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)],
                                                    header=[WhatsAppMessageTemplateBindingsComponent(ref_value=image.name)],
                                                    buttons=[WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.URL,
                                                    ref_value=uri_to_click.name)])
        sample_purchase_feedback.bindings = bindings
        sample_purchase_feedback.template_values=[name, image, uri_to_click]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_purchase_feedback)

Exemple complet

import os
import sys

sys.path.append("..")

class SendWhatsAppTemplateMessageSample(object):

    connection_string = os.getenv("COMMUNICATION_SAMPLES_CONNECTION_STRING")
    phone_number = os.getenv("RECIPIENT_PHONE_NUMBER")
    channel_id = os.getenv("WHATSAPP_CHANNEL_ID")

    def send_template_message_without_parameters(self):
        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import ( TemplateNotificationContent , MessageTemplate )

        # client creation
        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)
        input_template: MessageTemplate = MessageTemplate(
            name="<<TEMPLATE_NAME>>",
            language="<<LANGUAGE>>")
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channelRegistrationId,
            to=[self.phone_number],
            template=input_template
        )

        # calling send() with WhatsApp template details.
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        
        if (response is not None):
            print("WhatsApp Templated Message with message id {} was successfully sent to {}"
            .format(response.message_id, response.to))
        else:
            print("Message failed to send")

    def send_template_message_with_parameters(self):

        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import (TemplateNotificationContent, MessageTemplate,
        MessageTemplateText, WhatsAppMessageTemplateBindings, WhatsAppMessageTemplateBindingsComponent)

        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

        # Setting template options
        templateName = "sample_shipping_confirmation"
        templateLanguage = "en_us" 
        shippingConfirmationTemplate: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        threeDays = MessageTemplateText(name="threeDays", text="3")
        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=threeDays.name)])
        shippingConfirmationTemplate.bindings = bindings
        shippingConfirmationTemplate.template_values=[threeDays]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=shippingConfirmationTemplate
        )

        # calling send() with whatsapp message details
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        print("WhatsApp text parameters Templated Message with message id {} was successfully sent to {}"
            .format(response.message_id, response.to))

    def send_template_message_with_media(self):

        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import (TemplateNotificationContent, MessageTemplate,
        MessageTemplateText, WhatsAppMessageTemplateBindings, WhatsAppMessageTemplateBindingsComponent,
        MessageTemplateImage)

        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

        # Setting template options
        templateName = "sample_movie_ticket_confirmation"
        templateLanguage = "en_us" 
        imageUrl = "https://aka.ms/acsicon1"
        sample_movie_ticket_confirmation: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        image = MessageTemplateImage(name="image", url=imageUrl)
        title = MessageTemplateText(name="title", text="Contoso")
        time = MessageTemplateText(name="time", text="July 1st, 2023 12:30PM")
        venue = MessageTemplateText(name="venue", text="Southridge Video")
        seats = MessageTemplateText(name="seats", text="Seat 1A")

        bindings = WhatsAppMessageTemplateBindings(header=[WhatsAppMessageTemplateBindingsComponent(ref_value=image.name)],
                                                   body=[WhatsAppMessageTemplateBindingsComponent(ref_value=title.name),
                                                         WhatsAppMessageTemplateBindingsComponent(ref_value=time.name),
                                                         WhatsAppMessageTemplateBindingsComponent(ref_value=venue.name),
                                                         WhatsAppMessageTemplateBindingsComponent(ref_value=seats.name)])

        sample_movie_ticket_confirmation.bindings = bindings
        sample_movie_ticket_confirmation.template_values=[image,title,time,venue,seats]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_movie_ticket_confirmation)

        # calling send() with whatsapp message details
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        print("WhatsApp media parameters in templated message header with message id {} was successfully sent to {}"
            .format(response.message_id, response.to))

    def send_template_message_with_buttons(self):

        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import (TemplateNotificationContent, MessageTemplate,
        MessageTemplateText, WhatsAppMessageTemplateBindings, WhatsAppMessageTemplateBindingsComponent,
        MessageTemplateQuickAction, WhatsAppMessageTemplateBindingsButton, WhatsAppMessageButtonSubType)

        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

        # Setting template options
        templateName = "sample_issue_resolution"
        templateLanguage = "en_us" 
        shippingConfirmationTemplate: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        name = MessageTemplateText(name="first", text="Joe")
        yes = MessageTemplateQuickAction(name="Yes", payload="Joe said yes")
        no = MessageTemplateQuickAction(name="No", payload = "Joe said no")
        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)])
        bindings.buttons = [WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.QUICK_REPLY, ref_value=yes.name),
                            WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.QUICK_REPLY, ref_value=no.name)]
        shippingConfirmationTemplate.bindings = bindings
        shippingConfirmationTemplate.template_values=[name,yes,no]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=shippingConfirmationTemplate
        )

        # calling send() with whatsapp message details
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        print("WhatsApp Quick Button Templated Message with message id {} was successfully sent to {}"
            .format(response.message_id, response.to))

    def send_template_message_with_location(self):

        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import (TemplateNotificationContent, MessageTemplate,
        MessageTemplateText, WhatsAppMessageTemplateBindings, WhatsAppMessageTemplateBindingsComponent,
        MessageTemplateLocation)

        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

        # Setting template options
        templateName = "sample_movie_location"
        templateLanguage = "en_us" 
        sample_movie_location: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        name = MessageTemplateText(name="first", text="Joe")
        location = MessageTemplateLocation(name="location", location_name="Pablo Morales",
                                            address="1 Hacker Way, Menlo Park, CA 94025",
                                            latitude=37.483307,longitude=122.148981)
        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)],
                                                    header=[WhatsAppMessageTemplateBindingsComponent(ref_value=location.name)])
        sample_movie_location.bindings = bindings
        sample_movie_location.template_values=[name,location]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_movie_location)

        # calling send() with whatsapp message details
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        print("WhatsApp Location Templated Message with message id {} was successfully sent to {}"
            .format(response.message_id, response.to))

    def send_template_message_with_call_to_action(self):

        from azure.communication.messages import NotificationMessagesClient
        from azure.communication.messages.models import (TemplateNotificationContent, MessageTemplate,
        MessageTemplateText, WhatsAppMessageTemplateBindings, WhatsAppMessageTemplateBindingsComponent,
        MessageTemplateQuickAction, MessageTemplateImage, WhatsAppMessageTemplateBindingsButton,
        WhatsAppMessageButtonSubType)

        messaging_client = NotificationMessagesClient.from_connection_string(self.connection_string)

        # Setting template options
        templateName = "sample_purchase_feedback"
        templateLanguage = "en_us"
        imageUrl = "https://aka.ms/acsicon1" 
        sample_purchase_feedback: MessageTemplate = MessageTemplate(name=templateName, language=templateLanguage )
        name = MessageTemplateText(name="first", text="Joe")
        image = MessageTemplateImage(name="image", url=imageUrl)
        uri_to_click = MessageTemplateQuickAction(name="url", text="questions")

        bindings = WhatsAppMessageTemplateBindings(body=[WhatsAppMessageTemplateBindingsComponent(ref_value=name.name)],
                                                    header=[WhatsAppMessageTemplateBindingsComponent(ref_value=image.name)],
                                                    buttons=[WhatsAppMessageTemplateBindingsButton(sub_type=WhatsAppMessageButtonSubType.URL,
                                                                                                    ref_value=uri_to_click.name)])
        sample_purchase_feedback.bindings = bindings
        sample_purchase_feedback.template_values=[name, image, uri_to_click]
        template_options = TemplateNotificationContent(
            channel_registration_id=self.channel_id, to=[self.phone_number], template=sample_purchase_feedback)

        # calling send() with whatsapp message details
        message_responses = messaging_client.send(template_options)
        response = message_responses.receipts[0]
        print("WhatsApp Call To Action Templated Message with message id {} was successfully sent to {}"
        .format(response.message_id, response.to))

if __name__ == "__main__":
    sample = SendWhatsAppTemplateMessageSample()
    sample.send_template_message_without_parameters()
    sample.send_template_message_with_parameters()
    sample.send_template_message_with_buttons()
    sample.send_template_message_with_location()
    sample.send_template_message_with_call_to_action()

Exécuter le code

Pour exécuter le code, vérifiez que vous êtes dans le répertoire où se trouve votre fichier messages-quickstart.py.

python messages-quickstart.py

Azure Communication Services - Advanced Messages Quickstart
WhatsApp Templated Message with message id <<GUID>> was successfully sent to <<ToRecipient>>

Étapes suivantes

• Faites-en plus avec le kit SDK Advanced Messages