Nachricht über die Google Chat API senden

In diesem Leitfaden wird erläutert, wie Sie die messages.create() um eine der folgenden Aktionen auszuführen:

  • Senden Sie Nachrichten, die Text, Karten und interaktive Widgets enthalten.
  • Nachrichten privat an einen bestimmten Chat-Nutzer senden.
  • Sie können eine Unterhaltung starten oder darauf antworten.
  • Benennen Sie eine Nachricht, damit Sie sie in einer anderen Chat API angeben können -Anfragen.

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

Die maximale Nachrichtengröße (inklusive Text oder Karten) beträgt 32.000 Byte. Wenn Sie eine Nachricht senden möchten, die diese Größe überschreitet, muss stattdessen mehrere Nachrichten senden.

Neben der Methode messages.create() können Chat-Apps Nachrichten erstellen und senden, um auf Interaktionen von Nutzern zu antworten, z. B. Willkommensnachricht, nachdem ein Nutzer die Chat-App einer Leerzeichen. Beim Reagieren auf Interaktionen können Chat-Apps andere Arten von Messaging-Funktionen wie interaktive Dialogfelder und Linkvorschau Schnittstellen. Um einem Nutzer zu antworten, gibt die Chat App die Nachricht synchron, ohne die Chat API aufzurufen. Weitere Informationen wie Sie Nachrichten senden, um auf Interaktionen zu reagieren, Interaktionen mit der Google Chat App empfangen und beantworten

So werden in Google Chat mit der Chat API erstellte Nachrichten angezeigt und zugeordnet

Sie können die Methode messages.create() mit App-Authentifizierung und Nutzerauthentifizierung. In Google Chat wird der Absender der Nachricht unterschiedlich zugeordnet je nach verwendetem Authentifizierungstyp.

Wenn Sie sich als Chat-App authentifizieren, die Chat-App die Nachricht sendet.

<ph type="x-smartling-placeholder">
</ph> Durch Aufrufen der Methode messages.create() mit Anwendungsauthentifizierung
Abbildung 1: Bei der App-Authentifizierung sendet die Chat-App in der Nachricht. Hinweis: Der Absender ist keine Person. In Google Chat wird neben dem Namen das Symbol App angezeigt.

Wenn Sie sich als Nutzer authentifizieren, sendet die Chat-App die im Namen des Nutzers senden. In Chat wird auch die Chat-App an die Nachricht, indem der Name angezeigt wird.

<ph type="x-smartling-placeholder">
</ph> Durch Aufrufen der Methode messages.create() mit Nutzerauthentifizierung
Abbildung 2: Mit der Nutzerauthentifizierung sendet der Nutzer die Nachricht und Google Chat zeigt die Name der Chat-App neben dem Namen des Nutzers

Der Authentifizierungstyp bestimmt auch, welche Messaging-Funktionen und -Oberflächen die Sie in die Nachricht aufnehmen können. Bei der App-Authentifizierung Chat-Apps können Nachrichten senden, die RTF, kartenbasierten Oberflächen und interaktiven Widgets. Da Google Chat-Nutzer nur Text in ihren Nachrichten senden können, haben Sie folgende Möglichkeiten: nur Text enthalten, wenn Nachrichten mithilfe der Nutzerauthentifizierung erstellt werden. Weitere Informationen zur Nachrichtenfunktion die für die Chat API zur Verfügung stehen, finden Sie in der Nachrichten in Google Chat

In diesem Leitfaden wird erläutert, wie du beide Authentifizierungstypen zum Senden einer Nachricht verwendest mit der Chat-API.

Vorbereitung

Node.js

Python

Java

Apps Script

Nachricht als Chat-App senden

In diesem Abschnitt wird erläutert, wie Sie Nachrichten senden, die Text, Karten und interaktive Zubehör-Widgets App-Authentifizierung.

Nachricht mit App-Authentifizierung gesendet
Abbildung 4: Eine Chat-App sendet eine Nachricht mit Text, eine Karte und eine Zubehörschaltfläche.

Zum Aufrufen von messages.create() mithilfe der App-Authentifizierung müssen Sie die Methode folgende Felder in der Anfrage:

  • Der Autorisierungsbereich chat.bot.
  • Die Ressource Space, in der die Sie posten möchten. Die Chat-App muss Mitglied des Gruppenbereichs.
  • Die Message zu erstellende Ressource. Um den Inhalt der Nachricht zu definieren, können Sie RTF (text), eine oder mehrere Kartenschnittstellen (cardsV2), oder beides.

Optional können Sie Folgendes angeben:

Der folgende Code zeigt ein Beispiel für eine Chat-App kann eine in der Chat-App gepostete Nachricht senden, die Folgendes enthält: Text, eine Karte und eine anklickbare Schaltfläche unten in der Nachricht:

Node.js

chat/client-libraries/cloud/create-message-app-cred.js
import {createClientWithAppCredentials} from './authentication-utils.js';

// This sample shows how to create message with app credential
async function main() {
  // Create a client
  const chatClient = createClientWithAppCredentials();

  // Initialize request argument(s)
  const request = {
    // Replace SPACE_NAME here.
    parent: 'spaces/SPACE_NAME',
    message: {
      text: '👋🌎 Hello world! I created this message by calling ' +
            'the Chat API\'s `messages.create()` method.',
      cardsV2 : [{ card: {
        header: {
          title: 'About this message',
          imageUrl: 'https://fonts.gstatic.com/s/i/short-term/release/googlesymbols/info/default/24px.svg'
        },
        sections: [{
          header: 'Contents',
          widgets: [{ textParagraph: {
              text: '🔡 <b>Text</b> which can include ' +
                    'hyperlinks 🔗, emojis 😄🎉, and @mentions 🗣️.'
            }}, { textParagraph: {
              text: '🖼️ A <b>card</b> to display visual elements' +
                    'and request information such as text 🔤, ' +
                    'dates and times 📅, and selections ☑️.'
            }}, { textParagraph: {
              text: '👉🔘 An <b>accessory widget</b> which adds ' +
                    'a button to the bottom of a message.'
            }}
          ]}, {
            header: "What's next",
            collapsible: true,
            widgets: [{ textParagraph: {
                text: "❤️ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages.reactions/create'>Add a reaction</a>."
              }}, { textParagraph: {
                text: "🔄 <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/patch'>Update</a> " +
                      "or ❌ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/delete'>delete</a> " +
                      "the message."
              }
            }]
          }
        ]
      }}],
      accessoryWidgets: [{ buttonList: { buttons: [{
        text: 'View documentation',
        icon: { materialIcon: { name: 'link' }},
        onClick: { openLink: {
          url: 'https://developers.google.com/workspace/chat/create-messages'
        }}
      }]}}]
    }
  };

  // Make the request
  const response = await chatClient.createMessage(request);

  // Handle the response
  console.log(response);
}

main().catch(console.error);

Python

chat/client-libraries/cloud/create_message_app_cred.py
from authentication_utils import create_client_with_app_credentials
from google.apps import chat_v1 as google_chat

# This sample shows how to create message with app credential
def create_message_with_app_cred():
    # Create a client
    client = create_client_with_app_credentials()

    # Initialize request argument(s)
    request = google_chat.CreateMessageRequest(
        # Replace SPACE_NAME here.
        parent = "spaces/SPACE_NAME",
        message = {
            "text": '👋🌎 Hello world! I created this message by calling ' +
                    'the Chat API\'s `messages.create()` method.',
            "cards_v2" : [{ "card": {
                "header": {
                    "title": 'About this message',
                    "image_url": 'https://fonts.gstatic.com/s/i/short-term/release/googlesymbols/info/default/24px.svg'
                },
                "sections": [{
                    "header": "Contents",
                    "widgets": [{ "text_paragraph": {
                            "text": '🔡 <b>Text</b> which can include ' +
                                    'hyperlinks 🔗, emojis 😄🎉, and @mentions 🗣️.'
                        }}, { "text_paragraph": {
                            "text": '🖼️ A <b>card</b> to display visual elements' +
                                    'and request information such as text 🔤, ' +
                                    'dates and times 📅, and selections ☑️.'
                        }}, { "text_paragraph": {
                            "text": '👉🔘 An <b>accessory widget</b> which adds ' +
                                    'a button to the bottom of a message.'
                        }}
                    ]}, {
                        "header": "What's next",
                        "collapsible": True,
                        "widgets": [{ "text_paragraph": {
                                "text": "❤️ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages.reactions/create'>Add a reaction</a>."
                            }}, { "text_paragraph": {
                                "text": "🔄 <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/patch'>Update</a> " +
                                        "or ❌ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/delete'>delete</a> " +
                                        "the message."
                            }
                        }]
                    }
                ]
            }}],
            "accessory_widgets": [{ "button_list": { "buttons": [{
                "text": 'View documentation',
                "icon": { "material_icon": { "name": 'link' }},
                "on_click": { "open_link": {
                    "url": 'https://developers.google.com/workspace/chat/create-messages'
                }}
            }]}}]
        }
    )

    # Make the request
    response = client.create_message(request)

    # Handle the response
    print(response)

create_message_with_app_cred()

Java

chat/client-libraries/cloud/src/main/java/com/google/workspace/api/chat/samples/CreateMessageAppCred.java
import com.google.apps.card.v1.Button;
import com.google.apps.card.v1.ButtonList;
import com.google.apps.card.v1.Card;
import com.google.apps.card.v1.Icon;
import com.google.apps.card.v1.MaterialIcon;
import com.google.apps.card.v1.OnClick;
import com.google.apps.card.v1.OpenLink;
import com.google.apps.card.v1.TextParagraph;
import com.google.apps.card.v1.Widget;
import com.google.apps.card.v1.Card.CardHeader;
import com.google.apps.card.v1.Card.Section;
import com.google.chat.v1.AccessoryWidget;
import com.google.chat.v1.CardWithId;
import com.google.chat.v1.ChatServiceClient;
import com.google.chat.v1.CreateMessageRequest;
import com.google.chat.v1.Message;

// This sample shows how to create message with app credential.
public class CreateMessageAppCred {

  public static void main(String[] args) throws Exception {
    try (ChatServiceClient chatServiceClient =
        AuthenticationUtils.createClientWithAppCredentials()) {
      CreateMessageRequest.Builder request = CreateMessageRequest.newBuilder()
        // Replace SPACE_NAME here.
        .setParent("spaces/SPACE_NAME")
        .setMessage(Message.newBuilder()
          .setText( "👋🌎 Hello world! I created this message by calling " +
                    "the Chat API\'s `messages.create()` method.")
          .addCardsV2(CardWithId.newBuilder().setCard(Card.newBuilder()
            .setHeader(CardHeader.newBuilder()
              .setTitle("About this message")
              .setImageUrl("https://fonts.gstatic.com/s/i/short-term/release/googlesymbols/info/default/24px.svg"))
            .addSections(Section.newBuilder()
              .setHeader("Contents")
              .addWidgets(Widget.newBuilder().setTextParagraph(TextParagraph.newBuilder().setText(
                "🔡 <b>Text</b> which can include " +
                "hyperlinks 🔗, emojis 😄🎉, and @mentions 🗣️.")))
              .addWidgets(Widget.newBuilder().setTextParagraph(TextParagraph.newBuilder().setText(
                "🖼️ A <b>card</b> to display visual elements " +
                "and request information such as text 🔤, " +
                "dates and times 📅, and selections ☑️.")))
              .addWidgets(Widget.newBuilder().setTextParagraph(TextParagraph.newBuilder().setText(
                "👉🔘 An <b>accessory widget</b> which adds " +
                "a button to the bottom of a message."))))
            .addSections(Section.newBuilder()
              .setHeader("What's next")
              .setCollapsible(true)
              .addWidgets(Widget.newBuilder().setTextParagraph(TextParagraph.newBuilder().setText(
                "❤️ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages.reactions/create'>Add a reaction</a>.")))
              .addWidgets(Widget.newBuilder().setTextParagraph(TextParagraph.newBuilder().setText(
                "🔄 <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/patch'>Update</a> " +
                "or ❌ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/delete'>delete</a> " +
                "the message."))))))
          .addAccessoryWidgets(AccessoryWidget.newBuilder()
            .setButtonList(ButtonList.newBuilder()
              .addButtons(Button.newBuilder()
                .setText("View documentation")
                .setIcon(Icon.newBuilder()
                  .setMaterialIcon(MaterialIcon.newBuilder().setName("link")))
                .setOnClick(OnClick.newBuilder()
                  .setOpenLink(OpenLink.newBuilder()
                    .setUrl("https://developers.google.com/workspace/chat/create-messages")))))));
      Message response = chatServiceClient.createMessage(request.build());

      System.out.println(JsonFormat.printer().print(response));
    }
  }
}

Apps Script

Chat/erweiterter-Service/Main.gs
/**
 * This sample shows how to create message with app credential
 * 
 * It relies on the OAuth2 scope 'https://www.googleapis.com/auth/chat.bot'
 * used by service accounts.
 */
function createMessageAppCred() {
  // Initialize request argument(s)
  // TODO(developer): Replace SPACE_NAME here.
  const parent = 'spaces/SPACE_NAME';
  const message = {
    text: '👋🌎 Hello world! I created this message by calling ' +
          'the Chat API\'s `messages.create()` method.',
    cardsV2 : [{ card: {
      header: {
        title: 'About this message',
        imageUrl: 'https://fonts.gstatic.com/s/i/short-term/release/googlesymbols/info/default/24px.svg'
      },
      sections: [{
        header: 'Contents',
        widgets: [{ textParagraph: {
            text: '🔡 <b>Text</b> which can include ' +
                  'hyperlinks 🔗, emojis 😄🎉, and @mentions 🗣️.'
          }}, { textParagraph: {
            text: '🖼️ A <b>card</b> to display visual elements' +
                  'and request information such as text 🔤, ' +
                  'dates and times 📅, and selections ☑️.'
          }}, { textParagraph: {
            text: '👉🔘 An <b>accessory widget</b> which adds ' +
                  'a button to the bottom of a message.'
          }}
        ]}, {
          header: "What's next",
          collapsible: true,
          widgets: [{ textParagraph: {
              text: "❤️ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages.reactions/create'>Add a reaction</a>."
            }}, { textParagraph: {
              text: "🔄 <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/patch'>Update</a> " +
                    "or ❌ <a href='https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/delete'>delete</a> " +
                    "the message."
            }
          }]
        }
      ]
    }}],
    accessoryWidgets: [{ buttonList: { buttons: [{
      text: 'View documentation',
      icon: { materialIcon: { name: 'link' }},
      onClick: { openLink: {
        url: 'https://developers.google.com/workspace/chat/create-messages'
      }}
    }]}}]
  };
  const parameters = {};

  // Make the request
  const response = Chat.Spaces.Messages.create(
    message, parent, parameters, getHeaderWithAppCredentials()
  );

  // Handle the response
  console.log(response);
}

Ersetzen Sie zum Ausführen dieses Beispiels SPACE_NAME durch die ID von des Gruppenbereichs name. Sie erhalten die ID durch Aufrufen der spaces.list()-Methode oder aus der URL des Gruppenbereichs.

Interaktive Widgets am Ende einer Nachricht hinzufügen

Im ersten Codebeispiel dieses Leitfadens Bei der Chat-App-Nachricht wird im Bereich in der Meldung angezeigt wird – das sogenannte Zubehör-Widget. Zubehör-Widgets werden nach Text oder Karten in einer Nachricht angezeigt. Mit diesen Widgets können Sie die Nutzer auf verschiedene Arten mit Ihrer Botschaft interagieren können, z. B.:

  • Bewerten Sie die Genauigkeit oder Zufriedenheit einer Nachricht.
  • Problem mit der Messages App oder der Chat App melden
  • Öffnen Sie einen Link zu ähnlichen Inhalten, z. B. zur Dokumentation.
  • Ähnliche Nachrichten aus der Chat App schließen oder zurückstellen für einen bestimmten Zeitraum.

Fügen Sie zum Hinzufügen von Zubehör-Widgets den accessoryWidgets[] im Text Ihrer Anfrage und geben Sie ein oder mehrere Widgets an, die Sie enthalten sein sollen.

In der folgenden Abbildung sehen Sie eine Chat-App, eine Textnachricht mit Zubehör-Widgets, damit Nutzer ihre Erfahrung bewerten können mit der Chat-App.

<ph type="x-smartling-placeholder">
</ph> Zubehör-Widget.
Abbildung 5: Eine Chat-App-Nachricht mit Text- und Zubehör-Widgets.

Hier sehen Sie den Text der Anfrage, mit der eine Textnachricht mit zwei Zubehörtasten. Wenn Nutzende auf eine Schaltfläche klicken, wird die entsprechende (z. B. doUpvote) die Interaktion verarbeitet:

{
  text: "Rate your experience with this Chat app.",
  accessoryWidgets: [{ buttonList: { buttons: [{
    icon: { material_icon: {
      name: "thumb_up"
    }},
    color: { red: 0, blue: 255, green: 0 },
    onClick: { action: {
      function: "doUpvote"
    }}
  }, {
    icon: { material_icon: {
      name: "thumb_down"
    }},
    color: { red: 0, blue: 255, green: 0 },
    onClick: { action: {
      function: "doDownvote"
    }}
  }]}}]
}

Nachricht privat senden

Chat-Apps können private Nachrichten senden, damit die Die Nachricht ist nur für einen bestimmten Nutzer im Gruppenbereich sichtbar. Wenn ein die Chat-App eine private Nachricht sendet, zeigt ein Label, das den Nutzer darüber informiert, dass die Nachricht nur für ihn sichtbar ist.

Wenn Sie eine Nachricht privat über die Chat API senden möchten, geben Sie Folgendes an: privateMessageViewer im Text Ihrer Anfrage. Um den Nutzer anzugeben, setzen Sie den Wert auf User-Ressource, die für den Chat-Nutzer steht. Sie können auch die name des User, wie im folgenden Beispiel gezeigt:

{
  text: "Hello private world!",
  privateMessageViewer: {
    name: "users/USER_ID"
  }
}

Ersetzen Sie USER_ID, um dieses Beispiel zu verwenden mit einer eindeutigen ID für den Nutzer, z. B. 12345678987654321 oder hao@cymbalgroup.com Weitere Informationen zum Angeben von Nutzern finden Sie unter Google Chat-Nutzer identifizieren und angeben

Um eine Nachricht privat zu senden, müssen Sie in Ihrer Anfrage Folgendes weglassen:

SMS im Namen eines Nutzers senden

In diesem Abschnitt wird erläutert, wie Sie Nachrichten im Namen eines Nutzers mit Nutzerauthentifizierung Bei der Nutzerauthentifizierung darf der Inhalt der Nachricht nur Text enthalten und darf Nachrichtenfunktionen auslassen, die nur für Chat-Apps wie Kartenoberflächen und interaktive Widgets

Nachricht mit Nutzerauthentifizierung gesendet
Abbildung 3: Eine Chat-App sendet eine SMS an im Namen eines Nutzers.

Um die messages.create() mithilfe der Nutzerauthentifizierung aufzurufen, müssen Sie die folgende Felder in der Anfrage:

  • Einen Autorisierungsbereich die die Nutzerauthentifizierung für diese Methode unterstützt. Im folgenden Beispiel werden den Bereich chat.messages.create.
  • Die Ressource Space, in der die Sie posten möchten. Der authentifizierte Nutzer muss Mitglied des Leerzeichen.
  • Die Message zu erstellende Ressource. Um den Inhalt der Nachricht zu definieren, müssen Sie den Parameter text ein.

Optional können Sie Folgendes angeben:

Der folgende Code zeigt ein Beispiel für eine Chat-App kann im Namen eines authentifizierten Nutzers eine Textnachricht in einem bestimmten Bereich senden:

Node.js

chat/client-libraries/cloud/create-message-user-cred.js
import {createClientWithUserCredentials} from './authentication-utils.js';

const USER_AUTH_OAUTH_SCOPES = ['https://www.googleapis.com/auth/chat.messages.create'];

// This sample shows how to create message with user credential
async function main() {
  // Create a client
  const chatClient = await createClientWithUserCredentials(USER_AUTH_OAUTH_SCOPES);

  // Initialize request argument(s)
  const request = {
    // Replace SPACE_NAME here.
    parent: 'spaces/SPACE_NAME',
    message: {
      text: '👋🌎 Hello world!' +
            'Text messages can contain things like:\n\n' +
            '* Hyperlinks 🔗\n' +
            '* Emojis 😄🎉\n' +
            '* Mentions of other Chat users `@` \n\n' +
            'For details, see the ' +
            '<https://developers.google.com/workspace/chat/format-messages' +
            '|Chat API developer documentation>.'
    }
  };

  // Make the request
  const response = await chatClient.createMessage(request);

  // Handle the response
  console.log(response);
}

main().catch(console.error);

Python

chat/client-libraries/cloud/create_message_user_cred.py
from authentication_utils import create_client_with_user_credentials
from google.apps import chat_v1 as google_chat

SCOPES = ["https://www.googleapis.com/auth/chat.messages.create"]

def create_message_with_user_cred():
    # Create a client
    client = create_client_with_user_credentials(SCOPES)

    # Initialize request argument(s)
    request = google_chat.CreateMessageRequest(
        # Replace SPACE_NAME here.
        parent = "spaces/SPACE_NAME",
        message = {
            "text": '👋🌎 Hello world!' +
                    'Text messages can contain things like:\n\n' +
                    '* Hyperlinks 🔗\n' +
                    '* Emojis 😄🎉\n' +
                    '* Mentions of other Chat users `@` \n\n' +
                    'For details, see the ' +
                    '<https://developers.google.com/workspace/chat/format-messages' +
                    '|Chat API developer documentation>.'
        }
    )

    # Make the request
    response = client.create_message(request)

    # Handle the response
    print(response)

create_message_with_user_cred()

Java

chat/client-libraries/cloud/src/main/java/com/google/workspace/api/chat/samples/CreateMessageUserCred.java
import com.google.chat.v1.ChatServiceClient;
import com.google.chat.v1.CreateMessageRequest;
import com.google.chat.v1.Message;

// This sample shows how to create message with user credential.
public class CreateMessageUserCred {

  private static final String SCOPE =
    "https://www.googleapis.com/auth/chat.messages.create";

  public static void main(String[] args) throws Exception {
    try (ChatServiceClient chatServiceClient =
        AuthenticationUtils.createClientWithUserCredentials(
          ImmutableList.of(SCOPE))) {
      CreateMessageRequest.Builder request = CreateMessageRequest.newBuilder()
        // Replace SPACE_NAME here.
        .setParent("spaces/SPACE_NAME")
        .setMessage(Message.newBuilder()
          .setText( "👋🌎 Hello world!" +
                    "Text messages can contain things like:\n\n" +
                    "* Hyperlinks 🔗\n" +
                    "* Emojis 😄🎉\n" +
                    "* Mentions of other Chat users `@` \n\n" +
                    "For details, see the " +
                    "<https://developers.google.com/workspace/chat/format-messages" +
                    "|Chat API developer documentation>."));
      Message response = chatServiceClient.createMessage(request.build());

      System.out.println(JsonFormat.printer().print(response));
    }
  }
}

Apps Script

Chat/erweiterter-Service/Main.gs
/**
 * This sample shows how to create message with user credential
 * 
 * It relies on the OAuth2 scope 'https://www.googleapis.com/auth/chat.messages.create'
 * referenced in the manifest file (appsscript.json).
 */
function createMessageUserCred() {
  // Initialize request argument(s)
  // TODO(developer): Replace SPACE_NAME here.
  const parent = 'spaces/SPACE_NAME';
  const message = {
    text: '👋🌎 Hello world!' +
          'Text messages can contain things like:\n\n' +
          '* Hyperlinks 🔗\n' +
          '* Emojis 😄🎉\n' +
          '* Mentions of other Chat users `@` \n\n' +
          'For details, see the ' +
          '<https://developers.google.com/workspace/chat/format-messages' +
          '|Chat API developer documentation>.'
  };

  // Make the request
  const response = Chat.Spaces.Messages.create(message, parent);

  // Handle the response
  console.log(response);
}

Ersetzen Sie zum Ausführen dieses Beispiels SPACE_NAME durch die ID von des Gruppenbereichs name ein. Sie erhalten die ID durch Aufrufen der spaces.list()-Methode oder aus der URL des Gruppenbereichs.

Threads starten oder antworten

Für Gruppenbereiche mit Threads: können Sie festlegen, ob mit einer neuen Nachricht ein Thread gestartet oder auf einen vorhandenen Thread.

Standardmäßig wird bei Nachrichten, die Sie mit der Chat API erstellen, ein neuer Diskussions-Thread. Damit Sie die Konversation leichter identifizieren und später darauf antworten können, können Sie ein Thread-Schlüssel in Ihrer Anfrage:

  • Geben Sie im Text Ihrer Anfrage thread.threadKey ein.
  • Abfrageparameter angeben messageReplyOption um festzustellen, was passiert, falls der Schlüssel bereits vorhanden ist.

So erstellen Sie eine Antwort auf eine vorhandene Unterhaltung:

  • Fügen Sie in den Anfragetext das Feld thread ein. Wenn festgelegt, können Sie geben Sie die threadKey die Sie erstellt haben. Andernfalls müssen Sie die Methode name des Threads.
  • Geben Sie den Abfrageparameter messageReplyOption an.

Der folgende Code zeigt ein Beispiel für eine Chat-App kann eine Textnachricht senden, die einen bestimmten Thread startet oder darauf antwortet, der durch Schlüssel eines bestimmten Bereichs im Namen eines authentifizierten Nutzers:

Node.js

chat/client-libraries/cloud/create-message-user-cred-thread-key.js
import {createClientWithUserCredentials} from './authentication-utils.js';
const {MessageReplyOption} = require('@google-apps/chat').protos.google.chat.v1.CreateMessageRequest;

const USER_AUTH_OAUTH_SCOPES = ['https://www.googleapis.com/auth/chat.messages.create'];

// This sample shows how to create message with user credential with thread key
async function main() {
  // Create a client
  const chatClient = await createClientWithUserCredentials(USER_AUTH_OAUTH_SCOPES);

  // Initialize request argument(s)
  const request = {
    // Replace SPACE_NAME here.
    parent: 'spaces/SPACE_NAME',
    // Creates the message as a reply to the thread specified by thread_key
    // If it fails, the message starts a new thread instead
    messageReplyOption: MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD,
    message: {
      text: 'Hello with user credential!',
      thread: {
        // Thread key specifies a thread and is unique to the chat app
        // that sets it
        threadKey: 'THREAD_KEY'
      }
    }
  };

  // Make the request
  const response = await chatClient.createMessage(request);

  // Handle the response
  console.log(response);
}

main().catch(console.error);

Python

chat/client-libraries/cloud/create_message_user_cred_thread_key.py
from authentication_utils import create_client_with_user_credentials
from google.apps import chat_v1 as google_chat

import google.apps.chat_v1.CreateMessageRequest.MessageReplyOption

SCOPES = ["https://www.googleapis.com/auth/chat.messages.create"]

# This sample shows how to create message with user credential with thread key
def create_message_with_user_cred_thread_key():
    # Create a client
    client = create_client_with_user_credentials(SCOPES)

    # Initialize request argument(s)
    request = google_chat.CreateMessageRequest(
        # Replace SPACE_NAME here
        parent = "spaces/SPACE_NAME",
        # Creates the message as a reply to the thread specified by thread_key.
        # If it fails, the message starts a new thread instead.
        message_reply_option = MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD,
        message = {
            "text": "Hello with user credential!",
            "thread": {
                # Thread key specifies a thread and is unique to the chat app
                # that sets it.
                "thread_key": "THREAD_KEY"
            }
        }
    )

    # Make the request
    response = client.create_message(request)

    # Handle the response
    print(response)

create_message_with_user_cred_thread_key()

Java

chat/client-libraries/cloud/src/main/java/com/google/workspace/api/chat/samples/CreateMessageUserCredThreadKey.java
import com.google.chat.v1.ChatServiceClient;
import com.google.chat.v1.CreateMessageRequest;
import com.google.chat.v1.CreateMessageRequest.MessageReplyOption;
import com.google.chat.v1.Message;
import com.google.chat.v1.Thread;

// This sample shows how to create message with a thread key with user
// credential.
public class CreateMessageUserCredThreadKey {

  private static final String SCOPE =
    "https://www.googleapis.com/auth/chat.messages.create";

  public static void main(String[] args) throws Exception {
    try (ChatServiceClient chatServiceClient =
        AuthenticationUtils.createClientWithUserCredentials(
          ImmutableList.of(SCOPE))) {
      CreateMessageRequest.Builder request = CreateMessageRequest.newBuilder()
        // Replace SPACE_NAME here.
        .setParent("spaces/SPACE_NAME")
        // Creates the message as a reply to the thread specified by thread_key.
        // If it fails, the message starts a new thread instead.
        .setMessageReplyOption(
          MessageReplyOption.REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD)
        .setMessage(Message.newBuilder()
          .setText("Hello with user credentials!")
          // Thread key specifies a thread and is unique to the chat app
          // that sets it.
          .setThread(Thread.newBuilder().setThreadKey("THREAD_KEY")));
      Message response = chatServiceClient.createMessage(request.build());

      System.out.println(JsonFormat.printer().print(response));
    }
  }
}

Apps Script

Chat/erweiterter-Service/Main.gs
/**
 * This sample shows how to create message with user credential with thread key
 * 
 * It relies on the OAuth2 scope 'https://www.googleapis.com/auth/chat.messages.create'
 * referenced in the manifest file (appsscript.json).
 */
function createMessageUserCredThreadKey() {
  // Initialize request argument(s)
  // TODO(developer): Replace SPACE_NAME here.
  const parent = 'spaces/SPACE_NAME';
  // Creates the message as a reply to the thread specified by thread_key
  // If it fails, the message starts a new thread instead
  const messageReplyOption = 'REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD';
  const message = {
    text: 'Hello with user credential!',
    thread: {
      // Thread key specifies a thread and is unique to the chat app
      // that sets it
      threadKey: 'THREAD_KEY'
    }
  };

  // Make the request
  const response = Chat.Spaces.Messages.create(message, parent, {
    messageReplyOption: messageReplyOption
  });

  // Handle the response
  console.log(response);
}

Ersetzen Sie Folgendes, um dieses Beispiel auszuführen:

  • THREAD_KEY: ein vorhandener Threadschlüssel im Gruppenbereich oder zum Erstellen eines neuen Threads, einen eindeutigen Namen für den Thread.
  • SPACE_NAME: die ID aus dem name ein. Sie erhalten die ID durch Aufrufen der spaces.list()-Methode oder aus der URL des Gruppenbereichs.

Nachrichten benennen

Sie können eine Nachricht benennen, um eine Nachricht in zukünftigen API-Aufrufen abzurufen oder anzugeben. indem Sie das Feld messageId in Ihrer messages.create()-Anfrage festlegen. Durch einen Namen können Sie die Nachricht angeben, ohne den vom System zugewiesene ID aus dem Ressourcennamen der Nachricht (dargestellt in der name Feld.

Wenn Sie beispielsweise eine Nachricht mit der Methode get() abrufen möchten, verwenden Sie die Methode Ressourcenname, um anzugeben, welche Nachricht abgerufen werden soll. Der Ressourcenname lautet formatiert als spaces/{space}/messages/{message}, wobei {message} für die vom System zugewiesene ID oder den benutzerdefinierten Namen, den Sie beim Erstellen des angezeigt.

Um eine Nachricht zu benennen, geben Sie eine benutzerdefinierte ID in der messageId wenn Sie die Mitteilung erstellen. Das Feld messageId legt den Wert für die clientAssignedMessageId der Ressource Message.

Sie können eine Nachricht nur benennen, wenn Sie sie erstellen. Sie können weder einen Namen eine benutzerdefinierte ID für vorhandene Nachrichten ändern. Die benutzerdefinierte ID muss folgende Anforderungen erfüllen Anforderungen:

  • Beginnt mit client-. client-custom-name ist beispielsweise ein gültiger benutzerdefinierter ID, custom-name jedoch nicht.
  • Enthält bis zu 63 Zeichen und darf nur Kleinbuchstaben, Ziffern und Bindestriche verwenden.
  • Ist innerhalb eines Gruppenbereichs eindeutig. Eine Chat-App kann die dieselbe benutzerdefinierte ID für unterschiedliche Nachrichten verwenden.

Der folgende Code zeigt ein Beispiel für eine Chat-App kann im Namen einer Person eine SMS mit einer ID an einen bestimmten Gruppenbereich senden. authentifizierter Nutzer:

Node.js

chat/client-libraries/cloud/create-message-user-cred-message-id.js
import {createClientWithUserCredentials} from './authentication-utils.js';

const USER_AUTH_OAUTH_SCOPES = ['https://www.googleapis.com/auth/chat.messages.create'];

// This sample shows how to create message with user credential with message id
async function main() {
  // Create a client
  const chatClient = await createClientWithUserCredentials(USER_AUTH_OAUTH_SCOPES);

  // Initialize request argument(s)
  const request = {
    // Replace SPACE_NAME here.
    parent: 'spaces/SPACE_NAME',
    // Message id lets chat apps get, update or delete a message without needing
    // to store the system assigned ID in the message's resource name
    messageId: 'client-MESSAGE-ID',
    message: { text: 'Hello with user credential!' }
  };

  // Make the request
  const response = await chatClient.createMessage(request);

  // Handle the response
  console.log(response);
}

main().catch(console.error);

Python

chat/client-libraries/cloud/create_message_user_cred_message_id.py
from authentication_utils import create_client_with_user_credentials
from google.apps import chat_v1 as google_chat

SCOPES = ["https://www.googleapis.com/auth/chat.messages.create"]

# This sample shows how to create message with user credential with message id
def create_message_with_user_cred_message_id():
    # Create a client
    client = create_client_with_user_credentials(SCOPES)

    # Initialize request argument(s)
    request = google_chat.CreateMessageRequest(
        # Replace SPACE_NAME here
        parent = "spaces/SPACE_NAME",
        # Message id let chat apps get, update or delete a message without needing
        # to store the system assigned ID in the message's resource name.
        message_id = "client-MESSAGE-ID",
        message = {
            "text": "Hello with user credential!"
        }
    )

    # Make the request
    response = client.create_message(request)

    # Handle the response
    print(response)

create_message_with_user_cred_message_id()

Java

chat/client-libraries/cloud/src/main/java/com/google/workspace/api/chat/samples/CreateMessageUserCredMessageId.java
import com.google.chat.v1.ChatServiceClient;
import com.google.chat.v1.CreateMessageRequest;
import com.google.chat.v1.Message;

// This sample shows how to create message with message id specified with user
// credential.
public class CreateMessageUserCredMessageId {

  private static final String SCOPE =
    "https://www.googleapis.com/auth/chat.messages.create";

  public static void main(String[] args) throws Exception {
    try (ChatServiceClient chatServiceClient =
        AuthenticationUtils.createClientWithUserCredentials(
          ImmutableList.of(SCOPE))) {
      CreateMessageRequest.Builder request = CreateMessageRequest.newBuilder()
        // Replace SPACE_NAME here.
        .setParent("spaces/SPACE_NAME")
        .setMessage(Message.newBuilder()
          .setText("Hello with user credentials!"))
        // Message ID lets chat apps get, update or delete a message without
        // needing to store the system assigned ID in the message's resource
        // name.
        .setMessageId("client-MESSAGE-ID");
      Message response = chatServiceClient.createMessage(request.build());

      System.out.println(JsonFormat.printer().print(response));
    }
  }
}

Apps Script

Chat/erweiterter-Service/Main.gs
/**
 * This sample shows how to create message with user credential with message id
 * 
 * It relies on the OAuth2 scope 'https://www.googleapis.com/auth/chat.messages.create'
 * referenced in the manifest file (appsscript.json).
 */
function createMessageUserCredMessageId() {
  // Initialize request argument(s)
  // TODO(developer): Replace SPACE_NAME here.
  const parent = 'spaces/SPACE_NAME';
  // Message id lets chat apps get, update or delete a message without needing
  // to store the system assigned ID in the message's resource name
  const messageId = 'client-MESSAGE-ID';
  const message = { text: 'Hello with user credential!' };

  // Make the request
  const response = Chat.Spaces.Messages.create(message, parent, {
    messageId: messageId
  });

  // Handle the response
  console.log(response);
}

Ersetzen Sie Folgendes, um dieses Beispiel auszuführen:

  • SPACE_NAME: die ID aus dem name ein. Sie erhalten die ID durch Aufrufen der spaces.list()-Methode oder aus der URL des Gruppenbereichs.
  • MESSAGE-ID: ein Name für die Nachricht, die mit dem mit custom-. Muss unter allen anderen Nachrichtennamen, die vom Chat-App im angegebenen Gruppenbereich.

Fehlerbehebung

Wenn eine Google Chat App oder card gibt einen Fehler zurück. Der Parameter In der Chatoberfläche wird die Meldung „Ein Fehler ist aufgetreten“ angezeigt. oder „Ihre Anfrage kann nicht verarbeitet werden.“ Manchmal kann die Chat-UI Es wird zwar keine Fehlermeldung angezeigt, aber die Chat-App oder die Karte zu einem unerwarteten Ergebnis führt. z. B. wird eine Kartennachricht angezeigt werden.

Auch wenn in der Chat-Benutzeroberfläche möglicherweise keine Fehlermeldung angezeigt wird, beschreibende Fehlermeldungen und Protokolldaten stehen zur Fehlerbehebung zur Verfügung. wenn die Fehlerprotokollierung für Chat-Apps aktiviert ist. Hilfe bei der Anzeige: Debugging und Beheben von Fehlern finden Sie unter Google Chat-Fehler beheben