Envoyer des enquêtes pour suivre la satisfaction des utilisateurs

<ph type="x-smartling-placeholder">

</ph> Indiquez si vous souhaitez gérer les agents avec Business Communications Développeur la console ou l'API.

<ph type="x-smartling-placeholder"></ph> Console développeur API

Pour garantir que les utilisateurs ont des interactions satisfaisantes avec votre agent, Google envoie des enquêtes aux utilisateurs une fois qu'ils ont terminé les conversations avec votre agent. Si vous souhaitez collecter des données avec des délais différents, par exemple à la fin de une conversation, vous pouvez envoyer des enquêtes dans le contexte conversationnelle. Les enquêtes s'affichent dans la conversation et permettent aux utilisateurs feedback avec différentes options en fonction de la question.

La diffusion des enquêtes déclenchées par Google dépend du message de l'agent. disponibilité:

Disponibilité	Durée de l'enquête
Bot uniquement	30 minutes après le dernier message
Humain uniquement	24 heures ouvrées après le dernier message
Bot et humain	24 heures ouvrées après le dernier message

S'il y a < 24 heures ouvrées dans les sept prochains jours. Nous allons utiliser 24 heures à la place.

Vous pouvez envoyer une enquête par conversation toutes les 24 heures. Si vous envoyez une enquête dans à une conversation avant Google, Google n'envoie pas d'enquête à cette conversation. Si votre agent envoie plusieurs enquêtes dans la même conversation dans les 24 heures, Business Messages tente uniquement d'envoyer la première enquête à l'utilisateur.

La prochaine fois qu'un utilisateur entame une conversation avec votre agent après avoir effectué une l'agent affiche un message d'accueil. Si un utilisateur ne répond pas à une enquête, celle-ci expire au bout de sept jours, et le l'utilisateur voit un message d'accueil dans sa prochaine conversation après l'expiration de l'enquête.

Si un utilisateur envoie un message sans rapport avec une enquête alors qu'une enquête est en cours dans la conversation, Business Messages annule l'enquête et envoie le message de l'utilisateur au webhook de l'agent.

Si vous n'envoyez pas d'enquêtes aux utilisateurs, votre agent reçoit quand même les résultats des enquêtes Google sur votre webhook. Vous devez les accepter et les traiter. en conséquence.

Remarque :Google n'envoie pas automatiquement d'enquêtes dans les conversations démarrées depuis Business Messages widget ou l'URL de sécurité. Vous devez envoyez des enquêtes pour recueillir des données d'enquête à partir de ces points d'entrée.

Questions

Les enquêtes peuvent comporter jusqu'à cinq questions, réparties en trois catégories: required, template et custom. Une enquête inclut toujours la question requise, puis affiche jusqu'à deux modèles puis affiche jusqu'à deux questions personnalisées.

Question obligatoire

La question obligatoire est localisée dans toutes les langues pour lesquelles Business Messages compatibles. Les utilisateurs peuvent répondre en choisissant "J'aime" ou "Je n'aime pas".

à la question : "Ce service de messagerie a-t-il répondu à vos besoins avec AGENT_NAME ?"

Modèle de questions

Il s'agit de questions facultatives définies par Google et localisées. dans tous les paramètres régionaux compatibles avec Business Messages. Une enquête peut inclure jusqu'à deux modèles de questions. Les formats de réponse des utilisateurs varient selon les questions.

Les questions types incluent

• Comment s'est passée votre conversation avec AGENT_NAME via l'option Messages ?
• Quelle est la probabilité que vous recommandiez AGENT_NAME à un ami ?
• La prochaine fois que vous contacterez AGENT_NAME, quelle est la probabilité que Choisir l'option Messages ?
• Dans l'ensemble, avez-vous trouvé facile d'interagir avec AGENT_NAME ?
• Êtes-vous d'accord avec l'affirmation suivante: AGENT_NAME m'a permis de résoudre facilement mon problème.
• Veuillez évaluer votre niveau de satisfaction général vis-à-vis de l'agent de l'équipe d'assistance.
• Cette session de chat vous a-t-elle aidé à éviter d'appeler le AGENT_NAME ?

Pour afficher la liste de tous les modèles de questions disponibles et obtenir les ID de modèle, procédez comme suit :

1. Ouvrez l'application Business Communications Developer Console et connectez-vous avec votre compte Google Business Messages.
2. Choisissez votre agent.
3. Dans le volet de navigation de gauche, cliquez sur Enquête.

Questions personnalisées

Une enquête peut inclure jusqu'à deux questions personnalisées. Si vous spécifiez un de la question, incluez des versions de la question pour chaque paramètres régionaux compatibles avec votre agent. Vous devez spécifier une version de chaque question pour votre paramètres régionaux par défaut. Si un utilisateur reçoit une enquête, mais qu'il utilise une langue une version spécifique d'une question personnalisée, la question s'affiche telle qu'elle est définie dans les paramètres régionaux par défaut de l'agent.

Les réponses aux questions personnalisées permettent d'utiliser des données distinctes pour le texte et le postback. à suggérés réponses.

Personnaliser une enquête

Pour personnaliser l'enquête pour un agent, procédez comme suit :

1. Ouvrez l'application Business Communications Developer Console et connectez-vous avec votre compte Google Business Messages.
2. Choisissez votre agent.
3. Dans le volet de navigation de gauche, cliquez sur Enquête.
4. Ajoutez à l'enquête jusqu'à deux modèles de questions disponibles.
5. Cliquez sur Créer une question personnalisée pour ajouter des questions personnalisées à votre enquête.

Pour connaître les options de mise en forme et de valeur, consultez surveyConfig

Envoyer une enquête

Pour envoyer une enquête, exécutez la commande suivante. Remplacer CONVERSATION_ID par l'identifiant de la conversation à laquelle vous souhaitez envoyer l'enquête et SURVEY_ID par un identifiant unique pour l'enquête.

cURL

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at

#     https://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# This code sends a survey to the user:
# Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/message/surveys?hl=en

# Replace the __CONVERSATION_ID__ with a conversation id that you can send messages to
# Make sure a service account key file exists at ./service_account_key.json

curl -X POST "https://businessmessages.googleapis.com/v1/conversations/__CONVERSATION_ID__/surveys?surveyId=f4bd7576-6c2e-4674-9db4-d697166f63ce" \
-H "Content-Type: application/json" \
-H "User-Agent: curl/business-messages" \
-H "$(oauth2l header --json ./service_account_key.json businessmessages)"
send-survey.sh

Node.js

/**
 * This code sends a survey to the user:
 * Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/message/surveys?hl=en
 *
 * This code is based on the https://github.com/google-business-communications/nodejs-businessmessages Node.js
 * Business Messages client library.
 */

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

const businessmessages = require('businessmessages');
const uuidv4 = require('uuid').v4;
const {google} = require('googleapis');

// Initialize the Business Messages API
const bmApi = new businessmessages.businessmessages_v1.Businessmessages({});

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

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

/**
 * Posts a survey to the Business Messages API.
 *
 * @param {string} conversationId The unique id for this user and agent.
 */
async function sendSurvey(conversationId) {
  const authClient = await initCredentials();

  // Create the payload for creating a new survey
  const apiParams = {
    auth: authClient,
    parent: 'conversations/' + conversationId,
    surveyId: uuidv4(),
    resource: {}
  };

  // Call the message create function using the
  // Business Messages client library
  bmApi.conversations.surveys.create(apiParams,
    {auth: authClient}, (err, response) => {
    console.log(err);
    console.log(response);
  });
}

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

sendSurvey(CONVERSATION_ID);
send-survey.js

Java

import com.google.api.client.googleapis.services.AbstractGoogleClientRequest;
import com.google.api.client.http.HttpBackOffUnsuccessfulResponseHandler;
import com.google.api.client.http.HttpRequest;
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.client.util.ExponentialBackOff;
import com.google.api.services.businessmessages.v1.Businessmessages;
import com.google.api.services.businessmessages.v1.model.*;
import java.io.FileInputStream;
import java.util.Arrays;
import java.util.UUID;

class SendSurveySnippet {
  /**
   * Initializes credentials used by the Business Messages API.
   */
  private static Businessmessages.Builder getBusinessMessagesBuilder() {
    Businessmessages.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/businessmessages"));

      credential.refreshToken();

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

      // Create instance of the Business Messages API
      builder = new Businessmessages
        .Builder(httpTransport, jsonFactory, null)
        .setApplicationName("Sample Application");

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

    return builder;
  }

  public static void main(String args[]) {
    try {
      String conversationId = "CONVERSATION_ID";

      // Create client library reference
      Businessmessages.Builder builder = getBusinessMessagesBuilder();

      // Create a new survey to send to the user associated with the conversationId
      Businessmessages.Conversations.Surveys.Create request
          = bmBuilder.build().conversations().surveys()
          .create("conversations/" + conversationId,
              new BusinessMessagesSurvey());

      request.setSurveyId(UUID.randomUUID().toString());

      // Setup retries with exponential backoff
      HttpRequest httpRequest =
          ((AbstractGoogleClientRequest) request).buildHttpRequest();

      httpRequest.setUnsuccessfulResponseHandler(new
          HttpBackOffUnsuccessfulResponseHandler(
          new ExponentialBackOff()));

      // Execute request
      httpRequest.execute();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}
SendSurveySnippet.java

Python

"""This code sends a survey to the user.

Read more: https://developers.google.com/business-communications/business-messages/guides/how-to/message/surveys?hl=en

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

import uuid

from businessmessages import businessmessages_v1_client as bm_client
from businessmessages.businessmessages_v1_messages import BusinessmessagesConversationsSurveysCreateRequest
from businessmessages.businessmessages_v1_messages import BusinessMessagesSurvey
from oauth2client.service_account import ServiceAccountCredentials

# Edit the values below:
path_to_service_account_key = './service_account_key.json'
conversation_id = 'EDIT_HERE'

credentials = ServiceAccountCredentials.from_json_keyfile_name(
    path_to_service_account_key,
    scopes=['https://www.googleapis.com/auth/businessmessages'])

client = bm_client.BusinessmessagesV1(credentials=credentials)

# Create the survey request
survey_request = BusinessmessagesConversationsSurveysCreateRequest(
    surveyId=str(uuid.uuid4().int),
    parent='conversations/' + conversation_id,
    businessMessagesSurvey=BusinessMessagesSurvey())

# Send the survey
bm_client.BusinessmessagesV1.ConversationsSurveysService(
    client=client).Create(request=survey_request)
send-survey.py

Pour connaître les options de mise en forme et de valeur, consultez conversations.surveys

Recevoir des réponses aux enquêtes

Lorsqu'un utilisateur répond à une question d'une enquête, votre agent reçoit la réponse au niveau de son webhook. Recevez et traitez les réponses aux enquêtes de la même manière que vous recevez messages.

Toutes les questions d'une enquête ont la même valeur surveyResponse.survey. Si si votre enquête comporte plusieurs questions, assurez-vous que votre infrastructure accepte plusieurs réponses avec la même valeur surveyResponse.survey et identifie des questions individuelles via le champ surveyResponse.surveyQuestionId.

Les valeurs textuelles des réponses à l'enquête apparaissent dans surveyResponse.questionResponseText Pour les questions obligatoires et types, Business Messages renvoie une réponse "J'aime" sous la forme VERY_SATISFIED et une mention "J'aime" vers le bas en tant que VERY_DISSATISFIED. Si une réponse à une question personnalisée inclut d'emoji, il est recommandé de compter sur surveyResponse.questionResponsePostbackData plutôt que d'essayer d'analyser la Valeur Unicode

Attention :surveyResponse.rating est obsolète. Utilisez surveyResponse.questionResponseText à la place.

Les réponses à l'enquête se présentent sous le format suivant :

{
  "agent": "brands/BRAND_ID/agents/AGENT_ID",
  "sendTime": "SEND_TIME",
  "conversationId": "CONVERSATION_ID",
  "requestId": "REQUEST_ID",
  "surveyResponse": {
    "survey": "conversations/CONVERSATION_ID/surveys/SURVEY_ID",
    "rating": "SURVEY_RATING",
    "createTime": "CREATE_TIME",
    "surveyQuestionId": "QUESTION_ID",
    "questionResponseText": "RESPONSE_TEXT",
    "questionResponsePostbackData": "RESPONSE_POSTBACK_DATA",
    "questionType": "QUESTION_TYPE",
    "questionIndex": QUESTION_INDEX,
    "totalQuestionCount": TOTAL_QUESTION_COUNT,
    "surveyTriggerSource": "TRIGGER_SOURCE"
  }
}

Pour connaître les options de mise en forme et de valeur, consultez UserMessage et SurveyResponse