Als Google Chat-Nutzer authentifizieren und autorisieren

In diesem Leitfaden wird erläutert, wie Sie OAuth 2.0 mit der Google-Anmeldedaten, um Zugriff auf Chat API Authentifizieren und autorisieren mit Nutzeranmeldedaten können Chat-Apps auf Nutzerdaten zugreifen Vorgänge im Namen des authentifizierten Nutzers ausführen. Durch die Authentifizierung auf der hat die App dieselben Berechtigungen wie dieser Nutzer und kann Aktionen ausführen. so als ob sie von diesem Nutzer ausgeführt würden.

Nach der Authentifizierung und Autorisierung API-Aufruf mit Nutzeranmeldedaten ausführen, können Chat-Apps Folgendes:

  • Chatbereiche erstellen
  • Nutzer zu Chatbereichen und Gruppenunterhaltungen hinzufügen.
  • Mit Nutzerdaten in anderen Workspace APIs arbeiten, z. B. in den folgenden: <ph type="x-smartling-placeholder">

Wenn eine App eine Aktion mit Nutzerauthentifizierung ausführt (z. B. beim Erstellen eines Gruppenbereichs), wird in Google Chat eine Attributionsnachricht angezeigt. der den Namen der App enthält, die die Aktion für Nutzer, der sie autorisiert hat.

<ph type="x-smartling-placeholder">
</ph> In der Google Chat App wird ein Gruppenbereich für einen Nutzer erstellt.
Abbildung 1. Die Attributionsnachricht, die in Google Chat angezeigt wird, wenn eine Chat-App im Namen eines Nutzers einen Gruppenbereich erstellt.

Weitere Informationen dazu, wann Chat-Apps eine Authentifizierung erfordern und welche Art von Authentifizierung verwendet werden soll, Arten der erforderlichen Authentifizierung in der Übersicht über die Authentifizierung und Autorisierung der Chat API.

Mit domainweiter Delegierung authentifizieren und autorisieren

Als Domainadministrator können Sie domainweite Delegierung von Befugnissen um das Dienstkonto einer Anwendung für den Zugriff auf die ohne Jeder Nutzer muss seine Einwilligung geben. Nachdem Sie die domainweite Delegierung konfiguriert haben, die Dienstkonto kann die Identität eines Nutzerkontos übernehmen. Ein Dienstkonto wird zwar für gibt die domainweite Delegierung die Identität eines Nutzers an und ist daher Nutzerauthentifizierung. Alle Funktionen, die Nutzer können Sie die domainweite Delegierung verwenden.

Mit Administratorberechtigungen authentifizieren und autorisieren

Als Domainadministrator oder delegierter Administrator mit Administratorberechtigungen können Sie Ihre Aufrufe an die Google Chat API mit Administratorberechtigungen authentifizieren und autorisieren, indem Sie das Feld use_admin_access in den Anfragen der entsprechenden Methoden festlegen. Weitere Informationen finden Sie in der API-Referenzdokumentation.

Hinweis: Wenn eine Google Chat-App eine Aktion mit Administratorberechtigungen ausführt, wird Nutzern weder der Name der Chat-App, über die die Aktion ausgeführt wurde, noch der Name des Administrators mitgeteilt, der sie autorisiert hat. Nutzer werden lediglich darüber informiert, dass die Aktion vom Administrator ihrer Organisation ausgeführt wird.

Vorbereitung

Java

Python

Node.js

Apps Script

Schritt 1: OAuth-Zustimmungsbildschirm konfigurieren, Bereiche angeben und App registrieren

Wenn Sie OAuth 2.0 für die Autorisierung verwenden, zeigt Google einen Zustimmungsbildschirm an, des Nutzers, einschließlich einer Zusammenfassung Ihres Projekts, seiner Richtlinien und der Autorisierungsbereiche. OAuth-Zustimmungsbildschirm der Anwendung konfigurieren definiert, was Google Nutzern und App-Prüfern anzeigt, und registriert deine App damit Sie es später veröffentlichen können.

Alle Apps, die OAuth 2.0 verwenden, erfordern eine Konfiguration des Zustimmungsbildschirms. Sie können Sie müssen Bereiche für Apps auflisten, die von Personen außerhalb Ihres Google Workspace-Kontos verwendet werden Unternehmen.

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

  1. Öffnen Sie in der Google Cloud Console das Menü . &gt; APIs und Dienste &gt; OAuth-Zustimmungsbildschirm.

    Zum OAuth-Zustimmungsbildschirm

  2. Wählen Sie den Nutzertyp für Ihre Anwendung aus und klicken Sie auf Erstellen.

  3. Füllen Sie das App-Registrierungsformular aus und klicken Sie dann auf Speichern und fortfahren.

  4. Klicken Sie auf Bereiche hinzufügen oder entfernen. Fügen Sie den Parameter Autorisierungsbereiche, die für Ihre App erforderlich sind, klicken Sie auf Aktualisieren und dann auf Speichern und fortfahren.

  5. Überprüfen Sie die Registrierungsübersicht der App. Klicken Sie auf Bearbeiten, um Änderungen vorzunehmen, oder Klicken Sie auf Zurück zum Dashboard.

Schritt 2: OAuth-Client-ID-Anmeldedaten in der Google Cloud Console erstellen

Um sich als Endnutzer zu authentifizieren und in Ihrer App auf Nutzerdaten zuzugreifen, müssen Sie Erstellen Sie eine oder mehrere OAuth 2.0-Client-IDs. Eine Client-ID wird zur Identifizierung einer einzelnen Anwendung bei Googles OAuth-Servern verwendet. Wenn Ihre App auf mehreren wie Android, iOS und Web, müssen Sie eine separate Client-ID für für jede Plattform.

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

OAuth-Client-ID-Anmeldedaten erstellen

Wähle deinen Anwendungstyp aus, um spezifische Anweisungen zum Erstellen einer OAuth-Client-ID zu erhalten:

Webanwendung

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; Webanwendung.
  4. Geben Sie in das Feld Name einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Fügen Sie zu Ihrer App gehörige autorisierte URIs hinzu: <ph type="x-smartling-placeholder">
      </ph>
    • Clientseitige Apps (JavaScript): Klicken Sie unter Autorisierte JavaScript-Quellen auf URI hinzufügen. Geben Sie dann einen URI ein, der für Browseranfragen verwendet werden soll. Hiermit werden die Domains identifiziert, von denen aus Ihre Anwendung API-Anfragen an den OAuth 2.0-Server senden kann.
    • Serverseitige Anwendungen (Java, Python und mehr): Klicken Sie unter Autorisierte Weiterleitungs-URIs auf URI hinzufügen. Geben Sie dann einen Endpunkt-URI ein, an den der OAuth 2.0-Server Antworten senden kann.
  6. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem Clientschlüssel angezeigt.

    Notieren Sie sich die Client-ID. Clientschlüssel werden nicht für Webanwendungen verwendet.

  7. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter OAuth 2.0-Client-IDs angezeigt.

Android

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; Android.
  4. Geben Sie im Feld „Name“ einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Unter „Paketname“ den Paketnamen aus der Datei AndroidManifest.xml ein.
  6. Im SHA-1-Zertifikatfingerabdruck den generierten SHA-1-Zertifikatfingerabdruck ein.
  7. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" mit Ihrer neuen Client-ID wird angezeigt.
  8. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter „OAuth 2.0-Client-IDs“ angezeigt.

iOS

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; iOS.
  4. Geben Sie im Feld „Name“ einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Wählen Sie im Feld „Bundle-ID“ geben Sie den Paket-Identifikator so ein, wie er in der Datei Info.plist der App aufgeführt ist.
  6. Optional: Wenn Ihre App im Apple App Store angezeigt wird, geben Sie die App Store-ID ein.
  7. Optional: Geben Sie unter „Team-ID“ die eindeutige zehnstellige Zeichenfolge ein, die von Apple generiert und Ihrem Team zugewiesen wurde.
  8. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem Clientschlüssel angezeigt.
  9. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter „OAuth 2.0-Client-IDs“ angezeigt.

Chrome App

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; Chrome-App.
  4. Geben Sie im Feld „Name“ einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Wählen Sie im Feld „Anwendungs-ID“ die eindeutige 32-stellige ID-Zeichenfolge Ihrer Anwendung ein. Sie finden diesen ID-Wert in der Chrome Web Store-URL Ihrer App und im Chrome Web Store-Entwickler-Dashboard.
  6. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem Clientschlüssel angezeigt.
  7. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter „OAuth 2.0-Client-IDs“ angezeigt.

Desktopanwendung

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; Desktop-App.
  4. Geben Sie in das Feld Name einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem neuen Clientschlüssel angezeigt.
  6. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter OAuth 2.0-Client-IDs angezeigt.

Fernseher und Geräte mit begrenzter Eingabe

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf App-Typ &gt; Fernseher und Geräte mit begrenzter Eingabe.
  4. Geben Sie im Feld „Name“ einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem neuen Clientschlüssel angezeigt.
  6. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter „OAuth 2.0-Client-IDs“ angezeigt.

Universal Windows Platform (UWP)

  1. Öffnen Sie in der Google Cloud Console das Dreistrich-Menü &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie auf Anmeldedaten erstellen &gt; OAuth-Client-ID.
  3. Klicken Sie auf Anwendungstyp &gt; Universelle Windows-Plattform (UWP).
  4. Geben Sie im Feld „Name“ einen Namen für die Anmeldedaten ein. Dieser Name wird nur in der Google Cloud Console angezeigt.
  5. Im Feld „Shop-ID“ den eindeutigen 12-stelligen Microsoft Store-ID-Wert für Ihre App ein. Sie finden diese ID in der Microsoft Store-URL Ihrer App und im Partnercenter.
  6. Klicken Sie auf Erstellen. Der Bildschirm "OAuth-Client erstellt" wird mit Ihrer neuen Client-ID und Ihrem Clientschlüssel angezeigt.
  7. Klicken Sie auf OK. Die neu erstellten Anmeldedaten werden unter „OAuth 2.0-Client-IDs“ angezeigt.

Clientschlüssel-JSON-Datei herunterladen

Die Clientschlüsseldatei ist eine JSON-Darstellung der OAuth-Client-ID. Anmeldedaten, auf die sich die Chat-App beziehen kann, Anmeldedaten angeben.

  1. Öffnen Sie in der Google Cloud Console das Menü . &gt; APIs und Dienste &gt; Anmeldedaten.

    Zu den Anmeldedaten

  2. Klicken Sie unter OAuth 2.0-Client-IDs auf die erstellte Client-ID.

  3. Klicken Sie auf JSON herunterladen.

  4. Speichern Sie die Datei als client_secrets.json.

Schritt 3: Google-Clientbibliothek und andere Abhängigkeiten installieren

Installieren Sie die Google-Clientbibliothek und andere Abhängigkeiten, die für das Projekt erforderlich sind.

Java

So fügen Sie die Google-Clientbibliotheken und andere erforderliche Abhängigkeiten Maven-Projekt zu erstellen, bearbeiten Sie die Datei pom.xml im Verzeichnis Ihres Projekts und fügen Sie den folgenden Abhängigkeiten:

<dependencies>
  <!-- ... existing dependencies ... -->
  <dependency>
    <groupId>com.google.apis</groupId>
    <artifactId>google-api-services-chat</artifactId>
    <version>v1-rev20230905-2.0.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.auth</groupId>
    <artifactId>google-auth-library-oauth2-http</artifactId>
    <version>1.19.0</version>
  </dependency>
  <dependency>
    <groupId>com.google.oauth-client</groupId>
    <artifactId>google-oauth-client-jetty</artifactId>
    <version>1.34.1</version>
  </dependency>
  <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.10.1</version>
  </dependency>
</dependencies>

Python

Wenn Sie die Google-Clientbibliotheken für Python noch nicht installiert haben, führen Sie den folgenden Befehl aus: den folgenden Befehl in der Befehlszeile ein:

pip3 install --upgrade google-api-python-client google-auth-oauthlib

Node.js

So fügen Sie die Google-Clientbibliotheken und andere erforderliche Abhängigkeiten Node.js-Projekt öffnen möchten, wechseln Sie zum Verzeichnis Ihres Projekts und führen Sie den folgenden Befehl aus: Befehl in Ihrer Befehlszeile:

npm install "@googleapis/chat" open server-destroy

Apps Script

In diesem Beispiel wird die Methode Erweiterter Chat-Dienst um die Google Chat API aufzurufen. So aktivieren Sie den Dienst für Ihr Apps Script-Projekt:

  1. Klicken Sie links auf Editor .
  2. Klicken Sie links neben Dienste auf Dienst hinzufügen.
  3. Wählen Sie Google Chat API aus.
  4. Wählen Sie unter Version die Option v1 aus.
  5. Klicken Sie auf Hinzufügen.

Sie können jede Sprache verwenden, die von unserem Clientbibliotheken.

Schritt 4: Script schreiben, mit dem die Chat API aufgerufen wird

Der Aufruf einer API mit OAuth-Autorisierung ist ein mehrstufiger Prozess. In Web- oder Desktop-Anwendungen läuft der Prozess normalerweise wie folgt ab:

  1. Die App leitet den Nutzer zu einer Autorisierungsseite weiter, auf der er den Zugriff anfordert durch Autorisierungsbereiche angegebene Daten. Die App gibt sich gegenüber dem Client aus. ID-Anmeldedaten.
  2. Der Nutzer überprüft die von der App angeforderten Berechtigungen und genehmigt die
  3. Der Authentifizierungsserver von Google leitet den Browser an das HTTP-Protokoll der Anwendung weiter. Endpunkt und einen Autorisierungscode enthält.
  4. Die Anwendung sendet eine weitere Anfrage an den Autorisierungsserver von Google, tauschen Sie den Autorisierungscode gegen ein Zugriffstoken aus.
  5. Die Anwendung verwendet das Zugriffstoken, um die API im Namen des Nutzers aufzurufen.

Weitere Informationen zum OAuth-Autorisierungsprozess finden Sie unter OAuth 2.0 für den Zugriff auf Google APIs verwenden

In den folgenden Codebeispielen in Java, Python und Node.js wird ein Clientbibliothek um den OAuth-Autorisierungsvorgang auszuführen. Es öffnet einen lokalen HTTP-Server, den Autorisierungscode vom Autorisierungsserver zurückerhalten, den er dann Zugriffstokens austauschen. Im Apps Script-Codebeispiel ist dieser Autorisierungsablauf von Apps Script verarbeitet werden.

Nach Abschluss des Authentifizierungsvorgangs authentifiziert sich das Skript beim Chat API mit dem Zugriffstoken des Nutzers und erstellt dann ein Leerzeichen.

Java

  1. Öffnen Sie die Datei im Verzeichnis Ihres Projekts. src/main/java/com/google/chat/app/authsample/App.java

  2. Ersetzen Sie den Inhalt in App.java durch den folgenden Code:

    package com.google.chat.app.authsample;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.chat.v1.HangoutsChat;
import com.google.api.services.chat.v1.model.Space;

import java.io.InputStreamReader;
import java.util.Collection;
import java.util.Collections;

/**
 * Authenticates with Chat API via user credentials, then creates a Chat space.
 */
public class App {
    // Application OAuth credentials.
    private static final String KEYS_RESOURCE_URI = "/client_secrets.json";

    // Define your app's authorization scopes.
    private static final Collection<String> SCOPES =
        Collections.singleton("https://www.googleapis.com/auth/chat.spaces.create");

    // Directory to store user credentials.
    private static final java.io.File DATA_STORE_DIR =
        new java.io.File(System.getProperty("user.home"), ".store/auth-sample-app");

    // Global instance of the JSON factory.
    private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

    // Global instance of the HTTP transport.
    private static HttpTransport httpTransport;

    // Global instance of the DataStoreFactory. The best practice is to make it a single
    // globally shared instance across your application.
    private static FileDataStoreFactory dataStoreFactory;

    public static void main( String[] args ) {
        try {
            // Run app.
            httpTransport = GoogleNetHttpTransport.newTrustedTransport();
            dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);
            Credential userCredential = authorize();
            Space response = App.createChatSpace(userCredential);
            // Print details about the created space.
            System.out.println(response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Authorizes the installed application to access user's protected data.
     */
    private static Credential authorize() throws Exception {
        // Load client secrets.
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY,
            new InputStreamReader(App.class.getResourceAsStream("/client_secrets.json")));
        // Set up authorization code flow.
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
            httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
            .setDataStoreFactory(dataStoreFactory)
            .build();
        // Authorize.
        return new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
    }

    /**
     * Creates a Chat space.
     */
    private static Space createChatSpace(Credential userCredential) throws Exception {
        // Build the Chat API client and authenticate with the user account.
        HangoutsChat chatService = new HangoutsChat.Builder(
            httpTransport, JSON_FACTORY, userCredential)
            .setApplicationName("auth-sample-app")
            .build();

        // Create a Chat space.
        Space space = new Space()
            // To create a named space, set spaceType to SPACE.
            .setSpaceType("SPACE")
            // The user-visible name of the space.
            .setDisplayName("API-made");
        return chatService.spaces().create(space).execute();
    }
}

  3. Erstellen Sie im Verzeichnis Ihres Projekts ein neues Unterverzeichnis mit dem Namen resources.

  4. Kopieren Sie die Datei client_secrets.json in das Unterverzeichnis resources.

  5. So konfigurieren Sie Maven, um die Clientschlüsseldatei in das Projektpaket aufzunehmen: Bearbeiten Sie die Datei pom.xml im Verzeichnis Ihres Projekts und fügen Sie Folgendes hinzu: Konfiguration im Abschnitt <build>:

    <build>
  <!-- ... existing configurations ... -->
  <resources>
    <resource>
      <directory>resources</directory>
    </resource>
  </resources>
</build>

  6. Um Maven so zu konfigurieren, dass die Abhängigkeiten in das Projektpaket aufgenommen werden, und Um die Hauptklasse Ihrer Anwendung auszuführen, bearbeiten Sie die Datei pom.xml in Ihrem des Projekts und fügen Sie die folgende Konfiguration zum Abschnitt <plugins>:

    <plugins>
  <!-- ... existing configurations ... -->
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <archive>
        <manifest>
          <mainClass>com.google.chat.app.authsample.App</mainClass>
        </manifest>
      </archive>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
    </configuration>
  </plugin>
</plugins>

Python

  1. Speichern Sie den folgenden Code in einer Datei mit dem Namen chat_space_create_named.py im demselben Verzeichnis, das client_secrets.json enthält:

    from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

# Define your app's authorization scopes.
# When modifying these scopes, delete the file token.json, if it exists.
SCOPES = ["https://www.googleapis.com/auth/chat.spaces.create"]

def main():
  '''
  Authenticates with Chat API via user credentials,
  then creates a Chat space.
  '''

  flow = InstalledAppFlow.from_client_secrets_file(
                    'client_secrets.json', SCOPES)
  creds = flow.run_local_server()

  # Build a service endpoint for Chat API.
  service = build('chat', 'v1', credentials=creds)

  # Use the service endpoint to call Chat API.
  result = service.spaces().create(

    # Details about the space to create.
    body = {

      # To create a named space, set spaceType to SPACE.
      'spaceType': 'SPACE',

      # The user-visible name of the space.
      'displayName': 'API-made'

    }

  ).execute()

  # Prints details about the created space.
  print(result)

if __name__ == '__main__':
  main()

Node.js

  1. Speichern Sie den folgenden Code in einer Datei mit dem Namen chat_space_create_named.js im Dies ist das Verzeichnis, in dem sich das Node.js-Projekt und client_secrets.json befinden:

    const fs = require('fs');
const path = require('path');
const http = require('http');
const url = require('url');
const destroyer = require('server-destroy');

const chat = require('@googleapis/chat');

// Application OAuth credentials.
const keys = require('./client_secrets.json').installed;

// Define your app's authorization scopes.
// When modifying these scopes, delete the file token.json, if it exists.
const scopes = ["https://www.googleapis.com/auth/chat.spaces.create"];

// Create a new OAuth2 client with the configured keys.
const oauth2Client = new chat.auth.OAuth2(
  keys.client_id,
  keys.client_secret,
  'http://localhost:3000'
);

/**
 * Opens an HTTP server to accept the OAuth callback.
 * In this simple example, the only request to our webserver is to /?code=<code>.
 */
async function authenticate(scopes) {
  const opn = (await import('open')).default;

  return new Promise((resolve, reject) => {
    // Generate the URL for authorization.
    const authorizeUrl = oauth2Client.generateAuthUrl({
      access_type: 'offline',
      scope: scopes.join(' '),
    });
    // Start the HTTP server to listen for the callback.
    const server = http
      .createServer(async (req, res) => {
        try {
          const qs = new url.URL(req.url, 'http://localhost:3000').searchParams;
          res.end('Authentication successful! Please return to the console.');
          server.destroy();
          const { tokens } = await oauth2Client.getToken(qs.get('code'));
          oauth2Client.credentials = tokens;
          resolve(oauth2Client);
        } catch (e) {
          reject(e);
        }
      })
      .listen(3000, () => {
        // Open the browser to the authorize URL to start the workflow.
        opn(authorizeUrl, { wait: false }).then(cp => cp.unref());
      });
    destroyer(server);
  });
}

/**
 * Authenticates with Chat API via user credentials, then creates a Chat space.
 */
async function createSpace() {
  // Create the Chat API client and authenticate with the authorized user.
  const chatClient = await chat.chat({
    version: 'v1',
    auth: oauth2Client
  });

  // Call the Chat API to create a space.
  const result = await chatClient.spaces.create({

    // Details about the space to create.
    requestBody: {

      // To create a named space, set spaceType to SPACE.
      'spaceType': 'SPACE',

      // The user-visible name of the space.
      'displayName': 'API-made'

    }

  });
  return result;
}

// Authenticate the user, execute the function,
// then print details about the created space.
authenticate(scopes)
  .then(createSpace)
  .then(console.log);

Apps Script

  1. Bearbeiten Sie die Datei „appsscript.json“ im Apps Script-Editor und fügen Sie den erforderlichen OAuth-Bereich hinzu, um die API aufzurufen:

      "oauthScopes": [
    "https://www.googleapis.com/auth/chat.spaces.create"
  ]

  2. Speichern Sie den folgenden Code in einer Datei namens ChatSpaceCreateNamed.gs in Ihrem Apps Script-Projekt:

    /**
 * Authenticates with Chat API via user credentials, then creates a
 * Chat space.
 */
function createSpace() {
  try {
    // Details about the space to create.
    // To create a named space, set spaceType to SPACE.
    // The user-visible name of the space is displayName.
    const space = {'displayName': 'API-made', 'spaceType': 'SPACE'};

    // Call Chat API with user credentials to create the space.
    const result = Chat.Spaces.create(space);

    // Log details about the created space.
    console.log(result);
  } catch (err) {
    // TODO (developer) - Handle exception
    console.log('Failed to create space with error %s', err.message);
  }
}

Schritt 5: Beispielskript ausführen

Um das Beispiel auszuführen, wechseln Sie über die Befehlszeile zum Verzeichnis mit Ihre Projektdateien und führen Sie dann den folgenden Befehl aus:

Java

mvn compile assembly:single
java -jar target/auth-sample-app-1.0-SNAPSHOT-jar-with-dependencies.jar

Python

python3 chat_space_create_named.py

Node.js

node chat_space_create_named.js

Apps Script

Datei „ChatSpaceCreateNamed.gs“ in Apps Script öffnen Editor und klicken Sie auf Ausführen.

Ein Browser wird geöffnet und Sie werden aufgefordert, sich in Ihrem Google-Konto anzumelden:

Melde dich an, um eine Chat-App zu autorisieren.

Abbildung 2. OAuth-Zustimmungsbildschirm, in dem Sie das Konto für die Authentifizierung der Anwendung auswählen.

Nach der Anmeldung wird der OAuth-Zustimmungsbildschirm angezeigt und Sie werden gebeten, Berechtigung für die App.

Nachdem Sie die Berechtigung erteilt haben, ruft das Skript die Chat API, die als Antwort den Chatbereich mit dem Anzeigenamen „API-made“. Die Konsole gibt des API-Aufrufs. Sie finden den Gruppenbereich im Bereich Gruppenbereiche Google Chat

Fehlerbehebung für das Beispiel

Wenn Sie chat_space_create_named.py ausführen, erhalten Sie möglicherweise folgende Fehlermeldung:

Expected a JSON object with a single property for a "web" or "installed" application

Diese Fehlermeldung bedeutet, dass die heruntergeladene Datei client_secrets.json in der Google Cloud Console beginnt nicht mit "web" oder "installed" Property. Wenn Ihr Code nach der Authentifizierung mit der heruntergeladenen Datei Speichern Sie das Zugriffstoken in einer neuen Datei wie token.json. in client_secrets.json geschrieben, was zu diesem Fehler bei nachfolgenden Autorisierungsversuche.

Laden Sie die Clientschlüsseldatei aus der Google Cloud Console herunter, um den Fehler zu beheben und speichern Sie die neue Datei am Platz der aktuellen Datei.

  • Wenn Ihre Anwendung die Nutzertokens außerhalb des Bereichs weiterhin verwenden muss eines einzelnen Ablaufs sind, können die Tokens gespeichert werden, um sie später wiederzuverwenden. In diesem Fall Ihre Anwendung Nutzertokens sicher und Aktualisierungsvorgänge verarbeiten muss, Widerruf und Ablauf von Tokens. Weitere Informationen finden Sie unter Best Practices-Leitfaden für OAuth 2.0

  • Was die Chat API sonst noch leisten kann, erfahren Sie in der Referenzdokumentation zur Chat API