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 au nom 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 ces actions étaient effectuées par cet utilisateur.

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

  • créer des espaces Chat ;
  • ajouter des utilisateurs à des espaces Chat et à des conversations de groupe ;
  • Travailler avec les données utilisateur dans d'autres API Workspace, par exemple :

Lorsqu'une application effectue une action avec authentification de l'utilisateur (par exemple, la création d'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 au nom d'un utilisateur.

Pour en savoir plus sur les cas où les applications Chat nécessitent une authentification et le type d'authentification à utiliser, consultez la section Types d'authentification requise dans la présentation de l'authentification et des autorisations 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 ait à donner son consentement. Une fois que vous avez configuré la délégation au niveau du domaine, 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 utiliser la délégation au niveau du domaine pour toutes les fonctionnalités nécessitant une authentification des utilisateurs.

Prérequis

Pour exécuter l'exemple de ce guide, les prérequis suivants sont requis:

De plus, vous devez remplir les prérequis spécifiques aux langages suivants:

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 celui-ci, puis exécutez la commande suivante dans l'interface de ligne de commande:

    npm init

Apps Script ;

Étape 1: Configurer l'écran de consentement OAuth, définir 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, de ses règles et des champs d'application des autorisations 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 d'applications. Elle enregistre également 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 les champs d'application que pour les 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'enregistrement de l'application, puis cliquez sur Save and Continue (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 Edit (Modifier) pour apporter des modifications ou sur Back to Dashboard (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 ne s'affiche que dans la console Google Cloud.
  5. Ajoutez les 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 du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.

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

  7. Cliquez sur OK. Les nouveaux identifiants 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 ne s'affiche que dans la console Google Cloud.
  5. Dans le champ "Nom du package", saisissez le nom du package issu de votre fichier AndroidManifest.xml.
  6. Dans le champ "Empreinte du certificat SHA-1", saisissez l'empreinte du certificat SHA-1 généré.
  7. Cliquez sur Créer. L'écran du client OAuth créé s'affiche, indiquant votre nouvel ID client.
  8. Cliquez sur OK. Les nouveaux identifiants 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 ne s'affiche 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 son identifiant.
  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 du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.
  9. Cliquez sur OK. Les nouveaux identifiants 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 ne s'affiche que dans la console Google Cloud.
  5. Dans le champ "ID de l'application", saisissez la chaîne unique d'identifiant de votre application, composée de 32 caractères. La valeur de cet identifiant se trouve 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 du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.
  7. Cliquez sur OK. Les nouveaux identifiants 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 ne s'affiche que dans la console Google Cloud.
  5. Cliquez sur Créer. L'écran du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.
  6. Cliquez sur OK. Les nouveaux identifiants 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 ne s'affiche que dans la console Google Cloud.
  5. Cliquez sur Créer. L'écran du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.
  6. Cliquez sur OK. Les nouveaux identifiants 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 > Plate-forme Windows universelle (UWP).
  4. Dans le champ "Name" (Nom), saisissez un nom pour l'identifiant. Ce nom ne s'affiche que dans la console Google Cloud.
  5. Dans le champ "ID de plate-forme", saisissez la valeur unique de l'ID Microsoft Store à 12 caractères de votre application. Vous le trouverez dans l'URL Microsoft Store de votre application et dans le Centre des partenaires.
  6. Cliquez sur Créer. L'écran du client OAuth créé s'affiche, avec l'ID et le code secret du client que vous venez de créer.
  7. Cliquez sur OK. Les nouveaux identifiants s'affichent sous "ID client OAuth 2.0".

Télécharger le fichier JSON du 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 lors de la fourniture d'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 requises pour le 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 l'interface de ligne de commande:

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

Node.js

Pour ajouter les bibliothèques clientes Google et les autres dépendances requises à votre projet Node.js, accédez au répertoire de votre projet et exécutez la commande suivante dans l'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. À 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 Ajouter.

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

Étape 4: Rédigez un script qui appelle l'API Chat

L'appel d'une API avec l'autorisation OAuth est un processus en plusieurs étapes. Dans 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 des autorisations. L'application s'identifie à l'aide des identifiants du 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 afin d'é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 Utiliser 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 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 afin d'inclure les dépendances dans le package du projet et d'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 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. Enregistrez le code suivant dans un fichier nommé chat_space_create_named.js, dans le même répertoire contenant 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 au sein de 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 contenant 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:

Connexion 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

Lors de l'exécution de 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 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 du fichier 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.