Envía encuestas para hacer un seguimiento de la satisfacción de los usuarios

Encuesta personalizada en una conversación de Mensajes de Negocios.

Para asegurarse de que los usuarios tengan interacciones satisfactorias con tu agente, Google les envía encuestas después de que terminan las conversaciones con él. Si deseas recopilar datos en diferentes momentos, por ejemplo, al final de una conversación, puedes enviar encuestas en el contexto de una conversación. Las encuestas se muestran en la conversación y permiten que los usuarios proporcionen comentarios con una variedad de opciones según la pregunta.

El momento en que se activan las encuestas de Google depende de la disponibilidad de mensajería del agente:

Disponibilidad Momento de la encuesta
Solo para bots 30 minutos después del último mensaje
Solo para humanos 24 horas hábiles después del último mensaje
Bot y humano 24 horas hábiles después del último mensaje

Si hay menos de 24 horas hábiles en los próximos 7 días, usamos 24 horas.

Puedes enviar una encuesta por conversación cada 24 horas. Si envías una encuesta en una conversación antes de que lo haga Google, Google no enviará una encuesta a esa conversación. Si tu agente envía varias encuestas en la misma conversación en un plazo de 24 horas, Mensajes de Negocios solo intentará enviar la primera encuesta al usuario.

La próxima vez que un usuario inicie una conversación con tu agente después de completar una encuesta, el agente mostrará un saludo. Si un usuario no responde una encuesta, esta vence después de 7 días y, en su próxima conversación, verá un saludo después del vencimiento de la encuesta.

Si un usuario envía un mensaje no relacionado con una encuesta mientras esta está activa en la conversación, Mensajes de Negocios cancela la encuesta y envía el mensaje del usuario al webhook del agente.

Si no envías encuestas a los usuarios, tu agente recibirá los resultados de las encuestas de Google en tu webhook y deberá aceptarlos y procesarlos según corresponda.

Preguntas

Las encuestas pueden incluir hasta cinco preguntas, divididas en tres categorías: obligatorias, de plantilla y personalizadas. Una encuesta siempre incluye la pregunta obligatoria, luego muestra hasta dos preguntas de plantilla y, por último, muestra hasta dos preguntas personalizadas.

Pregunta obligatoria

La pregunta obligatoria se localiza en todas las configuraciones regionales que admite Mensajes de Negocios. Los usuarios pueden responder con Me gusta o No me gusta.

La pregunta obligatoria: "¿Este servicio de mensajería ayudó a resolver tus necesidades con AGENT_NAME?"

Preguntas de la plantilla

Las preguntas de plantilla son preguntas opcionales definidas por Google que se localizan en todas las configuraciones regionales que admite Business Messages. Una encuesta puede incluir hasta dos preguntas de plantilla. Los formatos de respuesta del usuario varían según la pregunta.

Las preguntas de la plantilla incluyen lo siguiente:

  • ¿Cómo fue tu experiencia enviándole mensajes a AGENT_NAME?
  • ¿Qué tan probable es que recomiendes AGENT_NAME a un amigo?
  • La próxima vez que te pongas en contacto con AGENT_NAME, ¿qué tan probable es que elijas hacerlo por mensajería?
  • En general, ¿qué tan fácil te resultó interactuar con AGENT_NAME?
  • ¿En qué medida estás de acuerdo o en desacuerdo con la siguiente afirmación?: AGENT_NAME hizo que fuera fácil solucionar mi problema.
  • Califica tu satisfacción general con el agente de asistencia.
  • ¿Esta sesión de chat te evitó llamar a AGENT_NAME?

Para ver una lista de todas las preguntas de plantilla disponibles y obtener los IDs de las plantillas, haz lo siguiente:

  1. Abre la consola de Business Communications para desarrolladores y accede con tu Cuenta de Google de Business Messages.
  2. Elige tu agente.
  3. En el menú de navegación de la izquierda, haz clic en Encuesta.

Preguntas personalizadas

Una encuesta puede incluir hasta dos preguntas personalizadas. Si especificas una pregunta personalizada, incluye versiones de la pregunta para cada configuración regional que admita tu agente. Debes especificar una versión de cada pregunta para tu configuración regional predeterminada. Si un usuario recibe una encuesta, pero se encuentra en una configuración regional que no tiene una versión especificada de una pregunta personalizada, la pregunta se mostrará tal como se define en la configuración regional predeterminada del agente.

Las respuestas a preguntas personalizadas admiten datos de texto y de devolución de llamada separados, de forma similar a las respuestas sugeridas.

Cómo personalizar una encuesta

Para personalizar la encuesta para un agente, haz lo siguiente:

  1. Abre la consola de Business Communications para desarrolladores y accede con tu Cuenta de Google de Business Messages.
  2. Elige tu agente.
  3. En el menú de navegación de la izquierda, haz clic en Encuesta.
  4. Agrega hasta dos preguntas de plantilla disponibles a la encuesta.
  5. Haz clic en Crear una pregunta personalizada para agregar preguntas personalizadas a tu encuesta.

Para conocer las opciones de formato y valores, consulta surveyConfig.

Envía una encuesta

Encuesta

Para enviar una encuesta, ejecuta el siguiente comando. Reemplaza CONVERSATION_ID por el identificador de la conversación a la que deseas enviar la encuesta y SURVEY_ID por un identificador único para la encuesta.

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

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

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

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)

Para conocer las opciones de formato y valores, consulta conversations.surveys.

Recibe respuestas a encuestas

Cuando un usuario responde una pregunta en una encuesta, tu agente recibe la respuesta en su webhook. Recibir y procesar las respuestas de la encuesta de la misma manera en que recibes mensajes

Todas las preguntas de una encuesta tienen el mismo valor de surveyResponse.survey. Si tu encuesta incluye varias preguntas, asegúrate de que tu infraestructura acepte varias respuestas con el mismo valor de surveyResponse.survey y que identifique las preguntas individuales por el campo surveyResponse.surveyQuestionId.

Los valores de texto para las respuestas de la encuesta aparecen en surveyResponse.questionResponseText. En el caso de las preguntas obligatorias y las de plantilla, Mensajes de Negocios devuelve una respuesta de me gusta como VERY_SATISFIED y una respuesta de no me gusta como VERY_DISSATISFIED. Si una respuesta a una pregunta personalizada incluye un emoji, se recomienda usar surveyResponse.questionResponsePostbackData en lugar de intentar analizar el valor Unicode.

Las respuestas de la encuesta tienen el siguiente formato.

{
  "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"
  }
}

Para conocer las opciones de formato y valores, consulta UserMessage y SurveyResponse.