Kontakte in Google Chat erfassen und verwalten

In diesem Tutorial erfahren Sie, wie Sie eine Google Chat-App erstellen, mit der Google Chat-Nutzer ihre privaten und geschäftlichen Kontakte verwalten können. Um Informationen zu erfassen, werden Nutzer in der Chat App aufgefordert, in Kartennachrichten und Dialogfeldern ein Kontaktformular auszufüllen.

Sehen Sie sich die Google Chat App in Aktion an:

Vorbereitung

• Unternehmen Google Workspace-Konto mit Zugriff auf Google Chat:

Zielsetzungen

• Benutzeroberflächen (UIs) entwerfen und erstellen card-Objekten und zeigen die Benutzeroberflächen in Meldungen und Dialogfeldern an.
• Informationen empfangen und verarbeiten, die Nutzer mithilfe von Widgets für die Formulareingabe.
• Auf Slash-Befehle reagieren, indem Sie Nachrichten, die Text, Karten und Zubehör-Widgets enthalten.

Architektur

Die Chat-App ist in Google Apps Script implementiert und verwendet Interaktionsereignisse, um Chat-Nutzer zu verarbeiten und zu beantworten.

Im Folgenden sehen Sie, wie Nutzende normalerweise mit dem Chat-App:

1. Ein Nutzer öffnet eine Direktnachricht mit der Chat App oder fügt die Chat App einem vorhandenen Gruppenbereich hinzu.

2. Die Chat-App fordert den Nutzer auf, einen Kontakt hinzuzufügen, indem er ein Kontaktformular als card-Objekt erstellt und anzeigt. Wenn die Chat-App das Kontaktformular anzeigt, reagiert sie auf Nutzer auf folgende Weise:

   • auf @Erwähnungen und Direktnachrichten mit einer Kartennachricht antwortet, enthält das Kontaktformular.
   • Reagiert auf den Slash-Befehl /addContact, indem ein Dialogfeld mit das Kontaktformular aus.
   • Er antwortet auf den Slash-Befehl /about mit einer Textnachricht mit dem Schaltfläche Kontakt hinzufügen, auf die Nutzer klicken können, um ein Dialogfeld mit dem Kontaktformular.

3. Wenn der Nutzer im Kontaktformular erscheint, gibt er seine Kontaktdaten ein. in die folgenden Felder und Widgets ein:

   • Vor- und Nachname: a textInput das Zeichenfolgen akzeptiert.
   • Geburtsdatum: Ein dateTimePicker-Widget, das nur Datumsangaben akzeptiert.
   • Kontakttyp: Ein selectionInput-Widget mit Optionsfeldern, über das Nutzer einen einzelnen Stringwert (Personal oder Work) auswählen und senden können.
   • Schaltfläche Überprüfen und senden: a buttonList Array mit dem Widget button, auf das der Nutzer klickt, um die Werte zu senden, die die sie eingeben.

4. Die Google Chat App verarbeitet ein CARD_CLICKED-Interaktionsereignis, um die von Nutzern eingegebenen Werte zu verarbeiten, und zeigt die Werte auf einer Bestätigungskarte an.

5. Der Nutzer sieht sich die Bestätigungskarte an und klickt auf die Schaltfläche Senden, um die Kontaktdaten abzuschließen.

6. Die Google Chat App sendet eine private SMS, bestätigt die Einreichung.

Umgebung vorbereiten

In diesem Abschnitt wird beschrieben, wie Sie ein Google Cloud-Projekt für die Chat-App erstellen und konfigurieren.

Google Cloud-Projekt erstellen

Google Cloud Console

1. Öffnen Sie in der Google Cloud Console das Menü menu. > IAM und Verwaltung > Projekt erstellen.

   Zur Seite „Projekt erstellen“

2. Geben Sie im Feld Projektname einen aussagekräftigen Namen für Ihr Projekt ein.

   Optional: Klicken Sie auf Bearbeiten, um die Projekt-ID zu bearbeiten. Die Projekt-ID kann nach dem Erstellen des Projekts nicht mehr geändert werden. Wählen Sie also eine ID aus, die während der gesamten Dauer des Projekts den Anforderungen entspricht.

3. Klicken Sie im Feld Standort auf Durchsuchen, um die potenziellen Standorte für Ihr Projekt arbeiten. Klicken Sie danach auf Auswählen.
4. Klicken Sie auf Erstellen. In der Google Cloud Console wird die Dashboard-Seite aufgerufen und Ihr Projekt wurde erstellt. innerhalb weniger Minuten.

gcloud-CLI

Greifen Sie in einer der folgenden Entwicklungsumgebungen auf die Google Cloud Befehlszeile (gcloud):

• Cloud Shell: Onlineterminal mit der gcloud CLI verwenden aktivieren Sie Cloud Shell.
  Cloud Shell aktivieren
• Lokale Shell: Zur Verwendung einer lokalen Entwicklungsumgebung müssen Sie die gcloud CLI installieren und initialisieren.
  Verwenden Sie den Befehl gcloud projects create, um ein Cloud-Projekt zu erstellen:

  gcloud projects create PROJECT_ID

  Ersetzen Sie PROJECT_ID durch die ID des Projekts, das Sie erstellen möchten.

Authentifizierung und Autorisierung einrichten

Für Google Chat-Apps müssen Sie ein OAuth-Zustimmungsbildschirm eingeben, damit Nutzer können Ihre App in Google Workspace-Anwendungen autorisieren, darunter: Google Chat

In dieser Anleitung stellen Sie eine Chat-App bereit, die nur für und zur internen Verwendung. Daher ist es in Ordnung, Platzhalterinformationen für die Zustimmungsbildschirm. Ersetzen Sie vor dem Veröffentlichen der Chat App Platzhalterinformationen mit echten Informationen.

1. Gehen Sie in der Google Cloud Console zu Menü menu > APIs und Dienste > OAuth-Zustimmungsbildschirm.

   Zum OAuth-Zustimmungsbildschirm

2. Wählen Sie unter Nutzertyp die Option Intern aus und klicken Sie auf Erstellen.

3. Geben Sie unter App-Name Contact Manager ein.

4. Wählen Sie unter Nutzer-Support-E-Mail Ihre E-Mail-Adresse oder eine geeignete Google-Gruppe.

5. Geben Sie unter Kontaktdaten des Entwicklers Ihre E-Mail-Adresse ein.

6. Klicken Sie auf Speichern und fortfahren.

7. Klicken Sie auf der Seite Bereiche auf Speichern und fortfahren. Für die Chat-App sind keine OAuth-Bereiche erforderlich.

8. Überprüfen Sie die Zusammenfassung und klicken Sie dann auf Zurück zum Dashboard.

Chat-App erstellen und bereitstellen

Im folgenden Abschnitt kopieren und aktualisieren Sie Apps Script-Projekt, das alle erforderlichen Anwendungen enthält Code für Ihre Chat-App ändern. Sie müssen den Code also nicht fügen Sie jede Datei ein.

Optional können Sie das gesamte Projekt auf GitHub ansehen.

Auf GitHub ansehen

Hier eine Übersicht über die einzelnen Dateien:

main.gs

Hier werden alle App-Logiken verarbeitet, einschließlich Interaktionsereignisse, wenn Nutzer Nachrichten an die Chat-App senden, in einer Chat-App-Nachricht auf Schaltflächen klicken oder Dialogfelder öffnen und schließen.

main.gs-Code ansehen

apps-script/contact-form-app/main.gs

Auf GitHub ansehen

/**
 * Copyright 2024 Google Inc.
 *
 * 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
 *
 * http://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.
 */

/**
 * Responds to a MESSAGE interaction event in Google Chat.
 *
 * @param {Object} event the MESSAGE interaction event from Chat API.
 * @return {Object} message response that opens a dialog or sends private
 *                          message with text and card.
 */
function onMessage(event) {
  if (event.message.slashCommand) {
    switch (event.message.slashCommand.commandId) {
      case 1:
        // If the slash command is "/about", responds with a text message and button
        // that opens a dialog.
        return {
          text: "Manage your personal and business contacts 📇. To add a " +
                  "contact, use the slash command `/addContact`.",
          accessoryWidgets: [{ buttonList: { buttons: [{
            text: "Add Contact",
            onClick: { action: {
              function: "openDialog",
              interaction: "OPEN_DIALOG"
            }}
          }]}}]
        }
      case 2:
        // If the slash command is "/addContact", opens a dialog.
        return openDialog(event);
    }
  }

  // If user sends the Chat app a message without a slash command, the app responds
  // privately with a text and card to add a contact.
  return {
    privateMessageViewer: event.user,
    text: "To add a contact, try `/addContact` or complete the form below:",
    cardsV2: [{
      cardId: "addContactForm",
      card: {
        header: { title: "Add a contact" },
        sections:[{ widgets: CONTACT_FORM_WIDGETS.concat([{
          buttonList: { buttons: [{
            text: "Review and submit",
            onClick: { action: { function : "openNextCard" }}
          }]}
        }])}]
      }
    }]
  };
}

/**
 * Responds to CARD_CLICKED interaction events in Google Chat.
 *
 * @param {Object} event the CARD_CLICKED interaction event from Google Chat.
 * @return {Object} message responses specific to the dialog handling.
 */
function onCardClick(event) {
  // Initial dialog form page
  if (event.common.invokedFunction === "openDialog") {
    return openDialog(event);
  // Second dialog form page
  } else if (event.common.invokedFunction === "openNextCard") {
    return openNextCard(
      event.user,
      fetchFormValue(event, "contactName"),
      fetchFormValue(event, "contactBirthdate"),
      fetchFormValue(event, "contactType"),
      event.isDialogEvent
    );
  // Dialog form submission
  } else if (event.common.invokedFunction === "submitForm") {
    const userInputs = event.common.parameters;
    return submitForm(event.user, userInputs, event.dialogEventType);
  }
}

/**
 * Extracts form input value for a given widget.
 *
 * @param {Object} event the CARD_CLICKED interaction event from Google Chat.
 * @param {String} widgetName a unique ID for the widget, specified in the widget's name field.
 * @returns the value inputted by the user, null if no value can be found.
 */
function fetchFormValue(event, widgetName) {
  const formItem = event.common.formInputs[widgetName][""];
  // For widgets that receive StringInputs data, the value input by the user.
  if (formItem.hasOwnProperty("stringInputs")) {
    const stringInput = event.common.formInputs[widgetName][""].stringInputs.value[0];
    if (stringInput != null) {
      return stringInput;
    }
  // For widgets that receive dateInput data, the value input by the user.
  } else if (formItem.hasOwnProperty("dateInput")) {
    const dateInput = event.common.formInputs[widgetName][""].dateInput.msSinceEpoch;
     if (dateInput != null) {
       return dateInput;
     }
  }

  return null;
}

/**
 * Opens a dialog that prompts users to add details about a contact.
 *
 * @return {Object} a message with an action response to open a dialog.
 */
function openDialog() {
  return { actionResponse: {
    type: "DIALOG",
    dialogAction: { dialog: { body: { sections: [{
      header: "Add new contact",
      widgets: CONTACT_FORM_WIDGETS.concat([{
        buttonList: { buttons: [{
          text: "Review and submit",
          onClick: { action: { function: "openNextCard" }}
        }]}
      }])
    }]}}}
  }};
}

/**
 * Returns a dialog or card message that displays a confirmation of contact
 * details before users submit.
 *
 * @param {String} user the user who submitted the information.
 * @param {String} contactName the contact name from the previous dialog or card.
 * @param {String} contactBirthdate the birthdate from the previous dialog or card.
 * @param {String} contactType the contact type from the previous dialog or card.
 * @param {boolean} fromDialog whether the information was submitted from a dialog.
 *
 * @return {Object} returns a dialog or private card message.
 */
function openNextCard(user, contactName, contactBirthdate, contactType, fromDialog) {
  const name = contactName ?? "<i>Not provided</i>";
  const birthdate = contactBirthdate ?? "<i>Not provided</i>";
  const type = contactType ?? "<i>Not provided</i>";
  const cardConfirmation = {
    header: "Your contact",
    widgets: [{
      textParagraph: { text: "Confirm contact information and submit:" }}, {
      textParagraph: { text: "<b>Name:</b> " + name }}, {
      textParagraph: {
        text: "<b>Birthday:</b> " + convertMillisToDateString(birthdate)
      }}, {
      textParagraph: { text: "<b>Type:</b> " + type }}, {
      buttonList: { buttons: [{
        text: "Submit",
        onClick: { action: {
          function: "submitForm",
          parameters: [{
            key: "contactName", value: name }, {
            key: "contactBirthdate", value: birthdate }, {
            key: "contactType", value: type
          }]
        }}
      }]}
    }]
  };

  // Returns a dialog with contact information that the user input.
  if (fromDialog) {
    return { action_response: {
      type: "DIALOG",
      dialogAction: { dialog: { body: { sections: [ cardConfirmation ]}}}
    }};
  }

  // Updates existing card message with contact information that the user input.
  return {
    actionResponse: { type: "UPDATE_MESSAGE" },
    privateMessageViewer: user,
    cardsV2: [{
      card: { sections: [cardConfirmation]}
    }]
  }
}

/**
  * Submits information from a dialog or card message.
  *
  * @param {Object} user the person who submitted the information.
  * @param {Object} userInputs the form input values from event parameters.
  * @param {boolean} dialogEventType "SUBMIT_DIALOG" if from a dialog.
  * @return {Object} a message response that opens a dialog or posts a private
  *                  message.
  */
function submitForm(user, userInputs, dialogEventType) {
  const contactName = userInputs["contactName"];
  // Checks to make sure the user entered a contact name.
  // If no name value detected, returns an error message.
  if (!contactName) {
    const errorMessage = "Don't forget to name your new contact!";
    if (dialogEventType === "SUBMIT_DIALOG") {
      return { actionResponse: {
        type: "DIALOG",
        dialogAction: { actionStatus: {
          statusCode: "INVALID_ARGUMENT",
          userFacingMessage: errorMessage
        }}
      }};
    } else {
      return {
        privateMessageViewer: user,
        text: errorMessage
      };
    }
  }

  // The Chat app indicates that it received form data from the dialog or card.
  // Sends private text message that confirms submission.
  const confirmationMessage = "✅ " + contactName + " has been added to your contacts.";
  if (dialogEventType === "SUBMIT_DIALOG") {
    return {
      actionResponse: {
        type: "NEW_MESSAGE",
        dialogAction: { actionStatus: {
          statusCode: "OK",
          userFacingMessage: "Success " + JSON.stringify(contactName)
        }}
      },
      privateMessageViewer: user,
      text: confirmationMessage
    }
  } else {
    return {
      actionResponse: { type: "NEW_MESSAGE" },
      privateMessageViewer: user,
      text: confirmationMessage
    };
  }
}

/**
 * Converts date in milliseconds since epoch to user-friendly string.
 *
 * @param {Object} millis the milliseconds since epoch time.
 * @return {string} Display-friend date (English US).
 */
function convertMillisToDateString(millis) {
  const date = new Date(millis);
  const options = { year: 'numeric', month: 'long', day: 'numeric' };
  return date.toLocaleDateString('en-US', options);
}

contactForm.gs

Enthält die Widgets, die Formulardaten von Nutzern empfangen. Diese Formulareingaben Widgets werden auf Karten in Nachrichten und Dialogfeldern angezeigt.

contactForm.gs-Code ansehen

apps-script/contact-form-app/contactForm.gs

Auf GitHub ansehen

/**
 * Copyright 2024 Google Inc.
 *
 * 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
 *
 * http://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.
 */

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

appsscript.json

Die Apps Script-Manifest zum Definieren und Konfigurieren des Apps Script-Projekts für die Chat-App.

appsscript.json-Code ansehen

apps-script/contact-form-app/appsscript.json

Auf GitHub ansehen

{
  "timeZone": "America/Los_Angeles",
  "dependencies": {},
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "chat": {}
}

Nummer und ID Ihres Cloud-Projekts ermitteln

1. Rufen Sie in der Google Cloud Console Ihr Cloud-Projekt auf.

   Zur Google Cloud Console

2. Klicken Sie auf „Einstellungen und Dienstprogramme“ more_vert > Projekteinstellungen.

3. Notieren Sie sich die Werte in den Feldern Projektnummer und Projekt-ID. Sie verwenden sie in den folgenden Abschnitten.

Apps Script-Projekt erstellen

Um ein Apps Script-Projekt zu erstellen und mit Ihrem Cloud-Projekt:

1. Klicken Sie auf die folgende Schaltfläche, um das Apps Script-Projekt Kontakte in Google Chat verwalten zu öffnen.
   Projekt öffnen
2. Klicken Sie auf info_outline Übersicht.
3. Klicken Sie auf der Übersichtsseite auf Kopie erstellen.

4. Benennen Sie Ihre Kopie des Apps Script-Projekts:

   1. Klicken Sie auf Kopie von „Kontakte in Google Chat verwalten“.

   2. Geben Sie unter Projekttitel Contact Manager - Google Chat app ein.

   3. Klicken Sie auf Umbenennen.

Cloud-Projekt des Apps Script-Projekts festlegen

1. In Ihrem Apps Script-Projekt Klicken Sie auf Projekteinstellungen.
2. Klicken Sie unter Google Cloud Platform-Projekt (GCP-Projekt) auf Projekt ändern.
3. Fügen Sie unter GCP-Projektnummer die Projektnummer Ihres Cloud-Projekts ein.
4. Klicken Sie auf Projekt festlegen. Cloud-Projekt und Apps Script sind jetzt verbunden.

Apps Script-Bereitstellung erstellen

Jetzt, wo der gesamte Code vorhanden ist, können Sie das Apps Script bereitstellen. Projekt arbeiten. Mit der Bereitstellungs-ID konfigurieren Sie die Chat-App in Google Cloud

1. Öffnen Sie in Apps Script die Projekt arbeiten.

   Zu Apps Script

2. Klicken Sie auf Bereitstellen > Neue Bereitstellung.

3. Wenn Add-on noch nicht ausgewählt ist, klicken Sie neben Typ auswählen auf die Bereitstellungstypen  und wählen Sie Add-on aus.

4. Geben Sie unter Beschreibung eine Beschreibung für die Version ein, z. B. Test of Contact Manager

5. Klicken Sie auf Bereitstellen. Apps Script-Berichte erfolgreich Bereitstellung und stellt eine Bereitstellungs-ID bereit.

6. Klicken Sie zum Kopieren auf content_copy Kopieren. die Bereitstellungs-ID und klicken Sie dann auf Fertig.

Chat-App in der Google Cloud Console konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie die Google Chat API in der Google Cloud Console mit Informationen zu Ihrer Chat-App konfigurieren, einschließlich der ID der Bereitstellung, die Sie gerade über Ihr Apps Script-Projekt erstellt haben.

1. Klicken Sie in der Google Cloud Console auf das Dreistrich-Menü. menu > Weitere Produkte > Google Workspace > Produktbibliothek > Google Chat API > Verwalten > Konfiguration.

   Zur Chat API-Konfiguration

2. Geben Sie unter App-Name Contact Manager ein.

3. Geben Sie unter Avatar-URL https://developers.google.com/chat/images/contact-icon.png ein.

4. Geben Sie unter Beschreibung den Wert Manage your personal and business contacts ein.

5. Stellen Sie die Ein/Aus-Schaltfläche Interaktive Funktionen aktivieren auf „Ein“.

6. Aktivieren Sie unter Funktionsweise die Kästchen 1:1-Nachrichten empfangen und Gruppenbereichen und Gruppenunterhaltungen beitreten.

7. Wählen Sie unter Verbindungseinstellungen die Option Apps Script aus.

8. Fügen Sie unter Deployment ID (Bereitstellungs-ID) die Deployment-ID für Apps Script ein. die Sie im vorherigen Abschnitt kopiert haben, als Sie den Apps Script-Bereitstellung

9. Richten Sie unter Slash-Befehle die Slash-Befehle /about und /addContact:

   1. Klicken Sie auf Slash-Befehl hinzufügen, um den ersten Slash-Befehl einzurichten.
   2. Geben Sie unter Name den Wert /about ein.
   3. Geben Sie unter Befehls-ID 1 ein.
   4. Geben Sie unter Beschreibung den Wert Learn how to use this Chat app to manage your contacts ein.
   5. Wählen Sie Öffnet ein Dialogfeld aus.
   6. Klicken Sie auf Fertig.
   7. Klicken Sie auf Slash-Befehl hinzufügen, um einen weiteren Slash-Befehl einzurichten.
   8. Geben Sie unter Name /addContact ein.
   9. Geben Sie unter Befehls-ID 2 ein.
   10. Geben Sie unter Beschreibung Submit information about a contact
   11. Wählen Sie Öffnet ein Dialogfeld aus.
   12. Klicken Sie auf Fertig.

10. Wähle unter Sichtbarkeit die Option Diese Chat-App bestimmten Personen und Gruppen in YOUR DOMAIN zur Verfügung stellen und geben Sie Ihre E-Mail-Adresse ein.

11. Wählen Sie unter Protokolle die Option Fehler in Logging protokollieren aus.

12. Klicken Sie auf Speichern. Eine Meldung, dass die Konfiguration gespeichert wurde, wird angezeigt.

Die Chat App kann jetzt in Google Chat installiert und getestet werden.

Chat App testen

Wenn Sie die Chat App testen möchten, öffnen Sie einen Direktnachrichtenbereich mit der Chat App und senden Sie eine Nachricht:

1. Öffnen Sie Google Chat mit dem Google Workspace-Konto, das Sie angegeben haben, als Sie sich als vertrauenswürdiger Tester hinzugefügt haben.

   Zu Google Chat

2. Klicken Sie auf add Neuer Chat.
3. Geben Sie im Feld Eine oder mehrere Personen hinzufügen den Namen Ihres Chat-App.

4. Wählen Sie in den Ergebnissen die Chat-App aus. Eine Direktnachricht wird geöffnet.

1. Geben Sie in der neuen Direktnachricht in der Chat App /addContact ein und drücken Sie die Eingabetaste.

2. Geben Sie im daraufhin angezeigten Dialogfeld die Kontaktdaten ein:

   1. Geben Sie im Textfeld Vor- und Nachname einen Namen ein.
   2. Wählen Sie in der Datumsauswahl unter Geburtsdatum ein Datum aus.
   3. Wählen Sie unter Kontakttyp das Optionsfeld Geschäftlich oder Privat aus.

3. Klicken Sie auf Überprüfen und senden.

4. Prüfen Sie im Bestätigungsdialogfeld die von Ihnen eingereichten Informationen und Klicken Sie auf Senden. Die Chat-App antwortet mit der Textnachricht ✅ CONTACT NAME has been added to your contacts..

5. Optional können Sie das Kontaktformular auch auf der folgenden Seite testen und an uns senden: Möglichkeiten:

   • Verwenden Sie den Slash-Befehl /about. Die Chat-App antwortet mit einer Textnachricht und einer Schaltfläche für das Zubehör-Widget mit der Aufschrift Add a contact. Wenn Sie auf die Schaltfläche klicken, wird ein Dialogfeld mit der Kontaktformular.
   • Senden Sie der Chat App eine Direktnachricht ohne Slash-Befehl wie Hello. Chat App mit einem Text und einer Karte, die das Kontaktformular enthalten.

Bereinigen

Um zu vermeiden, dass Ihrem Google Cloud-Konto Gebühren für Ressourcen, die in dieser Anleitung verwendet werden, empfehlen wir, dass Sie den Cloud-Projekt

1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten. Klicken Sie auf das Dreistrich-Menü menu > IAM & Verwaltung > Ressourcen verwalten.

   Ressourcenmanager aufrufen

2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen delete.
3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie zum Löschen auf Beenden. für das Projekt.

Weitere Informationen

• Auf Slash-Befehle reagieren
• Informationen von Google Chat-Nutzern erheben und verarbeiten
• Interaktive Dialogfelder öffnen
• Weitere Beispiele für die Google Chat App