Créer des agents pour gérer les marques

Choisissez de gérer les agents à l'aide de la console pour les développeurs ou de l'API Business Communications.

Console du développeur API

Une fois que vous vous êtes enregistré en tant que partenaire, vous pouvez activer les conversations pour les marques que vous gérez en créant des agents Business Messages pour elles.

Agent: représentation conversationnelle d'une marque, gérée par un partenaire. Inclut toute interface avec laquelle les utilisateurs interagissent, ainsi que tout code ou infrastructure requis pour alimenter l'interaction.

Un agent est une entité conversationnelle avec laquelle les utilisateurs interagissent. Vous créez un agent pour chaque marque que vous gérez. Vous créez et gérez des agents avec l'API Business Communications, et vous contrôlez la messagerie de vos agents avec l'API Business Messages.

Un agent couvre les fonctions commerciales d'une marque, telles que l'assistance en ligne et les établissements physiques (le cas échéant). Chaque message contient le contexte à partir duquel l'utilisateur a lancé la conversation. Votre infrastructure d'acheminement des messages peut détecter si l'utilisateur a consulté un établissement spécifique ou recherché une assistance générale, et peut acheminer les messages vers la bonne destination.

Par exemple, si vous gérez la marque Growing Tree Bank, qui possède un site Web et deux établissements, vous créez un seul agent "Growing Tree Bank". Les utilisateurs peuvent rencontrer l'agent via des recherches générales ou basées sur la localisation. Le contexte dans lequel l'utilisateur a trouvé l'agent est transmis avec chaque message à votre webhook. Vous utilisez ce contexte pour acheminer le message vers le personnel d'un site ou vers l'équipe d'assistance du site Web, qui crée une réponse et poursuit la conversation avec l'utilisateur.

Attentes

Avant de créer un agent, découvrez les attentes des agents sur Business Messages.

• Les agents doivent suivre les consignes de conception décrites dans Conception de conversations pour Business Messages.

• Les agents doivent disposer de représentants humains pour répondre aux questions lorsque l'automatisation ne peut pas répondre à une demande ou à la demande des utilisateurs.

  Remarque :Si votre agent n'est pas compatible avec les représentants humains, il ne peut pas être lancé à partir de points d'entrée basés sur la localisation ni de points d'entrée non locaux. Spécifiez un type d'interaction humain pour votre agent afin qu'il puisse s'afficher sur les points d'entrée gérés par Google.

• Les agents doivent maintenir un taux de satisfaction client (CSAT) d'au moins 80 % et un taux de réponse du marchand (MRR) d'au moins 95 %, comme indiqué dans la section Métriques.

Créer un agent

Pour créer un agent, vous devez collecter et envoyer des informations sur la marque et sur la façon dont vous souhaitez que l'agent apparaisse aux utilisateurs.

Remarque :Vous devez disposer d'un compte Google Business Messages pour créer des agents. Pour vous inscrire, consultez S'inscrire à Business Messages et consultez les attentes concernant les agents d'exploitation.

Si vous gérez plusieurs marques, répétez la procédure pour créer un agent pour chaque marque.

Prérequis

Avant de créer des agents pour les marques que vous gérez, vous devez rassembler certaines informations:

Environnement de développement

Informations sur votre environnement de développement.

• Projet GCP avec l'API Business Communications activée

  Pour activer l'API, consultez S'inscrire à Business Messages.

• Chemin d'accès à la clé de compte de service de votre projet GCP sur votre ordinateur de développement

Détails sur la marque

Informations sur la marque que représente l'agent.

• Marque
• Site Web de la marque
• Options de contact sur le site Web (définies dans OPTION)
• Numéro de téléphone du consommateur
• Numéros de téléphone activés pour la déviation d'appel

Apparence et règles concernant les agents

Informations sur l'apparence de l'agent auprès des utilisateurs et son fonctionnement.

• Nom de l'agent, tel que vous souhaitez qu'il apparaisse dans les conversations avec les utilisateurs
• Règles de confidentialité, sous la forme d'une URL accessible au public commençant par "https://"

• (Recommandé) Logo de l'agent (1 024 x 1 024 px), en tant qu'URL accessible au public

  Dans une conversation, les logos s'affichent sous la forme de cercles de 1 024 px de diamètre. Assurez-vous que votre logo s'affiche correctement sous forme arrondie.

  Tester votre logo

  Saisissez une URL pour votre logo afin de voir comment il s'affichera pour les utilisateurs.

  Remarque: Le serveur Web hébergeant l'image doit autoriser l'intégration d'images sur d'autres sites Web.

• (Facultatif) ID d'agent personnalisé, qui identifie la marque dans les messages reçus par le webhook

Interaction avec l'agent

Informations sur la façon dont votre agent interagit avec les utilisateurs.

• Langue définie par un code de langue ISO 639-1 à deux caractères, dans laquelle communique votre agent.

• Message de bienvenue pour les agents

  Que dit l'agent pour saluer les utilisateurs ?

• Amorces de conversation pour les agents

  Liste de suggestions, sous la forme de chips de conversation (comme défini dans SuggestedReply), pour que l'utilisateur puisse interagir avec l'agent

  • Texte affiché à l'utilisateur dans le chip
  • Données postback, chaîne renvoyée à votre webhook dans la charge utile du message si l'utilisateur appuie sur la puce

• Horaires du chat automatique et du chat en direct

  • Heure de début quotidienne, en tant qu'objet TimeOfDay

    Par exemple, 8h15 correspond à

    {
      "hours": 8,
      "minutes": 15,
    }
    

  • Heure de fin quotidienne, en tant qu'objet TimeOfDay

    Par exemple, 19h30 correspond à

    {
      "hours": 19,
      "minutes": 30,
    }
    

  • Jour de début, premier jour de la semaine où l'agent est disponible pour discuter (comme défini dans DayOfWeek)

  • Jour de fin, dernier jour de la semaine où l'agent est disponible pour le chat (comme défini dans DayOfWeek)

  • Fuseau horaire dans lequel l'agent opère (tel que défini dans la base de données des fuseaux horaires de l'IANA, par exemple "America/Los_Angeles")

Points d'entrée de l'agent

Informations sur les endroits où les utilisateurs peuvent démarrer des conversations avec l'agent.

• Points d'entrée autorisés pour les agents, à partir desquels les utilisateurs peuvent démarrer des conversations avec les agents (NON_LOCAL et/ou LOCATION)

  Remarque :Le point d'entrée LOCATION est nécessaire pour activer les conversations spécifiques à un emplacement.

Informations sur les points d'entrée NON_LOCAL (ne s'applique pas au point d'entrée Google Ads).

• Régions autorisées (en tant que codes région CLDR) pour limiter l'accès régional aux points d'entrée NON_LOCAL.

  Quel que soit le pays, un agent ne peut être associé qu'à un seul numéro de téléphone. Si vous avez besoin d'un numéro de téléphone différent en fonction de la région, vous devez créer un agent différent pour chaque région.

  Pour activer les points d'entrée NON_LOCAL dans toutes les régions disponibles, utilisez 001 pour le code de région mondial.

Installer et tester oauth2l

Toutes les requêtes curl de la documentation de ce site utilisent oauth2l pour l'authentification. Si vous souhaitez utiliser la ligne de commande pour vous connecter aux API Business Communications et Business Messages, installez oauth2l.

Pour installer oauth2l avec Python 3 :

1. Téléchargez oauth2l.

2. Remplacez le répertoire par "./oauth2l/python".

3. Installez oauth2l à l'aide de la commande suivante.

   sudo python setup.sh build && sudo python setup.py install
   

4. Vérifiez que oauth2l peut générer un jeton d'autorisation.

   oauth2l header --json resources/bm-agent-service-account-credentials.json businesscommunications

5. Vérifiez que la sortie crée un jeton d'autorisation au format suivant:

   Authorization: Bearer AUTHORIZATION_BEARER_TOKEN
   

Il existe d'autres façons d'installer oauth2l pour différents systèmes d'exploitation. Quelle que soit votre méthode d'installation, assurez-vous de pouvoir générer un jeton d'autorisation basé sur les identifiants JSON du compte de service avant de continuer.

Créer l'agent

Une fois que vous avez rassemblé les informations nécessaires, il est temps de créer votre agent.

1. Créez la marque que représente l'agent. Si la marque existe déjà, obtenez son name et passez à l'étape suivante.

   Dans un terminal, exécutez la commande suivante:

   cURL

   # This code creates a brand.
   # Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/create
   
   # Make sure a service account key file exists at ./service_account_key.json
   
   curl -X POST "https://businesscommunications.googleapis.com/v1/brands" \
   -H "Content-Type: application/json" \
   -H "User-Agent: curl/business-communications" \
   -H "$(oauth2l header --json ./service_account_key.json businesscommunications)" \
   -d '{
     "displayName": "My first brand curl"
   }'
   create-brand.sh

   Node.js

   /**
    * This code snippet creates a brand.
    * Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/create
    *
    * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
    * Business Communications client library.
    */
   
   /**
    * Edit the values below:
    */
   const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';
   
   const businesscommunications = require('businesscommunications');
   const {google} = require('googleapis');
   
   // Initialize the Business Communications API
   const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});
   
   // Set the scope that we need for the Business Communications API
   const scopes = [
     'https://www.googleapis.com/auth/businesscommunications',
   ];
   
   // Set the private key to the service account file
   const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);
   
   async function main() {
     const authClient = await initCredentials();
   
     if (authClient) {
       // Setup the parameters for the API call
       const apiParams = {
         auth: authClient,
         resource: {
           displayName: 'My first brand',
         },
       };
   
       bcApi.brands.create(apiParams, {}, (err, response) => {
         if (err !== undefined && err !== null) {
           console.dir(err);
         } else {
           // Brand created
           console.log(response.data);
         }
       });
     }
     else {
       console.log('Authentication failure.');
     }
   }
   
   /**
    * Initializes the Google credentials for calling the
    * Business Communcations API.
    */
    async function initCredentials() {
     // configure a JWT auth client
     const authClient = new google.auth.JWT(
       privatekey.client_email,
       null,
       privatekey.private_key,
       scopes,
     );
   
     return new Promise(function(resolve, reject) {
       // authenticate request
       authClient.authorize(function(err, tokens) {
         if (err) {
           reject('Failed to connect');
         } else {
           resolve(authClient);
         }
       });
     })
   }
   
   main();
   create-brand.js

   Java

   import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
   import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
   import com.google.api.client.http.HttpTransport;
   import com.google.api.client.json.jackson2.JacksonFactory;
   import com.google.api.services.businesscommunications.v1.BusinessCommunications;
   import com.google.api.services.businesscommunications.v1.model.Brand;
   import java.io.FileInputStream;
   import java.util.Arrays;
   import java.util.UUID;
   
   class Main {
     /**
      * Initializes credentials used by the Business Communications API.
      */
     private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
       BusinessCommunications.Builder builder = null;
       try {
         GoogleCredential credential = GoogleCredential
               .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));
   
         credential = credential.createScoped(Arrays.asList(
             "https://www.googleapis.com/auth/businesscommunications"));
   
         credential.refreshToken();
   
         HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
         JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();
   
         // Create instance of the Business Communications API
         builder = new BusinessCommunications
             .Builder(httpTransport, jsonFactory, null)
             .setApplicationName(credential.getServiceAccountProjectId());
   
         // Set the API credentials and endpoint
         builder.setHttpRequestInitializer(credential);
       } catch (Exception e) {
         e.printStackTrace();
       }
   
       return builder;
     }
   
     public static void main(String args[]) {
       try {
         // Create client library reference
         BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();
   
         // Create a request to create a new brand
         BusinessCommunications.Brands.Create request = builder
             .build().brands().create(new Brand().setDisplayName("BRAND_NAME"));
   
         Brand brand = request.execute();
   
         // Print newly created brand object
         System.out.println(brand.toPrettyString());
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
   }

   Ce code est basé sur la bibliothèque cliente Java Business Communications.

   Python

   """This code creates a brand.
   
   Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/create
   
   This code is based on the https://github.com/google-business-communications/python-businessmessages
   Python Business Messages client library.
   """
   
   from oauth2client.service_account import ServiceAccountCredentials
   from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
   from businesscommunications.businesscommunications_v1_messages import (
       Brand)
   
   # Edit the values below:
   SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
   SERVICE_ACCOUNT_FILE = './service_account_key.json'
   
   credentials = ServiceAccountCredentials.from_json_keyfile_name(
       SERVICE_ACCOUNT_FILE, scopes=SCOPES)
   
   client = BusinesscommunicationsV1(credentials=credentials)
   
   brands_service = BusinesscommunicationsV1.BrandsService(client)
   
   brand = brands_service.Create(Brand(displayName='My first brand'))
   
   print(brand)
   create-brand.py

   Stockez la valeur name renvoyée par l'API. Vous en aurez besoin pour effectuer des mises à jour ou créer des agents.

   Pour mettre à jour ou rechercher des marques, consultez la section brands.

2. Créez l'agent. Remplacez BRAND_ID par la partie de la valeur name de la marque qui suit "brands/". Par exemple, si name est "brands/12345", l'ID de la marque est "12345".

   Remarque :Remplacez les variables en surbrillance par les valeurs que vous avez identifiées dans la section Conditions préalables.

   Dans un terminal, exécutez la commande suivante:

   cURL

   # This code creates a Business Messages agent.
   # Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/agents?method=api#create_the_agent
   
   # Replace the __BRAND_ID__ with a brand id that you can create agents for
   # Make sure a service account key file exists at ./service_account_key.json
   
   curl -X POST "https://businesscommunications.googleapis.com/v1/brands/__BRAND_ID__/agents" \
   -H "Content-Type: application/json" \
   -H "User-Agent: curl/business-communications" \
   -H "$(oauth2l header --json ./service_account_key.json businesscommunications)" \
   -d '{
     "displayName": "My first agent",
     "businessMessagesAgent": {
       "logoUrl": "https://developers.google.com/identity/images/g-logo.png",
       "entryPointConfigs": [
         {
           "allowedEntryPoint": "NON_LOCAL"
         }
       ],
       "customAgentId": "'$(uuidgen)'",
       "nonLocalConfig": {
         "regionCodes": [
           "US",
           "CA"
         ],
         "contactOption": {
           "url": "https://www.your-company-website.com",
           "options": [
             "EMAIL",
             "PHONE"
           ]
         },
         "enabledDomains": [
           "your-company-website.com"
         ],
         "phoneNumber": {
           "number": "[phone]"
         },
         "callDeflectionPhoneNumbers": [
           {
             "number": "[phone]"
           },
           {
             "number": "[phone]"
           }
         ]
       },
       "conversationalSettings": {
         "en": {
           "welcomeMessage": {
             "text": "This is a sample welcome message"
           },
           "privacyPolicy": {
             "url": "https://www.your-company-website.com/privacy"
           },
           "conversationStarters": [
             {
               "suggestion": {
                 "reply": {
                   "text": "Option 1",
                   "postbackData": "postback_option_1"
                 }
               }
             }
           ]
         }
       },
       "defaultLocale": "en",
       "primaryAgentInteraction": {
         "interactionType": "HUMAN",
         "humanRepresentative": {
           "humanMessagingAvailability": {
             "hours": [
               {
                 "startTime": {
                   "hours": 8,
                   "minutes": 30
                 },
                 "endTime": {
                   "hours": 20,
                   "minutes": 0
                 },
                 "timeZone": "America/Los_Angeles",
                 "startDay": "MONDAY",
                 "endDay": "SATURDAY"
               }
             ]
           }
         }
       }
     }
   }'
   create-agent-bm.sh

   Node.js

   /**
    * This code snippet creates a Business Messages agent.
    * Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/agents?method=api#create_the_agent
    *
    * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
    * Business Communications client library.
    */
   
   /**
    * Edit the values below:
    */
   const BRAND_ID = 'EDIT_HERE';
   const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';
   
   const businesscommunications = require('businesscommunications');
   const {google} = require('googleapis');
   const uuidv4 = require('uuid').v4;
   
   // Initialize the Business Communications API
   const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});
   
   // Set the scope that we need for the Business Communications API
   const scopes = [
     'https://www.googleapis.com/auth/businesscommunications',
   ];
   
   // Set the private key to the service account file
   const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);
   
   async function main() {
     const authClient = await initCredentials();
     const brandName = 'brands/' + BRAND_ID;
   
     if (authClient) {
       const agentObject = {
         displayName: 'My first agent',
         businessMessagesAgent: {
           customAgentId: uuidv4(), // Optional
           logoUrl: 'https://developers.google.com/identity/images/g-logo.png',
           entryPointConfigs: [
             {
               allowedEntryPoint: 'NON_LOCAL',
             }
           ],
           nonLocalConfig: { // Configuration options for launching on non-local entry points
             // List of phone numbers for call deflection, values must be globally unique
             callDeflectionPhoneNumbers: [
               { number: '[phone]' },
               { number: '[phone]' },
             ],
             // Contact information for the agent that displays with the messaging button
             contactOption: {
               options: [
                 'EMAIL',
                 'PHONE'
               ],
               url: 'https://www.your-company-website.com',
             },
             // Domains enabled for messaging within Search, values must be globally unique
             enabledDomains: [ 'your-company-website.com' ],
             // Agent's phone number. Overrides the `phone` field
             // for conversations started from non-local entry points
             phoneNumber: { number: '[phone]' },
             // List of CLDR region codes for countries where the agent is allowed to launch `NON_LOCAL` entry points
             regionCodes: [ 'US', 'CA' ]
           },
           // Must match a conversational setting locale
           defaultLocale: 'en',
           conversationalSettings: {
             en: {
               privacyPolicy: { url: 'https://www.your-company-website.com/privacy' },
               welcomeMessage: { text: 'This is a sample welcome message' },
               conversationStarters: [
                 {
                   suggestion: {
                     reply: {
                       text: 'Option 1',
                       postbackData: 'postback_option_1',
                     },
                   },
                 },
               ],
             },
           },
           primaryAgentInteraction: {
             interactionType: 'HUMAN',
             humanRepresentative: {
               humanMessagingAvailability: {
                 hours: [
                   {
                     startTime: {
                       hours: 8,
                       minutes: 30
                     },
                     startDay: 'MONDAY',
                     endDay: 'SATURDAY',
                     endTime: {
                       hours: 20,
                       minutes: 0
                     },
                     timeZone: 'America/Los_Angeles',
                   },
                 ],
               },
             },
           },
         },
       };
   
       // Setup the parameters for the API call
       const apiParams = {
         auth: authClient,
         parent: brandName,
         resource: agentObject
       };
   
       bcApi.brands.agents.create(apiParams, {}, (err, response) => {
         if (err !== undefined && err !== null) {
           console.dir(err);
         } else {
           // Agent created
           console.log(response.data);
         }
       });
     }
     else {
       console.log('Authentication failure.');
     }
   }
   
   /**
    * Initializes the Google credentials for calling the
    * Business Messages API.
    */
    async function initCredentials() {
     // Configure a JWT auth client
     const authClient = new google.auth.JWT(
       privatekey.client_email,
       null,
       privatekey.private_key,
       scopes,
     );
   
     return new Promise(function(resolve, reject) {
       // Authenticate request
       authClient.authorize(function(err, tokens) {
         if (err) {
           reject(false);
         } else {
           resolve(authClient);
         }
       });
     });
   }
   
   main();
   create-agent-bm.js

   Java

   import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
   import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
   import com.google.api.client.http.HttpTransport;
   import com.google.api.client.json.jackson2.JacksonFactory;
   import com.google.api.services.businesscommunications.v1.BusinessCommunications;
   import com.google.api.services.businesscommunications.v1.model.Brand;
   import com.google.common.collect.ImmutableMap;
   import java.io.FileInputStream;
   import java.util.Arrays;
   import java.util.UUID;
   
   class Main {
     /**
      * Initializes credentials used by the Business Communications API.
      */
     private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
       BusinessCommunications.Builder builder = null;
       try {
         GoogleCredential credential = GoogleCredential
               .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));
   
         credential = credential.createScoped(Arrays.asList(
             "https://www.googleapis.com/auth/businesscommunications"));
   
         credential.refreshToken();
   
         HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
         JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();
   
         // Create instance of the Business Communications API
         builder = new BusinessCommunications
             .Builder(httpTransport, jsonFactory, null)
             .setApplicationName(credential.getServiceAccountProjectId());
   
         // Set the API credentials and endpoint
         builder.setHttpRequestInitializer(credential);
       } catch (Exception e) {
         e.printStackTrace();
       }
   
       return builder;
     }
   
     public static void main(String args[]) {
       try {
         // Create client library reference
         BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();
   
         String brandName = "BRAND_ID";
   
         BusinessCommunications.Brands.Agents.Create request = builder
             .build().brands().agents().create(brandName,
                 new Agent()
                     .setDisplayName("AGENT_NAME")
                     .setBusinessMessagesAgent(new BusinessMessagesAgent()
                         .setCustomAgentId("CUSTOM_ID") // Optional
                         .setLogoUrl("LOGO_URL")
                         .setEntryPointConfigs(Arrays.asList(
                           new BusinessMessagesEntryPointConfig()
                               .setAllowedEntryPoint(
                                   "ENTRY_POINT_1"),
                           new BusinessMessagesEntryPointConfig()
                               .setAllowedEntryPoint(
                                   "ENTRY_POINT_2")
                         ))
                         // Configuration options for launching on non-local entry points
                         .setNonLocalConfig(new NonLocalConfig()
                           // List of phone numbers for call deflection, values must be globally unique
                           .setCallDeflectionPhoneNumbers(Arrays.asList(new Phone().setNumber("DEFLECTION_PHONE_NUMBER_1"),
                               new Phone().setNumber("DEFLECTION_PHONE_NUMBER_2")))
                           // Contact information for the agent that displays with the messaging button
                           .setContactOption(new ContactOption().setOptions(Arrays.asList(
                               "CONTACT_OPTION_1",
                               "CONTACT_OPTION_2")
                           ).setUrl("WEBSITE_URL"))
                           // Domains enabled for messaging within Search, values must be globally unique
                           .setEnabledDomains(Arrays.asList("ENABLED_DOMAIN_1", "ENABLED_DOMAIN_2"))
                           // Agent's phone number. Overrides the `phone` field for
                           // conversations started from non-local entry points
                           .setPhoneNumber(new Phone().setNumber("CONTACT_PHONE_NUMBER"))
                           // List of regions where this agent will be available
                           .setRegionCodes(Arrays.asList("REGION_CODE")))
                         .setDefaultLocale("LOCALE")
                         // Create a map between the language code and the initial conversation settings
                         .setConversationalSettings(ImmutableMap.of("LOCALE",
                           new ConversationalSetting()
                               .setPrivacyPolicy(new PrivacyPolicy().setUrl("PRIVACY_POLICY_URL"))
                               .setWelcomeMessage(new WelcomeMessage().setText("WELCOME_MESSAGE"))
                               .setConversationStarters(Arrays.asList(
                                   new ConversationStarters().setSuggestion(new Suggestion()
                                       .setReply(new SuggestedReply().setText("SUGGESTION_TEXT").setPostbackData("SUGGESTION_POSTBACK_DATA")))
                               ))))
                         .setPrimaryAgentInteraction(new SupportedAgentInteraction()
                             .setInteractionType(InteractionType.HUMAN.toString())
                             .setHumanRepresentative(new HumanRepresentative()
                                 .setHumanMessagingAvailability(new MessagingAvailability()
                                     // Create a list of available hours
                                     .setHours(Arrays.asList(new Hours()
                                       .setStartTime(new TimeOfDay().setHours(START_TIME_HOURS).setMinutes(START_TIME_MINUTES))
                                       .setStartDay("BEGINNING_DAY_OF_WEEK")
                                       .setEndDay("END_DAY_OF_WEEK")
                                       .setEndTime(new TimeOfDay().setHours(END_TIME_HOURS).setMinutes(END_TIME_MINUTES))
                                       .setTimeZone("TIME_ZONE"))))))
   
                     ));
   
         Agent agent = request.execute();
   
         System.out.println(agent.toPrettyString());
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
   }

   Ce code est basé sur la bibliothèque cliente Java Business Communications.

   Python

   """This code creates a Business Messages agent.
   
   Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/agents?method=api#create_the_agent
   
   This code is based on the https://github.com/google-business-communications/python-businessmessages
   Python Business Messages client library.
   """
   
   from oauth2client.service_account import ServiceAccountCredentials
   from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
   from businesscommunications.businesscommunications_v1_messages import (
       Agent, BusinesscommunicationsBrandsAgentsCreateRequest,
       BusinessMessagesAgent, BusinessMessagesEntryPointConfig,
       ContactOption, ConversationalSetting, ConversationStarters,
       Hours, HumanRepresentative, MessagingAvailability,
       NonLocalConfig, Phone, PrivacyPolicy, Suggestion,
       SuggestedReply, SupportedAgentInteraction,
       TimeOfDay, WelcomeMessage
   )
   
   # Edit the values below:
   BRAND_ID = 'EDIT_HERE'
   SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
   SERVICE_ACCOUNT_FILE = './service_account_key.json'
   
   credentials = ServiceAccountCredentials.from_json_keyfile_name(
       SERVICE_ACCOUNT_FILE, scopes=SCOPES)
   
   client = BusinesscommunicationsV1(credentials=credentials)
   
   agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)
   
   brand_name = 'brands/ '+ BRAND_ID
   
   agent = Agent(
       displayName='My first agent',
       businessMessagesAgent=BusinessMessagesAgent(
           customAgentId='CUSTOM_ID', # Optional
           logoUrl='https://developers.google.com/identity/images/g-logo.png',
           entryPointConfigs=[BusinessMessagesEntryPointConfig(
               allowedEntryPoint=BusinessMessagesEntryPointConfig.AllowedEntryPointValueValuesEnum.LOCATION
           ), BusinessMessagesEntryPointConfig(
               allowedEntryPoint=BusinessMessagesEntryPointConfig.AllowedEntryPointValueValuesEnum.NON_LOCAL
           )],
           nonLocalConfig=NonLocalConfig(
               # List of phone numbers for call deflection, values must be globally unique
               # Generating a random phone number for demonstration purposes
               # This should be replaced with a real brand phone number
               callDeflectionPhoneNumbers=[Phone(number='[phone]'),
                 Phone(number='[phone]')],
               # Contact information for the agent that displays with the messaging button
               contactOption=ContactOption(
                       options=[ContactOption.OptionsValueListEntryValuesEnum.EMAIL,
                           ContactOption.OptionsValueListEntryValuesEnum.PHONE],
                       url='https://www.your-company-website.com'
                   ),
               # Domains enabled for messaging within Search, values must be globally unique
               # Generating a random URL for demonstration purposes
               # This should be replaced with a real brand URL
               enabledDomains=['your-company-website.com'],
               # Agent's phone number. Overrides the `phone` field for conversations started from non-local entry points
               phoneNumber=Phone(number='[phone]'),
               # List of CLDR region codes for countries where the agent is allowed to launch `NON_LOCAL` entry points.
               # Example is for launching in Canada and the USA
               regionCodes=['US', 'CA']
           ),
           defaultLocale='en',
           conversationalSettings=BusinessMessagesAgent.ConversationalSettingsValue(
               additionalProperties=[BusinessMessagesAgent.ConversationalSettingsValue.AdditionalProperty(
                   key='en',
                   value=ConversationalSetting(
                       privacyPolicy=PrivacyPolicy(url='https://www.your-company-website.com/privacy'),
                       welcomeMessage=WelcomeMessage(text='This is a sample welcome message'),
                       conversationStarters=[
                           ConversationStarters(
                               suggestion=Suggestion(
                                   reply=SuggestedReply(text='Option 1',
                                                        postbackData='postback_option_1')
                               )
                           )
                       ]
                   )
               )]
           ),
           primaryAgentInteraction=SupportedAgentInteraction(
               interactionType=SupportedAgentInteraction.InteractionTypeValueValuesEnum.HUMAN,
               humanRepresentative=HumanRepresentative(
                   humanMessagingAvailability=MessagingAvailability(hours=[
                           Hours(
                               startTime=TimeOfDay(hours=8, minutes=30),
                               startDay=Hours.StartDayValueValuesEnum.MONDAY,
                               endDay=Hours.EndDayValueValuesEnum.SATURDAY,
                               endTime=TimeOfDay(hours=20, minutes=0),
                               timeZone='America/Los_Angeles'
                           )
                       ])
               )
           ),
       )
   )
   
   new_agent = agents_service.Create(
       BusinesscommunicationsBrandsAgentsCreateRequest(
           agent=agent,
           parent=brand_name
       )
   )
   
   print(new_agent)
   create-agent-bm.py

   Pour connaître les options de mise en forme et de valeur, consultez brands.agents.

3. Si la marque dispose de lieux que vous souhaitez associer à votre agent, consultez la section Ajouter des lieux.

Exemple: Créer un agent pour Growing Tree Bank

curl -X POST "https://businesscommunications.googleapis.com/v1/brands" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json /path/to/service/account/key.json businesscommunications)" \
-d "{
    'displayName': 'Growing Tree Bank'
}"

# Fetch returned brand name value of "brands/12345"

curl -X POST "https://businesscommunications.googleapis.com/v1/brands/12345/agents" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json /path/to/service/account/key.json businesscommunications)" \
-d "{
    'displayName': 'Growing Tree Bank',
    'businessMessagesAgent': {
        'logoUrl': 'https://www.growingtreebank.com/images/logo.png',
        'entryPointConfigs': [
          {
            'allowedEntryPoint': 'NON_LOCAL',
          },
          {
            'allowedEntryPoint': 'LOCATION',
          },
        ],
        'customAgentId': 'growing-tree-bank',
        'nonLocalConfig': {
            'regionCodes': ['001'],
            'contactOption': {
                'url': 'https://www.growingtreebank.com',
                'options': [
                    'EMAIL',
                    'PHONE',
                ],
            },
            'enabledDomains': [
                'https://www.growingtreebank.com',
            ],
            'phoneNumber': {
                'number': '[phone]',
            },
            'callDeflectionPhoneNumbers': [
                {
                    'number': '[phone]',
                },
                {
                    'number': '[phone]',
                },
            ],
        },
        'conversationalSettings': {
            'en': {
                'welcomeMessage': {
                    'text': 'Thanks for contacting Growing Tree Bank. What can I help with today?',
                },
                'privacyPolicy': {
                    'url': 'https://www.growingtreebank.com/privacy',
                },
                'conversationStarters': [
                    {
                        'suggestion': {
                            'reply': {
                                'text': 'Set up an account',
                                'postbackData': 'new-account',
                            },
                        },
                    },
                ],
            },
        },
        'defaultLocale': 'en',
        'primaryAgentInteraction': {
            'interactionType': 'BOT',
            'botRepresentative': {
                'botMessagingAvailability': {
                    'hours': [
                        {
                            'startTime': {
                                'hours': '8',
                                'minutes': '00',
                            },
                            'endTime': {
                                'hours': '17',
                                'minutes': '30',
                            },
                            'timeZone': 'America/Los_Angeles',
                            'startDay': 'MONDAY',
                            'endDay': 'FRIDAY',
                        },
                    ],
                },
            },
        },
    },
}"

Stocker des informations importantes

Lorsque vous créez un agent, l'API Business Communications renvoie les valeurs de votre agent, y compris name et testUrls.

Remarque :Stockez name dans un emplacement auquel vous avez accès. Vous avez besoin de name pour mettre à jour, valider ou lancer l'agent.

Définir un webhook au niveau de l'agent

Vous recevez les messages envoyés à votre agent sur votre webhook. Si vous souhaitez que les messages destinés à un agent spécifique soient envoyés à un autre webhook, vous pouvez définir un webhook au niveau de l'agent.

Pour définir un webhook au niveau de l'agent, utilisez la console de développement.

Tester un agent

Chaque agent dispose d'URL de test qui vous permettent de voir comment une conversation avec cet agent s'affiche pour les utilisateurs et de vérifier votre infrastructure de messagerie.

Un TestUrl possède des attributs url et surface. Pour effectuer un test avec un appareil iOS, utilisez l'URL de test avec une valeur de surface de SURFACE_IOS_MAPS. Ouvrir l'URL sur un appareil iOS sur lequel l'application Google Maps est installée permet de lancer une conversation avec l'agent.

Les appareils Android disposent de deux URL de test. Les URL dont la valeur surface est SURFACE_ANDROID_MAPS ouvrent des conversations dans Google Maps et représentent les points d'entrée de conversation qui apparaissent dans Google Maps. Les URL dont la valeur surface est SURFACE_ANDROID_WEB ouvrent des conversations dans une vue de conversation en superposition et représentent tous les autres points d'entrée.

Une fois qu'une surface de conversation s'ouvre, la conversation inclut toutes les informations de branding que les utilisateurs verront. Lorsque vous envoyez un message à l'agent, votre webhook le reçoit, y compris la charge utile JSON complète que vous pouvez attendre lorsque vous communiquez avec les utilisateurs.

Remarque :Les charges utiles JSON de l'URL de test de l'agent n'incluent pas d'informations de localisation (context). Pour recevoir des informations de localisation, utilisez une URL de test de localisation. Consultez la section Tester un emplacement.

Pour ouvrir l'URL de test d'un agent, appuyez sur un lien ou utilisez le lanceur d'agent Business Messages sur un appareil mobile.

Remarque :Si vous modifiez les informations sur l'agent après avoir commencé une conversation, supprimez-la de votre appareil et commencez une nouvelle conversation pour voir les informations mises à jour.

Obtenir des informations sur l'agent

Pour obtenir des informations sur un agent, telles que agentTestUrl, vous pouvez les obtenir à partir de l'API Business Communications, à condition de disposer de la valeur name de l'agent.

Obtenir des informations sur un seul agent

Pour obtenir des informations sur l'agent, exécutez la commande suivante. Remplacez BRAND_ID et AGENT_ID par les valeurs uniques de l'name de l'agent.

Remarque :Les noms et ID des agents doivent être encodés au format URL. Par exemple, si le nom ou l'ID d'un agent inclut un "/", remplacez-le par "%2F".

cURL

# This code gets the agent.
# Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/get

# Replace the __BRAND_ID__ and __AGENT_ID__
# Make sure a service account key file exists at ./service_account_key.json

curl -X GET \
"https://businesscommunications.googleapis.com/v1/brands/__BRAND_ID__/agents/__AGENT_ID__" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json ./service_account_key.json businesscommunications)"
get-agent.sh

Node.js

/**
 * This code snippet gets an agent.
 * Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/get
 *
 * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
 * Business Communications client library.
 */

/**
 * Edit the values below:
 */
const BRAND_ID = 'EDIT_HERE';
const AGENT_ID = 'EDIT_HERE';
const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);

async function main() {
  const authClient = await initCredentials();

  const agentName = 'brands/' + BRAND_ID + '/agents/' + AGENT_ID;

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: agentName,
    };

    bcApi.brands.agents.get(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent found
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
 async function initCredentials() {
  // Configure a JWT auth client
  const authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

main();
get-agent.js

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.Agent;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String agentName = "brands/BRAND_ID/agents/AGENT_ID";

      BusinessCommunications.Brands.Agents.Get request = builder
        .build().brands().agents().get(agentName);

      Agent agent = request.execute();

      System.out.println(agent.toPrettyString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

"""This code gets the agent.

Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/get

This code is based on the https://github.com/google-business-communications/python-businessmessages
Python Business Messages client library.
"""

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinesscommunicationsBrandsAgentsGetRequest,
)

# Edit the values below:
BRAND_ID = 'EDIT_HERE'
AGENT_ID = 'EDIT_HERE'
SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = './service_account_key.json'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

agent_name = 'brands/' + BRAND_ID + '/agents/' + AGENT_ID

agent = agents_service.Get(BusinesscommunicationsBrandsAgentsGetRequest(
        name=agent_name
    ))

print(agent)
get-agent.py

Lister tous les agents d'une marque

Si vous ne connaissez pas le name de l'agent, vous pouvez obtenir des informations sur tous les agents associés à une marque en omettant la valeur AGENT_ID de l'URL de la requête GET.

Remarque :Les noms et ID des agents doivent être encodés au format URL. Par exemple, si le nom ou l'ID d'un agent inclut un "/", remplacez-le par "%2F".

cURL

# This code lists all agents from a brand.
# Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/list

# Replace the __BRAND_ID__
# Make sure a service account key file exists at ./service_account_key.json

curl -X GET \
"https://businesscommunications.googleapis.com/v1/brands/__BRAND_ID__/agents/" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json ./service_account_key.json businesscommunications)"
list-agents.sh

Node.js

/**
 * This code snippet lists the agents of a brand.
 * Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/list
 *
 * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
 * Business Communications client library.
 */

/**
 * Edit the values below:
 */
const BRAND_ID = 'EDIT_HERE';
const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);

async function main() {
  const authClient = await initCredentials();

  const brandName = 'brands/' + BRAND_ID;

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      parent: brandName,
    };

    bcApi.brands.agents.list(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent found
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
 async function initCredentials() {
  // Configure a JWT auth client
  const authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

main();
list-agents.js

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.Agent;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String brandName = "brands/BRAND_ID";

      BusinessCommunications.Brands.Agents.List request = builder
          .build().brands().agents().list(brandName);

      List agents = request.execute().getAgents();
      agents.stream().forEach(agent -> {
        try {
          System.out.println(agent.toPrettyString());
        } catch (IOException e) {
          e.printStackTrace();
        }
      });
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

"""This code lists all agents from a brand.

Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/list

This code is based on the https://github.com/google-business-communications/python-businessmessages
Python Business Messages client library.
"""

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinesscommunicationsBrandsAgentsGetRequest,
)

# Edit the values below:
BRAND_ID = 'EDIT_HERE'
SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = './service_account_key.json'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

brand_name = 'brands/' + BRAND_ID

agents = agents_service.List(BusinesscommunicationsBrandsAgentsListRequest(
        parent=brand_name
    ))

print(agents)
list-agents.py

Mettre à jour les informations sur l'agent

Pour mettre à jour un agent, effectuez une requête PATCH avec l'API Business Communications. Lorsque vous effectuez l'appel d'API, vous incluez les noms des champs que vous modifiez en tant que valeurs pour le paramètre d'URL "updateMask".

Par exemple, si vous mettez à jour les champs displayName et customAgentId, le paramètre d'URL "updateMask" est "updateMask=displayName,businessMessagesAgent.customAgentId".

Pour connaître les options de mise en forme et de valeur, consultez brands.agents.patch.

Si vous ne connaissez pas le name d'un agent, consultez Lister tous les agents d'une marque.

Attention :Lorsque vous modifiez un champ, il remplace l'intégralité du contenu précédent de ce champ. Lorsque vous mettez à jour un champ répétitif, vous devez inclure toutes les répétitions du champ dans votre mise à jour, sinon vous risquez de perdre des données. Par exemple, pour ajouter une instance hours supplémentaire, vous devez inclure toutes les répétitions de hours.

Une fois que vous avez validé un agent, vous ne pouvez modifier que les champs suivants:

• conversationalSetting

  Attention :Si vous modifiez un champ dans conversationalSettings, vous devez modifier tous les champs de l'objet et spécifier les paramètres régionaux (sous la forme d'un code de langue ISO 639-1 à deux caractères).

• customAgentId

• defaultLocale

• primaryAgentInteraction

• additionalAgentInteractions

• phone

Si vous devez mettre à jour d'autres champs après avoir validé votre agent, nous contacter. (Vous devez d'abord vous connecter avec un compte Google Business Messages. Pour vous inscrire, consultez S'inscrire à Business Messages.

Exemple: Mettre à jour le nom à afficher

cURL

curl -X PATCH \
"https://businesscommunications.googleapis.com/v1/brands/BRAND_ID/agents/AGENT_ID?updateMask=displayName" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json PATH_TO_SERVICE_ACCOUNT_KEY businesscommunications)" \
-d "{
    'displayName': 'Growing Tree Bank',
}"

Node.js

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
let bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require('PATH_TO_SERVICE_ACCOUNT_KEY');

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
async function initCredentials() {
  // Configure a JWT auth client
  let authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

async function main() {
  let authClient = await initCredentials();

  let agentName = 'brands/BRAND_ID/agents/AGENT_ID';

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: agentName,
      updateMask: 'displayName',
      resource: {
        displayName: 'Growing Tree Bank',
      }
    };

    bcApi.brands.agents.patch(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent found
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

main();

Ce code est basé sur la bibliothèque cliente Business Communications pour Node.js.

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.Agent;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String agentName = "brands/BRAND_ID/agents/AGENT_ID";

      Agent agent = new Agent().setDisplayName("Growing Tree Bank");

      BusinessCommunications.Brands.Agents.Patch request = builder
          .build().brands().agents().patch(agentName, agent);

      request.setUpdateMask("displayName");

      Agent updatedAgent = request.execute();
      System.out.println(updatedAgent.toPrettyString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import (
    BusinesscommunicationsV1
)
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinesscommunicationsBrandsAgentsPatchRequest,
)

SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = 'PATH_TO_SERVICE_ACCOUNT_KEY'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

agent_name = 'brands/BRAND_ID/agents/AGENT_ID'

agent=Agent(
          displayName='Growing Tree Bank'
      )

updated_agent = agents_service.Patch(
        BusinesscommunicationsBrandsAgentsPatchRequest(
            agent=agent,
            name=agent_name,
            updateMask='displayName'
        )
    )

print(updated_agent)

Ce code est basé sur la bibliothèque cliente Python Business Communications.

Exemple: Spécifier des groupes de points d'entrée NON_LOCAL et LOCATION

cURL

curl -X PATCH \
"https://businesscommunications.googleapis.com/v1/brands/BRAND_ID/agents/AGENT_ID?updateMask=businessMessagesAgent.entryPointConfigs" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json PATH_TO_SERVICE_ACCOUNT_KEY businesscommunications)" \
-d "{
  'businessMessagesAgent': {
    'entryPointConfigs': [
      {
        'allowedEntryPoint': 'NON_LOCAL',
      },
      {
        'allowedEntryPoint': 'LOCATION',
      },
    ],
  },
}"

Node.js

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
let bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require('PATH_TO_SERVICE_ACCOUNT_KEY');

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
async function initCredentials() {
  // Configure a JWT auth client
  let authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

async function main() {
  let authClient = await initCredentials();

  let agentName = 'brands/BRAND_ID/agents/AGENT_ID';

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: agentName,
      updateMask: 'businessMessagesAgent.entryPointConfigs',
      resource: {
        businessMessagesAgent: {
          entryPointConfigs: [
            {
              allowedEntryPoint: 'LOCATION',
            },
            {
              allowedEntryPoint: 'NON_LOCAL',
            },
          ],
        }
      }
    };

    bcApi.brands.agents.patch(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent found
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

main();

Ce code est basé sur la bibliothèque cliente Business Communications pour Node.js.

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.*;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String agentName = "brands/BRAND_ID/agents/AGENT_ID";

      Agent agent = new Agent().setBusinessMessagesAgent(
          new BusinessMessagesAgent().setEntryPointConfigs(Arrays.asList(
              new BusinessMessagesEntryPointConfig()
                  .setAllowedEntryPoint(
                      "NON_LOCAL"),
              new BusinessMessagesEntryPointConfig()
                  .setAllowedEntryPoint(
                      "LOCATION"))));

      BusinessCommunications.Brands.Agents.Patch request = builder
          .build().brands().agents().patch(agentName, agent);

      request.setUpdateMask("businessMessagesAgent.entryPointConfigs");

      Agent updatedAgent = request.execute();
      System.out.println(updatedAgent.toPrettyString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import (
    BusinesscommunicationsV1
)
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinessMessagesAgent,
    BusinessMessagesEntryPointConfig,
    BusinesscommunicationsBrandsAgentsPatchRequest,
)

SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = 'PATH_TO_SERVICE_ACCOUNT_KEY'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

agent_name = 'brands/BRAND_ID/agents/AGENT_ID'

agent=Agent(
    businessMessagesAgent=BusinessMessagesAgent(
        entryPointConfigs=[BusinessMessagesEntryPointConfig(
            allowedEntryPoint=BusinessMessagesEntryPointConfig.AllowedEntryPointValueValuesEnum.NON_LOCAL
        ), BusinessMessagesEntryPointConfig(
            allowedEntryPoint=BusinessMessagesEntryPointConfig.AllowedEntryPointValueValuesEnum.LOCATION
        )]
    )
)

updated_agent = agents_service.Patch(
        BusinesscommunicationsBrandsAgentsPatchRequest(
            agent=agent,
            name=agent_name,
            updateMask='businessMessagesAgent.entryPointConfigs'
        )
    )

print(updated_agent)

Ce code est basé sur la bibliothèque cliente Python Business Communications.

Exemple: Modifier le message d'accueil

Si vous modifiez un champ dans conversationalSettings (par exemple, welcomeMessage), vous devez modifier tous les champs de l'objet et spécifier les paramètres régionaux (sous la forme d'un code de langue ISO 639-1 à deux caractères).

Remarque :Il peut s'écouler jusqu'à deux heures avant que les nouveaux paramètres de conversation n'apparaissent dans les conversations avec votre agent.

cURL

curl -X PATCH \
"https://businesscommunications.googleapis.com/v1/brands/BRAND_ID/agents/AGENT_ID?updateMask=businessMessagesAgent.conversationalSettings.en" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json PATH_TO_SERVICE_ACCOUNT_KEY businesscommunications)" \
-d "{
    'businessMessagesAgent': {
        'conversationalSettings': {
            'en': {
                'welcomeMessage': {
                    'text': 'Thanks for contacting Growing Tree Bank. What can I help with today?',
                },
                'offlineMessage': {
                    'text': 'We\'re closed for the night. Please reach out to us again tomorrow.',
                },
                'privacyPolicy': {
                    'url': 'https://www.growingtreebank.com/privacy',
                },
                'conversationStarters': [
                    {
                        'suggestion': {
                            'reply': {
                                'text': 'Set up an account',
                                'postbackData': 'new-account',
                            },
                        },
                    },
                    {
                        'suggestion': {
                            'reply': {
                                'text': 'Look up account information',
                                'postbackData': 'account-lookup',
                            },
                        },
                    },
                ],
            },
        },
    },
}"

Node.js

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
let bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require('PATH_TO_SERVICE_ACCOUNT_KEY');

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
async function initCredentials() {
  // Configure a JWT auth client
  let authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

async function main() {
  let authClient = await initCredentials();

  let agentName = 'brands/BRAND_ID/agents/AGENT_ID';

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: agentName,
      updateMask: 'businessMessagesAgent.conversationalSettings.en',
      resource: {
        businessMessagesAgent: {
          conversationalSettings: {
            en: {
              privacyPolicy: { url: 'https://www.growingtreebank.com/privacy' },
              welcomeMessage: { text: 'Thanks for contacting Growing Tree Bank. What can I help with today?' },
              offlineMessage: { text: 'We\'re closed for the night. Please reach out to us again tomorrow.' },
              conversationStarters: [
                {
                  suggestion: {
                    reply: {
                      text: 'Set up an account',
                      postbackData: 'new-account',
                    },
                  },
                },
                {
                  suggestion: {
                    reply: {
                      text: 'Look up account information',
                      postbackData: 'account-lookup',
                    },
                  },
                },
              ],
            },
          }
        }
      }
    };

    bcApi.brands.agents.patch(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent found
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

main();

Ce code est basé sur la bibliothèque cliente Business Communications pour Node.js.

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.*;
import com.google.common.collect.ImmutableMap;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String agentName = "brands/BRAND_ID/agents/AGENT_ID";

      Agent agent = new Agent().setBusinessMessagesAgent(
          new BusinessMessagesAgent().setConversationalSettings(ImmutableMap.of("en",
              new ConversationalSetting()
                  .setPrivacyPolicy(new PrivacyPolicy().setUrl("https://www.growingtreebank.com/privacy"))
                  .setWelcomeMessage(new WelcomeMessage().setText("Thanks for contacting Growing Tree Bank. What can I help with today?"))
                  .setOfflineMessage(new OfflineMessage().setText("We're closed for the night. Please reach out to us again tomorrow."))
                  .setConversationStarters(Arrays.asList(
                      new ConversationStarters().setSuggestion(new Suggestion()
                          .setReply(new SuggestedReply()
                              .setText("Set up an account")
                              .setPostbackData("new-account"))),
                      new ConversationStarters().setSuggestion(new Suggestion()
                          .setReply(new SuggestedReply()
                              .setText("Look up account information")
                              .setPostbackData("account-lookup")))
                      )))));

      BusinessCommunications.Brands.Agents.Patch request = builder
          .build().brands().agents().patch(agentName, agent);

      request.setUpdateMask("businessMessagesAgent.conversationalSettings.en");

      Agent updatedAgent = request.execute();
      System.out.println(updatedAgent.toPrettyString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import (
    BusinesscommunicationsV1
)
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinessMessagesAgent,
    ConversationStarters,
    ConversationalSetting,
    OfflineMessage,
    PrivacyPolicy,
    WelcomeMessage,
    BusinesscommunicationsBrandsAgentsPatchRequest,
)

SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = 'PATH_TO_SERVICE_ACCOUNT_KEY'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

agent_name = 'brands/BRAND_ID/agents/AGENT_ID'

agent=Agent(
		businessMessagesAgent=BusinessMessagesAgent(
		  	conversationalSettings=BusinessMessagesAgent.ConversationalSettingsValue(
		        additionalProperties=[BusinessMessagesAgent.ConversationalSettingsValue.AdditionalProperty(
		            key='en',
		            value=ConversationalSetting(
		                privacyPolicy=PrivacyPolicy(url='https://www.growingtreebank.com/privacy'),
		                welcomeMessage=WelcomeMessage(text='Thanks for contacting Growing Tree Bank. What can I help with today?'),
		                offlineMessage=OfflineMessage(text='We\'re closed for the night. Please reach out to us again tomorrow.'),
		                conversationStarters=[
		                    ConversationStarters(
		                        suggestion=Suggestion(
		                            reply=SuggestedReply(text='Set up an account',
		                                postbackData='new-account')
		                        )
		                    ),
		                    ConversationStarters(
		                        suggestion=Suggestion(
		                            reply=SuggestedReply(text='Look up account information',
		                                postbackData='account-lookup')
		                        )
		                    )]
		                )
		            )
		        ]
		    )
		)
)

updated_agent = agents_service.Patch(
        BusinesscommunicationsBrandsAgentsPatchRequest(
            agent=agent,
            name=agent_name,
            updateMask='businessMessagesAgent.conversationalSettings.en'
        )
    )

print(updated_agent)

Ce code est basé sur la bibliothèque cliente Python Business Communications.

Supprimer un agent

Lorsque vous supprimez un agent, Business Messages supprime toutes ses données. Les messages envoyés par votre agent qui sont en transit vers l'appareil d'un utilisateur ou qui y sont stockés ne sont pas supprimés par Messages d'entreprise. Les messages envoyés aux utilisateurs ne sont pas des données d'agent.

Les requêtes de suppression échouent si l'agent est associé à un emplacement ou si vous avez tenté de le valider une ou plusieurs fois. Pour mettre à jour des emplacements, consultez Ajouter des emplacements.

Vous ne pouvez pas supprimer un agent validé. Pour supprimer un agent que vous avez validé ou tenté de valider, nous contacter. (Vous devez d'abord vous connecter avec un compte Google Business Messages. Pour vous inscrire, consultez S'inscrire à Business Messages.

Avertissement :La suppression d'un agent supprime définitivement toutes les informations le concernant de Business Messages.

Pour supprimer un agent, exécutez la commande suivante. Remplacez BRAND_ID et AGENT_ID par les valeurs uniques de l'name de l'agent.

cURL

# This code deletes an agent.
# Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/delete

# Replace the __BRAND_ID__ and __AGENT_ID__
# Make sure a service account key file exists at ./service_account_key.json

curl -X DELETE "https://businesscommunications.googleapis.com/v1/brands/__BRAND_ID__/agents/__AGENT_ID__" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json ./service_account_key.json businesscommunications)"
delete-agent.sh

Node.js

/**
 * This code snippet deletes an agent.
 * Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/delete
 *
 * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
 * Business Communications client library.
 */

/**
 * Edit the values below:
 */
const BRAND_ID = 'EDIT_HERE';
const AGENT_ID = 'EDIT_HERE';
const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);

async function main() {
  const authClient = await initCredentials();

  const agentName = 'brands/' + BRAND_ID + '/agents/' + AGENT_ID;

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: agentName,
    };

    bcApi.brands.agents.delete(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Agent removed
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
 async function initCredentials() {
  // Configure a JWT auth client
  const authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

main();
delete-agent.js

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.*;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String agentName = "brands/BRAND_ID/agents/AGENT_ID";

      BusinessCommunications.Brands.Agents.Delete request
         = builder.build().brands().agents().delete(agentName);

      System.out.println(request.execute());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

"""This code deletes an agent.

Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands.agents/delete

This code is based on the https://github.com/google-business-communications/python-businessmessages
Python Business Messages client library.
"""

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
from businesscommunications.businesscommunications_v1_messages import (
    Agent,
    BusinesscommunicationsBrandsAgentsDeleteRequest,
)

# Edit the values below:
BRAND_ID = 'EDIT_HERE'
AGENT_ID = 'EDIT_HERE'
SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = './service_account_key.json'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

agent_name = 'brands/' + BRAND_ID + '/agents/' + AGENT_ID

agent = agents_service.Delete(BusinesscommunicationsBrandsAgentsDeleteRequest(
        name=agent_name
    ))

print(agent)
delete-agent.py

Pour connaître les options de mise en forme et de valeur, consultez brands.agents.delete.

Supprimer une marque

Lorsque vous supprimez une marque, vous effectuez une requête DELETE avec l'API Business Communications. Les requêtes de suppression échouent si une ou plusieurs agences ou zones géographiques sont associées à la marque, même si ces agences appartiennent à un autre produit.

Avertissement :La suppression d'une marque supprime définitivement toutes les informations la concernant. Le paramètre ?force=true supprime également tous les agents (pour tous les produits) et tous les emplacements associés.

Pour supprimer une marque, exécutez la commande suivante. Remplacez BRAND_ID par la valeur unique de l'name de la marque.

cURL

# This code deletes a brand.
# Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/delete

# Replace the __BRAND_ID__
# Make sure a service account key file exists at ./service_account_key.json

curl -X DELETE "https://businesscommunications.googleapis.com/v1/brands/__BRAND_ID__" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-communications" \
-H "$(oauth2l header --json ./service_account_key.json businesscommunications)"
delete-brand.sh

Node.js

/**
 * This code snippet deletes a brand.
 * Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/delete
 *
 * This code is based on the https://github.com/google-business-communications/nodejs-businesscommunications Node.js
 * Business Communications client library.
 */

/**
 * Edit the values below:
 */
const BRAND_ID = 'EDIT_HERE';
const PATH_TO_SERVICE_ACCOUNT_KEY = './service_account_key.json';

const businesscommunications = require('businesscommunications');
const {google} = require('googleapis');

// Initialize the Business Communications API
const bcApi = new businesscommunications.businesscommunications_v1.Businesscommunications({});

// Set the scope that we need for the Business Communications API
const scopes = [
  'https://www.googleapis.com/auth/businesscommunications',
];

// Set the private key to the service account file
const privatekey = require(PATH_TO_SERVICE_ACCOUNT_KEY);

async function main() {
  const authClient = await initCredentials();

  const brandName = 'brands/' + BRAND_ID;

  if (authClient) {
    // Setup the parameters for the API call
    const apiParams = {
      auth: authClient,
      name: brandName,
    };

    bcApi.brands.delete(apiParams, {}, (err, response) => {
      if (err !== undefined && err !== null) {
        console.dir(err);
      } else {
        // Brand removed
        console.log(response.data);
      }
    });
  }
  else {
    console.log('Authentication failure.');
  }
}

/**
 * Initializes the Google credentials for calling the
 * Business Messages API.
 */
 async function initCredentials() {
  // Configure a JWT auth client
  const authClient = new google.auth.JWT(
    privatekey.client_email,
    null,
    privatekey.private_key,
    scopes,
  );

  return new Promise(function(resolve, reject) {
    // Authenticate request
    authClient.authorize(function(err, tokens) {
      if (err) {
        reject(false);
      } else {
        resolve(authClient);
      }
    });
  });
}

main();
delete-brand.js

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.businesscommunications.v1.BusinessCommunications;
import com.google.api.services.businesscommunications.v1.model.*;
import java.io.FileInputStream;
import java.util.Arrays;

class Main {
  /**
   * Initializes credentials used by the Business Communications API.
   */
  private static BusinessCommunications.Builder getBusinessCommunicationsBuilder() {
    BusinessCommunications.Builder builder = null;
    try {
      GoogleCredential credential = GoogleCredential
            .fromStream(new FileInputStream("PATH_TO_SERVICE_ACCOUNT_KEY"));

      credential = credential.createScoped(Arrays.asList(
          "https://www.googleapis.com/auth/businesscommunications"));

      credential.refreshToken();

      HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      JacksonFactory jsonFactory = JacksonFactory.getDefaultInstance();

      // Create instance of the Business Communications API
      builder = new BusinessCommunications
          .Builder(httpTransport, jsonFactory, null)
          .setApplicationName(credential.getServiceAccountProjectId());

      // Set the API credentials and endpoint
      builder.setHttpRequestInitializer(credential);
    } catch (Exception e) {
      e.printStackTrace();
    }

    return builder;
  }

  public static void main(String args[]) {
    try {
      // Create client library reference
      BusinessCommunications.Builder builder = getBusinessCommunicationsBuilder();

      String brandName = "brands/BRAND_ID";

      BusinessCommunications.Brands.Delete request = builder.build().brands().delete(brandName);

      System.out.println(request.execute());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ce code est basé sur la bibliothèque cliente Java Business Communications.

Python

"""This code deletes a brand.

Read more: https://developers.google.com/business-communications/business-messages/reference/business-communications/rest/v1/brands/delete

This code is based on the https://github.com/google-business-communications/python-businessmessages
Python Business Messages client library.
"""

from oauth2client.service_account import ServiceAccountCredentials
from businesscommunications.businesscommunications_v1_client import BusinesscommunicationsV1
from businesscommunications.businesscommunications_v1_messages import (
    BusinesscommunicationsBrandsAgentsDeleteRequest
)

# Edit the values below:
BRAND_ID = 'EDIT_HERE'
SCOPES = ['https://www.googleapis.com/auth/businesscommunications']
SERVICE_ACCOUNT_FILE = './service_account_key.json'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)

client = BusinesscommunicationsV1(credentials=credentials)

agents_service = BusinesscommunicationsV1.BrandsAgentsService(client)

brand_name = 'brands/' + BRAND_ID

agent = agents_service.Delete(BusinesscommunicationsBrandsAgentsDeleteRequest(
        name=brand_name
    ))

print(agent)
delete-brand.py

Pour connaître les options de mise en forme et de valeur, consultez brands.delete.

Étapes suivantes

Maintenant que vous avez un agent, procédez comme suit:

• Ajouter des zones géographiques à votre agent
• Concevoir l'expérience conversationnelle
• Développer vos flux de messages