Collecter et traiter les informations des utilisateurs de Google Chat

Ce guide explique comment les applications Google Chat peuvent collecter et traiter les informations des utilisateurs en créant des entrées de formulaire dans des interfaces basées sur des fiches.

Les applications Chat demandent des informations aux utilisateurs pour effectuer des actions dans Chat ou en dehors, y compris de la manière suivante :

• Configurer les paramètres. Par exemple, pour permettre aux utilisateurs de personnaliser les paramètres de notification ou de configurer et d'ajouter l'application Chat à un ou plusieurs espaces.
• Créer ou mettre à jour des informations dans d'autres applications Google Workspace. Par exemple, permettre aux utilisateurs de créer un événement Google Agenda.
• Permettre aux utilisateurs d'accéder à des ressources et de les mettre à jour dans d'autres applications ou services Web. Par exemple, une application Chat peut aider les utilisateurs à mettre à jour l'état d'un ticket d'assistance directement depuis un espace Chat.

Prérequis

Créer des formulaires à l'aide de fiches

Pour collecter des informations, les applications Chat conçoivent des formulaires et leurs entrées, puis les intègrent dans des fiches. Pour afficher des fiches aux utilisateurs, les applications Chat peuvent utiliser les interfaces Chat suivantes :

• Messages contenant une ou plusieurs fiches.
• Pages d'accueil, qui sont des fiches qui s'affichent dans l'onglet Accueil des messages privés avec l'application Chat.
• Boîtes de dialogue, qui sont des fiches qui s'ouvrent dans une nouvelle fenêtre à partir de messages et de pages d'accueil.

Les applications Chat peuvent créer des fiches à l'aide des widgets suivants :

• Widgets d'entrée de formulaire qui demandent des informations aux utilisateurs. Vous pouvez également ajouter une validation aux widgets d'entrée de formulaire pour vous assurer que les utilisateurs saisissent et mettent en forme les informations correctement. Les applications Chat peuvent utiliser les widgets d'entrée de formulaire suivants :

  • Entrées de texte (textInput) pour le texte libre ou suggéré.
  • Les entrées de sélection (selectionInput) sont des éléments d'interface utilisateur sélectionnables tels que des cases à cocher, cases d'option et menus déroulants. Les widgets d'entrée de sélection peuvent également remplir des éléments à partir de sources de données statiques ou dynamiques. Par exemple, les utilisateurs peuvent choisir parmi une liste d'espaces Chat dont ils sont membres.
  • Sélecteurs de date et d'heure (dateTimePicker) pour les entrées de date et d'heure.

• Un widget bouton permettant aux utilisateurs d'envoyer les valeurs qu'ils ont saisies dans la fiche. Une fois qu'un utilisateur a cliqué sur le bouton, l'application Chat peut alors traiter les informations qu'elle reçoit.

Dans l'exemple suivant, une fiche collecte des coordonnées à l'aide d'une entrée de texte, d'un sélecteur de date et d'heure, et d'une entrée de sélection :

Pour obtenir un exemple d'application Chat qui utilise ce formulaire de contact, consultez le code suivant :

/**
 * The section of the contact card that contains the form input widgets. Used in a dialog and card message.
 * To add and preview widgets, use the Card Builder: https://addons.gsuite.google.com/uikit/builder
 */
const CONTACT_FORM_WIDGETS = [
  {
    "textInput": {
      "name": "contactName",
      "label": "First and last name",
      "type": "SINGLE_LINE"
    }
  },
  {
    "dateTimePicker": {
      "name": "contactBirthdate",
      "label": "Birthdate",
      "type": "DATE_ONLY"
    }
  },
  {
    "selectionInput": {
      "name": "contactType",
      "label": "Contact type",
      "type": "RADIO_BUTTON",
      "items": [
        {
          "text": "Work",
          "value": "Work",
          "selected": false
        },
        {
          "text": "Personal",
          "value": "Personal",
          "selected": false
        }
      ]
    }
  }
];

# The section of the contact card that contains the form input widgets. Used in a dialog and card message.
# To add and preview widgets, use the Card Builder: https://addons.gsuite.google.com/uikit/builder
CONTACT_FORM_WIDGETS = [
  {
    "textInput": {
      "name": "contactName",
      "label": "First and last name",
      "type": "SINGLE_LINE"
    }
  },
  {
    "dateTimePicker": {
      "name": "contactBirthdate",
      "label": "Birthdate",
      "type": "DATE_ONLY"
    }
  },
  {
    "selectionInput": {
      "name": "contactType",
      "label": "Contact type",
      "type": "RADIO_BUTTON",
      "items": [
        {
          "text": "Work",
          "value": "Work",
          "selected": False
        },
        {
          "text": "Personal",
          "value": "Personal",
          "selected": False
        }
      ]
    }
  }
]

// The section of the contact card that contains the form input widgets. Used in a dialog and card message.
// To add and preview widgets, use the Card Builder: https://addons.gsuite.google.com/uikit/builder
final static private List<GoogleAppsCardV1Widget> CONTACT_FORM_WIDGETS = List.of(
  new GoogleAppsCardV1Widget().setTextInput(new GoogleAppsCardV1TextInput()
    .setName("contactName")
    .setLabel("First and last name")
    .setType("SINGLE_LINE")),
  new GoogleAppsCardV1Widget().setDateTimePicker(new GoogleAppsCardV1DateTimePicker()
    .setName("contactBirthdate")
    .setLabel("Birthdate")
    .setType("DATE_ONLY")),
  new GoogleAppsCardV1Widget().setSelectionInput(new GoogleAppsCardV1SelectionInput()
    .setName("contactType")
    .setLabel("Contact type")
    .setType("RADIO_BUTTON")
    .setItems(List.of(
      new GoogleAppsCardV1SelectionItem()
        .setText("Work")
        .setValue("Work")
        .setSelected(false),
      new GoogleAppsCardV1SelectionItem()
        .setText("Personal")
        .setValue("Personal")
        .setSelected(false)))));

/**
 * The section of the contact card that contains the form input widgets. Used in a dialog and card message.
 * To add and preview widgets, use the Card Builder: https://addons.gsuite.google.com/uikit/builder
 */
const CONTACT_FORM_WIDGETS = [
  {
    "textInput": {
      "name": "contactName",
      "label": "First and last name",
      "type": "SINGLE_LINE"
    }
  },
  {
    "dateTimePicker": {
      "name": "contactBirthdate",
      "label": "Birthdate",
      "type": "DATE_ONLY"
    }
  },
  {
    "selectionInput": {
      "name": "contactType",
      "label": "Contact type",
      "type": "RADIO_BUTTON",
      "items": [
        {
          "text": "Work",
          "value": "Work",
          "selected": false
        },
        {
          "text": "Personal",
          "value": "Personal",
          "selected": false
        }
      ]
    }
  }
];

Pour obtenir d'autres exemples de widgets interactifs que vous pouvez utiliser pour collecter des informations, consultez Concevoir une fiche ou une boîte de dialogue interactive.

Recevoir des données à partir de widgets interactifs

Chaque fois que les utilisateurs cliquent sur un bouton, les applications Chat reçoivent un événement d'interaction en fonction de l'emplacement du bouton :

• Si le bouton se trouve dans un message ou une boîte de dialogue, les applications Chat reçoivent un CARD_CLICKED événement d'interaction contenant des informations sur l'interaction. La charge utile des CARD_CLICKED événements d'interaction contient un common.formInputs objet avec toutes les valeurs saisies par l'utilisateur.

  Vous pouvez récupérer les valeurs de l'objet common.formInputs.WIDGET_NAME, où WIDGET_NAME est le name champ que vous avez spécifié pour le widget. Les valeurs sont renvoyées en tant que type de données spécifique pour le widget (représenté sous la forme d'un objet Inputs).

  L'exemple suivant montre une partie d'un événement d'interaction CARD_CLICKED dans lequel un utilisateur a saisi des valeurs pour chaque widget :

  HTTP

  {
    "type": "CARD_CLICKED",
    "common": { "formInputs": {
      "contactName": { "stringInputs": {
        "value": ["Kai 0"]
      }},
      "contactBirthdate": { "dateInput": {
        "msSinceEpoch": 1000425600000
      }},
      "contactType": { "stringInputs": {
        "value": ["Personal"]
      }}
    }}
  }
  

  Apps Script

  {
    "type": "CARD_CLICKED",
    "common": { "formInputs": {
      "contactName": { "": { "stringInputs": {
        "value": ["Kai 0"]
      }}},
      "contactBirthdate": { "": { "dateInput": {
        "msSinceEpoch": 1000425600000
      }}},
        "contactType": { "": { "stringInputs": {
        "value": ["Personal"]
      }}}
    }}
  }
  

• Si le bouton se trouve sur une page d'accueil, les applications Chat reçoivent un SUBMIT_FORM événement d'interaction. La charge utile de l'événement d'interaction contient un commonEventObject.formInputs objet avec toutes les valeurs saisies par l'utilisateur.

  Vous pouvez récupérer les valeurs de l'objet commonEventObject.formInputs.WIDGET_NAME, où WIDGET_NAME est le name champ que vous avez spécifié pour le widget. Les valeurs sont renvoyées en tant que type de données spécifique pour le widget (représenté sous la forme d'un objet Inputs).

  L'exemple suivant montre une partie d'un événement d'interaction SUBMIT_FORM dans lequel un utilisateur a saisi des valeurs pour chaque widget :

  HTTP

  {
    "type": "SUBMIT_FORM",
    "commonEventObject": { "formInputs": {
      "contactName": { "stringInputs": {
        "value": ["Kai 0"]
      }},
      "contactBirthdate": { "dateInput": {
        "msSinceEpoch": 1000425600000
      }},
      "contactType": { "stringInputs": {
        "value": ["Personal"]
      }}
    }}
  }
  

  Apps Script

  {
    "type": "SUBMIT_FORM",
    "commonEventObject": { "formInputs": {
      "contactName": { "": { "stringInputs": {
        "value": ["Kai 0"]
      }}},
      "contactBirthdate": { "": { "dateInput": {
        "msSinceEpoch": 1000425600000
      }}},
        "contactType": { "": { "stringInputs": {
        "value": ["Personal"]
      }}}
    }}
  }
  

Pour recevoir les données, votre application Chat gère l'événement d'interaction afin d'obtenir les valeurs que les utilisateurs saisissent dans les widgets. Le tableau suivant montre comment obtenir la valeur d'un widget d'entrée de formulaire donné. Pour chaque widget, le tableau indique le type de données que le widget accepte, l'endroit où la valeur est stockée dans l'événement d'interaction et un exemple de valeur.

Transférer des données vers une autre fiche

Une fois qu'un utilisateur a envoyé des informations à partir d'une fiche, vous devrez peut-être renvoyer des fiches supplémentaires pour effectuer l'une des opérations suivantes :

• Aider les utilisateurs à remplir des formulaires plus longs en créant des sections distinctes.
• Permettre aux utilisateurs de prévisualiser et de confirmer les informations de la fiche initiale afin qu'ils puissent vérifier leurs réponses avant de les envoyer.
• Remplir dynamiquement les parties restantes du formulaire. Par exemple, pour inviter les utilisateurs à créer un rendez-vous, une application Chat peut afficher une fiche initiale qui demande le motif du rendez-vous, puis remplir une autre fiche qui indique les horaires disponibles en fonction du type de rendez-vous.

Pour transférer les données saisies à partir de la fiche initiale, vous pouvez créer le button widget avec actionParameters qui contiennent le name du widget et la valeur saisie par l'utilisateur, comme illustré dans l'exemple suivant :

buttonList: { buttons: [{
  text: "Submit",
  onClick: { action: {
    function: "submitForm",
    parameters: [{
      key: "contactName", value: name }, {
      key: "contactBirthdate", value: birthdate }, {
      key: "contactType", value: type
    }]
  }}
}]}

'buttonList': { 'buttons': [{
  'text': "Submit",
  'onClick': { 'action': {
    'function': "submitForm",
    'parameters': [{
      'key': "contactName", 'value': name }, {
      'key': "contactBirthdate", 'value': birthdate }, {
      'key': "contactType", 'value': type
    }]
  }}
}]}

new GoogleAppsCardV1Widget().setButtonList(new GoogleAppsCardV1ButtonList().setButtons(List.of(new GoogleAppsCardV1Button()
  .setText("Submit")
  .setOnClick(new GoogleAppsCardV1OnClick().setAction(new GoogleAppsCardV1Action()
    .setFunction("submitForm")
    .setParameters(List.of(
      new GoogleAppsCardV1ActionParameter().setKey("contactName").setValue(name),
      new GoogleAppsCardV1ActionParameter().setKey("contactBirthdate").setValue(birthdate),
      new GoogleAppsCardV1ActionParameter().setKey("contactType").setValue(type))))))))));

buttonList: { buttons: [{
  text: "Submit",
  onClick: { action: {
    function: "submitForm",
    parameters: [{
      key: "contactName", value: name }, {
      key: "contactBirthdate", value: birthdate }, {
      key: "contactType", value: type
    }]
  }}
}]}

Lorsqu'un utilisateur clique sur le bouton, votre application Chat reçoit un CARD_CLICKED événement d'interaction à partir duquel vous pouvez recevoir des données.

Répondre à un envoi de formulaire

Après avoir reçu les données d'un message de fiche ou d'une boîte de dialogue, l'application Chat répond en accusant réception ou en renvoyant une erreur.

Dans l'exemple suivant, une application Chat envoie un message texte pour confirmer qu'elle a bien reçu un formulaire envoyé à partir d'une boîte de dialogue ou d'un message de fiche.

const contactName = event.common.parameters["contactName"];
// Checks to make sure the user entered a contact name.
// If no name value detected, returns an error message.
const errorMessage = "Don't forget to name your new contact!";
if (!contactName && event.dialogEventType === "SUBMIT_DIALOG") {
  return { actionResponse: {
    type: "DIALOG",
    dialogAction: { actionStatus: {
      statusCode: "INVALID_ARGUMENT",
      userFacingMessage: errorMessage
    }}
  }};
}

contact_name = event.get('common').get('parameters')["contactName"]
# Checks to make sure the user entered a contact name.
# If no name value detected, returns an error message.
error_message = "Don't forget to name your new contact!"
if contact_name == "" and "SUBMIT_DIALOG" == event.get('dialogEventType'):
  return { 'actionResponse': {
    'type': "DIALOG",
    'dialogAction': { 'actionStatus': {
      'statusCode': "INVALID_ARGUMENT",
      'userFacingMessage': error_message
    }}
  }}

String contactName = event.at("/common/parameters/contactName").asText();
// Checks to make sure the user entered a contact name.
// If no name value detected, returns an error message.
String errorMessage = "Don't forget to name your new contact!";
if (contactName.isEmpty() && event.at("/dialogEventType") != null && "SUBMIT_DIALOG".equals(event.at("/dialogEventType").asText())) {
  return new Message().setActionResponse(new ActionResponse()
    .setType("DIALOG")
    .setDialogAction(new DialogAction().setActionStatus(new ActionStatus()
      .setStatusCode("INVALID_ARGUMENT")
      .setUserFacingMessage(errorMessage))));
}

const contactName = event.common.parameters["contactName"];
// Checks to make sure the user entered a contact name.
// If no name value detected, returns an error message.
const errorMessage = "Don't forget to name your new contact!";
if (!contactName && event.dialogEventType === "SUBMIT_DIALOG") {
  return { actionResponse: {
    type: "DIALOG",
    dialogAction: { actionStatus: {
      statusCode: "INVALID_ARGUMENT",
      userFacingMessage: errorMessage
    }}
  }};
}

Pour traiter et fermer une boîte de dialogue, vous renvoyez un ActionResponse objet qui spécifie si vous souhaitez envoyer un message de confirmation, mettre à jour le message ou la fiche d'origine, ou simplement fermer la boîte de dialogue. Pour connaître la procédure à suivre, consultez Fermer une boîte de dialogue.

Résoudre les problèmes

Lorsqu'une application ou fiche Google Chat renvoie une erreur, l'interface Chat affiche un message indiquant "Un problème est survenu." ou "Impossible de traiter votre demande." Parfois, l'interface utilisateur Chat n'affiche aucun message d'erreur, mais l'application ou la fiche Chat produit un résultat inattendu. Par exemple, un message de fiche peut ne pas s'afficher.

Bien qu'un message d'erreur ne s'affiche pas dans l'interface utilisateur Chat, des messages d'erreur descriptifs et des données de journal sont disponibles pour vous aider à corriger les erreurs lorsque la journalisation des erreurs pour les applications Chat est activée. Pour obtenir de l'aide sur l'affichage, le débogage et la correction des erreurs, consultez Résoudre et corriger les erreurs Google Chat.

Articles associés

• Consultez l'exemple de gestionnaire de contacts, qui est une application Chat invitant les utilisateurs à remplir un formulaire de contact à partir de messages de fiche et de boîtes de dialogue.
• Ouvrir des boîtes de dialogue interactives