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 à l'aide d'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 étaient 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 l'authentification de l'utilisateur (par exemple, en créant un espace), Google Chat affiche un message d'attribution indiquant 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 savoir quand les applications Chat nécessitent une authentification et quel type d'authentification utiliser, consultez la section Types d'authentification requis dans la présentation de l'authentification et de l'autorisation de l'API Chat.

S'authentifier et s'autoriser en tant qu'administrateur Google Workspace

Cette section explique comment les administrateurs de l'espace de travail Google Workspace peuvent gérer les applications et les espaces Google Chat dans leur organisation à l'aide de l'authentification des utilisateurs.

Authentifier et autoriser à l'aide de la délégation au niveau du domaine

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'entre eux ait à donner son consentement. Une fois la délégation au niveau du domaine configurée, le compte de service peut usurper 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 usurpe l'identité d'un utilisateur et est donc considérée comme une authentification utilisateur. Pour toute fonctionnalité nécessitant l'authentification des utilisateurs, vous pouvez utiliser la délégation au niveau du domaine.

S'authentifier et autoriser l'accès à l'aide de droits d'administrateur

Si vous êtes administrateur de domaine ou administrateur délégué disposant de droits d'administrateur, vous pouvez authentifier et autoriser vos appels à l'API Google Chat avec des droits d'administrateur en définissant le champ useAdminAccess dans les requêtes des méthodes applicables. Pour en savoir plus, consultez la documentation de référence sur les API.

Notez que lorsqu'une application Google Chat effectue une action avec des droits d'administrateur, Chat n'indique pas aux utilisateurs le nom de l'application Chat qui a effectué l'action ni celui de l'administrateur qui l'a autorisée, mais seulement que l'action est effectuée par l'administrateur de leur organisation.

Prérequis

Java

  • Compte Google Workspace Business ou Enterprise ayant accès à Google Chat.
  • Créez un projet Google Cloud.
  • Activez et configurez l'API Google Chat en attribuant un nom, une icône et une description à votre application Chat.
  • JDK 1.7 ou version ultérieure
  • L'outil de gestion de paquets 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

Node.js

Apps Script

Étape 1: Configurez l'écran de consentement OAuth, spécifiez des champs d'application et enregistrez votre application

Lorsque vous utilisez OAuth 2.0 pour gérer les autorisations, Google présente à l'utilisateur un écran de consentement, qui montre un récapitulatif de votre projet et des règles qui s'y appliquent, ainsi que les périmètres d'autorisation demandés. En configurant l'écran de consentement OAuth de votre application, vous définissez ce que Google affiche aux utilisateurs et aux évaluateurs de l'application, et vous enregistrez votre application pour pouvoir la publier ultérieurement.

Toutes les applications utilisant OAuth 2.0 nécessitent une configuration de l'écran de consentement, mais vous n'avez besoin de lister des 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 pour votre application, puis cliquez sur Créer.

  3. Remplissez le formulaire d'enregistrement 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'autorisation requis par votre application, cliquez sur Mettre à jour, puis sur Enregistrer et continuer.

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

Étape 2: Créez des identifiants 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 (Android, iOS et Web, par exemple), vous devez créer un ID client distinct pour chaque plate-forme.

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 Nom, saisissez un nom pour l'identifiant. Ce nom n'apparaît 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. Il 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 vers lequel le serveur OAuth 2.0 peut envoyer des réponses.
  6. Cliquez sur Créer. L'écran "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.

    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 "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 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 "Client OAuth créé" s'affiche, avec 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 "Nom", saisissez un nom pour l'identifiant. Ce nom n'apparaît que dans la console Google Cloud.
  5. Dans le champ "Bundle ID" (ID de bundle), saisissez l'identifiant de bundle tel qu'il apparaît dans le fichier Info.plist de l'application.
  6. Facultatif: Si votre application figure dans l'App Store d'Apple, saisissez l'ID App Store.
  7. Facultatif: Dans le champ "ID de l'é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 "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
  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 "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'ID unique de 32 caractères de votre application. Vous trouverez cette valeur d'ID 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 "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
  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 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 "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
  6. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous ID client OAuth 2.0.

Téléviseurs et appareils à saisie limitée

  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 > TV et appareils à saisie limitée.
  4. Dans le champ "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 "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
  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 "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 l'ID Microsoft Store unique de 12 caractères de votre application. Vous trouverez cet ID dans l'URL Microsoft Store de votre application et dans le Partner Center.
  6. Cliquez sur Créer. L'écran "Client OAuth créé" s'affiche, avec votre nouvel ID client et votre nouveau code secret.
  7. Cliquez sur OK. Les identifiants nouvellement créés s'affichent sous "ID client OAuth 2.0".

Télécharger le fichier JSON du secret client

Le fichier de secret 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 votre 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 votre interface de ligne de commande:

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

Apps Script

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

  1. Sur la gauche, cliquez sur Montage .
  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 Ajouter.

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

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

L'appel d'une API avec autorisation OAuth est un processus en plusieurs étapes. Dans les applications Web ou pour ordinateur, le processus se présente généralement comme suit:

  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. 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 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. Il 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 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 que 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 que 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, accédez au répertoire contenant les fichiers de votre projet à partir de la ligne de commande, 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 Run (Exécuter).

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

Se connecter pour autoriser une application Chat

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

Une fois connecté, l'écran de consentement OAuth s'affiche et vous demande d'accorder une 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é depuis la console Google Cloud ne commence pas par la propriété "web" ou "installed". Après l'authentification 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 de secret client à partir de la console Google Cloud, puis enregistrez le nouveau fichier à la place 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, et gérer 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.