S'authentifier et autoriser l'accès en tant qu'utilisateur Google Chat

Ce guide explique comment utiliser OAuth 2.0 avec les identifiants Google des utilisateurs pour accéder à l'API Chat. L'authentification et l'autorisation avec les identifiants utilisateur permettent aux applications Chat d'accéder aux données utilisateur et d'effectuer des opérations pour le compte de l'utilisateur authentifié. En s'authentifiant au nom d'un utilisateur, l'application dispose des mêmes autorisations que cet utilisateur et peut effectuer des actions comme si elles avaient été effectuées par cet utilisateur.

Après avoir authentifié et autorisé un appel d'API avec des identifiants utilisateur, les applications Chat peuvent effectuer les opérations suivantes:

Lorsqu'une application effectue une action avec authentification de l'utilisateur (par exemple, créer un espace), Google Chat affiche un message d'attribution qui indique aux utilisateurs le nom de l'application qui a effectué l'action pour l'utilisateur qui l'a autorisée.

L'application Google Chat crée un espace pour un utilisateur.
Figure 1. Message d'attribution que Google Chat affiche lorsqu'une application Chat crée un espace pour le compte d'un utilisateur.

Pour en savoir plus sur les cas où les applications Chat nécessitent une authentification et sur le type d'authentification à utiliser, consultez la section Types d'authentification requises dans la présentation de l'authentification et de l'autorisation de l'API Chat.

Si vous êtes administrateur de domaine, vous pouvez accorder une délégation d'autorité au niveau du domaine pour autoriser le compte de service d'une application à accéder aux données de vos utilisateurs sans que chacun d'eux donne son consentement. Une fois la délégation au niveau du domaine configurée, le compte de service peut emprunter l'identité d'un compte utilisateur. Bien qu'un compte de service soit utilisé pour l'authentification, la délégation au niveau du domaine emprunte l'identité d'un utilisateur et est donc considérée comme une authentification de l'utilisateur. Vous pouvez employer la délégation au niveau du domaine pour toutes les fonctionnalités nécessitant une authentification des utilisateurs.

Conditions préalables

Pour exécuter l'exemple présenté dans ce guide, les conditions préalables suivantes sont requises:

De plus, vous devez remplir les conditions préalables suivantes pour chaque langage:

Java

  • JDK 1.7 ou version ultérieure
  • L'outil de gestion des packages Maven

  • Projet Maven initialisé. Pour initialiser un nouveau projet, exécutez la commande suivante dans votre interface de ligne de commande:

    mvn archetype:generate -DgroupId=com.google.chat.app.authsample -DartifactId=auth-sample-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Python

  • Python 3.6 ou version ultérieure
  • L'outil de gestion des packages pip

Node.js

  • Node.js
  • L'outil de gestion des packages npm

  • Un projet Node.js initialisé. Pour initialiser un nouveau projet, créez un dossier et basculez vers un nouveau dossier, puis exécutez la commande suivante dans votre interface de ligne de commande:

    npm init

Apps Script ;

Étape 1: Configurer l'écran de consentement OAuth, spécifier les champs d'application et enregistrer votre application

Lorsque vous utilisez OAuth 2.0 pour l'autorisation, Google présente à l'utilisateur un écran de consentement comprenant un résumé de votre projet, ses règles et les champs d'application d'autorisation demandés. La configuration de l'écran de consentement OAuth de votre application permet de définir ce que Google présente aux utilisateurs et aux examinateurs de l'application, et d'enregistrer votre application pour que vous puissiez la publier ultérieurement.

Toutes les applications utilisant OAuth 2.0 nécessitent une configuration d'écran de consentement, mais vous ne devez répertorier que les champs d'application des applications utilisées par des personnes externes à votre organisation Google Workspace.

  1. Dans la console Google Cloud, accédez à Menu > API et services > Écran de consentement OAuth.

    Accéder à l'écran de consentement OAuth

  2. Sélectionnez le type d'utilisateur de votre application, puis cliquez sur Créer.

  3. Remplissez le formulaire d'inscription de l'application, puis cliquez sur Enregistrer et continuer.

  4. Cliquez sur Ajouter ou supprimer des champs d'application. Ajoutez et vérifiez les champs d'application d'autorisation requis par votre application. Cliquez sur Mettre à jour, puis sur Enregistrer et continuer.

  5. Consultez le résumé d'enregistrement de votre application. Cliquez sur Modifier pour apporter des modifications ou sur Revenir au tableau de bord.

Étape 2: Créez des identifiants d'ID client OAuth dans la console Google Cloud

Pour vous authentifier en tant qu'utilisateur final et accéder aux données utilisateur dans votre application, vous devez créer un ou plusieurs ID client OAuth 2.0. Un ID client sert à identifier une application unique auprès des serveurs OAuth de Google. Si votre application s'exécute sur plusieurs plates-formes, telles qu'Android, iOS et le Web, vous devez créer un ID client distinct pour chacune d'elles.

Créer des identifiants d'ID client OAuth

Choisissez votre type d'application pour obtenir des instructions spécifiques sur la création d'un ID client OAuth:

Application Web

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Application Web.
  4. Dans le champ Name (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Ajoutez des URI autorisés associés à votre application :
    • Applications côté client (JavaScript) : sous Origines JavaScript autorisées, cliquez sur Ajouter un URI. Saisissez ensuite un URI à utiliser pour les requêtes du navigateur. Ce champ identifie les domaines à partir desquels votre application peut envoyer des requêtes API au serveur OAuth 2.0.
    • Applications côté serveur (Java, Python, etc.) : sous URI de redirection autorisés, cliquez sur Ajouter un URI. Saisissez ensuite un URI de point de terminaison auquel le serveur OAuth 2.0 peut envoyer des réponses.
  6. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.

    Notez l'ID client. Les codes secrets du client ne sont pas utilisés pour les applications Web.

  7. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous ID client OAuth 2.0.

Android

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Android.
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Dans le champ "Nom du package", saisissez le nom du package indiqué dans votre fichier AndroidManifest.xml.
  6. Dans le champ "Empreinte du certificat SHA-1", saisissez l'empreinte du certificat SHA-1 générée.
  7. Cliquez sur Créer. L'écran OAuth client créé s'affiche, indiquant votre nouvel ID client.
  8. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

iOS

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > iOS.
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Dans le champ "ID du bundle", saisissez l'identifiant du bundle indiqué dans le fichier Info.plist de l'application.
  6. Facultatif: si votre application apparaît sur l'App Store d'Apple, saisissez l'ID App Store.
  7. Facultatif: dans le champ "ID d'équipe", saisissez la chaîne unique de 10 caractères générée par Apple et attribuée à votre équipe.
  8. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.
  9. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

Application Chrome

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Application Chrome.
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Dans le champ "ID de l'application", saisissez la chaîne d'identifiant unique de 32 caractères associée à votre application. Vous trouverez cette valeur d'identifiant dans l'URL Chrome Web Store de votre application et dans le tableau de bord du développeur Chrome Web Store.
  6. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.
  7. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

Application de bureau

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Application de bureau.
  4. Dans le champ Name (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.
  6. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous ID client OAuth 2.0.

Téléviseurs et périphériques d'entrée limités

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Téléviseurs et périphériques d'entrée limités.
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.
  6. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

Plate-forme Windows universelle (UWP)

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Cliquez sur Créer des identifiants > ID client OAuth.
  3. Cliquez sur Type d'application > Universal Windows Platform (UWP).
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Dans le champ "ID de plate-forme", saisissez la valeur de l'ID Microsoft Store unique à 12 caractères de votre application. Vous trouverez cet ID dans l'URL Microsoft Store de votre application et dans le Centre des partenaires.
  6. Cliquez sur Créer. L'écran OAuth créé pour le client s'affiche, indiquant votre nouvel ID et votre nouveau code secret de client.
  7. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

Télécharger le fichier JSON contenant le code secret du client

Le fichier secret du client est une représentation JSON des identifiants de l'ID client OAuth que votre application Chat peut référencer lorsqu'elle fournit des identifiants.

  1. Dans la console Google Cloud, accédez à Menu > API et services > Identifiants.

    Accéder à "Identifiants"

  2. Sous ID client OAuth 2.0, cliquez sur l'ID client que vous avez créé.

  3. Cliquez sur Télécharger au format JSON.

  4. Enregistrez le fichier sous le nom client_secrets.json.

Étape 3: Installez la bibliothèque cliente Google et les autres dépendances

Installez la bibliothèque cliente Google et les autres dépendances nécessaires au projet.

Java

Pour ajouter les bibliothèques clientes Google et les autres dépendances requises à votre projet Maven, modifiez le fichier pom.xml dans le répertoire de votre projet et ajoutez les dépendances suivantes:

<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

Si vous n'avez pas encore installé les bibliothèques clientes Google pour Python, exécutez la commande suivante dans votre interface de ligne de commande:

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

Node.js

Pour ajouter les bibliothèques clientes Google et les autres dépendances requises à votre projet Node.js, basculez vers le répertoire de votre projet et exécutez la commande suivante dans votre interface de ligne de commande:

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

Apps Script ;

Cet exemple utilise le service Advanced Chat pour appeler l'API Google Chat. Pour activer le service pour votre projet Apps Script:

  1. À gauche, cliquez sur Éditeur .
  2. Sur la gauche, à côté de Services, cliquez sur Ajouter un service .
  3. Sélectionnez API Google Chat.
  4. Dans Version, sélectionnez v1.
  5. Cliquez sur Add (Ajouter).

Vous pouvez utiliser n'importe quel langage compatible avec nos bibliothèques clientes.

Étape 4: Écrivez un script qui appelle l'API Chat

L'appel d'une API avec l'autorisation OAuth est un processus en plusieurs étapes. Pour les applications Web ou de bureau, le processus est généralement le suivant:

  1. L'application redirige l'utilisateur vers une page d'autorisation demandant l'accès aux données utilisateur spécifiées par les champs d'application d'autorisation. L'application s'identifie à l'aide d'identifiants d'ID client.
  2. L'utilisateur examine les autorisations demandées par l'application et approuve la demande.
  3. Le serveur d'authentification de Google redirige le navigateur vers le point de terminaison HTTP de l'application avec un code d'autorisation.
  4. L'application envoie une autre requête au serveur d'autorisation de Google pour échanger le code d'autorisation contre un jeton d'accès.
  5. L'application utilise le jeton d'accès pour appeler l'API au nom de l'utilisateur.

Pour en savoir plus sur le processus d'autorisation OAuth, consultez le guide Utilisation d'OAuth 2.0 pour accéder aux API Google.

Les exemples de code suivants en Java, Python et Node.js utilisent une bibliothèque cliente pour exécuter le flux d'autorisation OAuth. Elle ouvre un serveur HTTP local pour recevoir le code d'autorisation du serveur d'autorisation, qu'il échange ensuite contre un jeton d'accès. Dans l'exemple de code Apps Script, ce flux d'autorisation est géré par Apps Script.

Une fois le flux d'authentification terminé, le script s'authentifie auprès de l'API Chat à l'aide du jeton d'accès de l'utilisateur, puis crée un espace.

Java

  1. Dans le répertoire de votre projet, ouvrez le fichier src/main/java/com/google/chat/app/authsample/App.java.

  2. Remplacez le contenu de App.java par le code suivant:

    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. Créez un sous-répertoire nommé resources dans le répertoire de votre projet.

  4. Copiez le fichier client_secrets.json dans le sous-répertoire resources.

  5. Pour configurer Maven afin d'inclure le fichier de codes secrets du client dans le package du projet, modifiez le fichier pom.xml dans le répertoire de votre projet et ajoutez la configuration suivante à la section <build>:

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

  6. Pour configurer Maven de sorte qu'il inclue les dépendances dans le package du projet et exécuter la classe principale de votre application, modifiez le fichier pom.xml dans le répertoire de votre projet et ajoutez la configuration suivante à la section <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. Enregistrez le code suivant dans un fichier nommé chat_space_create_named.py dans le même répertoire contenant client_secrets.json:

    from __future__ import print_function

import os.path

from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# 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. Enregistrez le code suivant dans un fichier nommé chat_space_create_named.js dans le même répertoire qui contient le projet Node.js et client_secrets.json:

    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. Dans l'éditeur Apps Script, modifiez le fichier appsscript.json et ajoutez le champ d'application OAuth nécessaire pour appeler l'API:

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

  2. Enregistrez le code suivant dans un fichier nommé ChatSpaceCreateNamed.gs dans votre projet Apps Script:

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

Étape 5: Exécutez l'exemple de script

Pour exécuter l'exemple, à partir de la ligne de commande, accédez au répertoire qui contient les fichiers de votre projet, puis exécutez la commande suivante:

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 ;

Ouvrez le fichier ChatSpaceCreateNamed.gs dans l'éditeur Apps Script, puis cliquez sur Exécuter.

Un navigateur s'ouvre et vous invite à vous connecter à votre compte Google:

Connectez-vous pour autoriser une application Chat.

Figure 2. Écran de consentement OAuth dans lequel vous sélectionnez le compte avec lequel authentifier l'application.

Une fois connecté, l'écran de consentement OAuth s'affiche et vous demande d'accorder l'autorisation à l'application.

Une fois l'autorisation accordée, le script appelle l'API Chat, qui répond en créant l'espace Chat avec le nom à afficher API-made. La console affiche les détails de l'appel d'API. Pour trouver l'espace, accédez au panneau Espaces dans Google Chat.

Résoudre l'exemple

Lorsque vous exécutez chat_space_create_named.py, vous pouvez recevoir le message d'erreur suivant:

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

Ce message d'erreur signifie que le fichier client_secrets.json que vous avez téléchargé à partir de la console Google Cloud ne commence pas par la propriété "web" ou "installed". Une fois que vous vous êtes authentifié avec le fichier téléchargé, si votre code n'enregistre pas le jeton d'accès dans un nouveau fichier tel que token.json, le jeton d'accès est écrit dans client_secrets.json, ce qui peut entraîner cette erreur lors des tentatives d'autorisation ultérieures.

Pour résoudre l'erreur, téléchargez à nouveau le fichier secret du client à partir de la console Google Cloud, puis enregistrez le nouveau fichier à l'emplacement actuel.

  • Si votre application doit continuer à utiliser les jetons utilisateur en dehors du champ d'application d'un seul flux, elle peut les stocker pour les réutiliser ultérieurement. Dans ce cas, votre application doit gérer les jetons utilisateur de manière sécurisée, ainsi que la révocation et l'expiration des jetons d'actualisation. Pour en savoir plus, consultez le Guide des bonnes pratiques d'utilisation d'OAuth 2.0.

  • Découvrez les autres fonctionnalités de l'API Chat en consultant la documentation de référence de l'API Chat.