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

Elige si quieres administrar agentes con Business Communications Desarrollador Console o API.

Consola para desarrolladores API .

Para garantizar que los usuarios tengan interacciones satisfactorias con tu agente, Google envía encuestas a los usuarios una vez que finalizan las conversaciones con tu agente. Si Desea recopilar datos con distintos tiempos, por ejemplo, al final de conversación, puedes enviar encuestas en el contexto de un conversación. Las encuestas se muestran en la conversación y permiten que los usuarios proporcionen feedback con una variedad de opciones según la pregunta.

El momento de las encuestas activadas por Google depende de la mensajería del agente disponibilidad:

Disponibilidad	Horario de la encuesta
Solo bot	30 minutos después del último mensaje
Solo para personas	24 horas hábiles después del último mensaje
Bot y humanos	24 horas hábiles después del último mensaje

Si hay < 24 horas hábiles en los próximos 7 días, en cambio, 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 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, Business Messages solo intenta enviar la primera encuesta al usuario.

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

Si un usuario envía un mensaje no relacionado con una encuesta mientras esta está activa en el Business Messages cancelará la encuesta y enviará el mensaje del usuario al webhook del agente.

Aunque no envíes encuestas a los usuarios, tu agente igualmente recibirá los resultados de las encuestas de Google en su webhook, y debe aceptarlos y procesarlos. en consecuencia.

Nota: Google no envía encuestas automáticamente en las conversaciones que se inician desde en Business Messages Widget o la entrada de URL punto. Debes envía encuestas para recopilar datos de estos puntos de entrada.

Preguntas

Las encuestas pueden incluir hasta cinco preguntas, divididas en tres categorías: required, template y custom. Una encuesta Siempre incluye la pregunta obligatoria y muestra hasta dos plantillas preguntas y luego muestra hasta dos preguntas personalizadas.

Pregunta obligatoria

La pregunta obligatoria está localizada en todas las configuraciones regionales en las que Business Messages admite. Los usuarios pueden responder con un Me gusta o No me gusta.

La pregunta obligatoria: "¿Este servicio de mensajería abordó tus necesidades con AGENT_NAME.

Preguntas sobre la plantilla

Las preguntas de plantilla son opcionales, definidas por Google y localizadas en todas las configuraciones regionales que admite Business Messages. Una encuesta puede incluir hasta dos plantillas de preguntas. 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 enviando mensajes a AGENT_NAME?
• ¿Qué tan probable es que recomiendes AGENT_NAME a un amigo?
• La próxima vez que te comuniques con AGENT_NAME, ¿qué tan probable es que ¿Quieres elegir la opción de 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 me ayudó a resolver el problema.
• Califica tu nivel de satisfacción general con el agente que te brindó 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 página de desarrollador de comunicaciones empresariales. Consola y accede con tu Cuenta de Google de Business Messages.
2. Elige tu agente.
3. En el panel de navegación de la izquierda, haz clic en Encuesta.

Preguntas personalizadas

Una encuesta puede incluir hasta dos preguntas personalizadas. Si especificas una configuración pregunta, incluye versiones de la pregunta para cada configuración regional que admite tu agente. Debes especificar una versión de cada pregunta para tu la configuración regional predeterminada. Si un usuario recibe una encuesta, pero se encuentra en una región que no tiene una versión específica de una pregunta personalizada, la pregunta se muestra como está definida en la configuración regional predeterminada del agente.

Las respuestas a las preguntas personalizadas admiten texto independiente y datos de notificación de conversión, similares a sugerido respuestas.

Personaliza una encuesta

Para personalizar la encuesta para un agente,

1. Abre la página de desarrollador de comunicaciones empresariales. Consola y accede con tu Cuenta de Google de Business Messages.
2. Elige tu agente.
3. En el panel de navegación de la izquierda, haz clic en Encuesta.
4. Agrega a la encuesta hasta dos plantillas de preguntas disponibles.
5. Haz clic en Crear una pregunta personalizada para agregar preguntas personalizadas a tu encuesta.

Para ver las opciones de formato y valor, consulta surveyConfig

Enviar una encuesta

Para enviar una encuesta, ejecuta el siguiente comando. Reemplazar CONVERSATION_ID con el identificador de la conversación a la que deseas enviar la encuesta y SURVEY_ID con 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)"
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

Para ver las opciones de formato y valor, consulta conversations.surveys

Recibir respuestas de la encuesta

Cuando un usuario responde una pregunta de una encuesta, tu agente recibe la respuesta en su webhook. Recibe y procesa las respuestas a las encuestas de la misma forma en que las recibes. mensajes.

Todas las preguntas de una encuesta tienen el mismo valor de surveyResponse.survey. Si incluya varias preguntas, asegúrese de que su infraestructura acepte varias respuestas con el mismo valor de surveyResponse.survey e identifica preguntas individuales en el campo surveyResponse.surveyQuestionId.

Los valores de texto de las respuestas de la encuesta aparecen en surveyResponse.questionResponseText Para las preguntas obligatorias y de plantilla, Business Messages devuelve una respuesta de Me gusta como VERY_SATISFIED y un Me gusta respuesta descendente como VERY_DISSATISFIED. Si la respuesta de una pregunta personalizada incluye un emoji, es una práctica recomendada confiar en el surveyResponse.questionResponsePostbackData en lugar de intentar analizar Unicode.

Precaución: surveyResponse.rating dejó de estar disponible. Usa surveyResponse.questionResponseText en su lugar.

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 ver las opciones de formato y valor, consulta UserMessage y SurveyResponse