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

Ce guide explique comment utiliser OAuth 2.0 avec l'authentification d'identifiants Google pour accéder au API Chat : Authentification et autorisation permet aux applications Chat d'accéder aux données utilisateur pour le compte de l'utilisateur authentifié. En s’authentifiant sur l'application dispose des mêmes autorisations que cet utilisateur et peut effectuer des actions comme si elle avait été effectuée par cet utilisateur.

Après authentification et autorisation un appel d'API avec des identifiants utilisateur, les applications Chat peuvent suivantes:

Lorsqu'une application effectue une action avec l'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 l'utilisateur qui l'a autorisé.

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

Pour savoir quand les applications Chat exigent une authentification et le type d'authentification à utiliser, voir Types d'authentification requise dans la présentation de l'API Chat sur l'authentification et l'autorisation.

Authentification et autorisation à l'aide de la délégation au niveau du domaine

Si vous êtes administrateur de domaine, vous pouvez accorder délégation d'autorité au niveau du domaine pour autoriser le compte de service d'une application à accéder aux données sans données obligeant chaque utilisateur à donner son consentement. Après avoir configuré la délégation au niveau du domaine, la Le compte de service peut emprunter l'identité d'un compte utilisateur. Bien qu'un compte de service soit utilisé l'authentification, la délégation au niveau du domaine emprunte l'identité d'un utilisateur et est donc comme l'authentification des utilisateurs. Toute fonctionnalité nécessitant 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 un administrateur de domaine ou un administrateur délégué doté de droits d'administrateur, vous pouvez authentifier et autoriser vos appels vers l'API Google Chat avec des droits d'administrateur en définissant le champ use_admin_access dans les requêtes des méthodes applicables. Pour en savoir plus, consultez la documentation de référence de l'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 qui a effectué l'action ni le nom de l'administrateur qui l'a autorisée, mais uniquement que l'action est exécutée par l'administrateur de leur organisation.

Prérequis

Java

  • Une entreprise Un compte Google Workspace ayant accès à Google Chat :
  • Créez un projet Google Cloud.
  • activer et configurer l'API Google Chat à l'aide d'un nom ; et la description de votre application Chat.
  • JDK 1.7 ou version ultérieure
  • L'outil de gestion de paquets Maven
  • Un 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 les champs d'application et enregistrez votre application

Lorsque vous utilisez OAuth 2.0 pour l'autorisation, Google affiche un écran de consentement pour un résumé de votre projet, de ses règles et des informations et des niveaux d'autorisation. Configurer l'écran de consentement OAuth de votre application définit ce que Google présente aux utilisateurs et aux examinateurs de l'application, et enregistre votre application pour pouvoir les publier ultérieurement.

Toutes les applications qui utilisent OAuth 2.0 nécessitent une configuration d'écran de consentement, mais vous seul lister les champs d'application pour les applications utilisées par des personnes extérieures à Google Workspace organisation.

  1. Dans la console Google Cloud, accédez au 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'inscription de l'application, puis cliquez sur Enregistrer et continuer.

  4. Cliquez sur Ajouter ou supprimer des habilitations. Ajoutez et validez le requis par votre application, cliquez sur Mettre à jour, puis sur Enregistrer et continuer.

  5. Consultez le récapitulatif d'enregistrement de votre application. Cliquez sur Modifier pour apporter des modifications, ou cliquez sur Retour 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 (comme Android, iOS et le Web), vous devez créer un ID client distinct pour chaque plateforme.

Créer des identifiants 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 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 des navigateurs. 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 "Client OAuth créé" s'affiche. Il contient l'ID et le code secret du client.

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

  7. Cliquez sur OK. Les nouveaux identifiants apparaissent sous ID clients 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 ne s'affiche que dans la console Google Cloud.
  5. Dans le champ « Nom du package », , saisissez le nom du package à partir de votre fichier AndroidManifest.xml.
  6. Dans le champ "Empreinte du certificat SHA-1", saisissez l'empreinte de votre certificat SHA-1 générée.
  7. Cliquez sur Créer. L'écran "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 "Nom", saisissez un nom pour l'identifiant. Ce nom ne s'affiche que dans la console Google Cloud.
  5. Dans "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 ID App Store.
  7. Facultatif: Dans "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 "Client OAuth créé" s'affiche. Il contient l'ID et le code secret du client.
  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 "Nom", saisissez un nom pour l'identifiant. Ce nom ne s'affiche que dans la console Google Cloud.
  5. Dans "ID de l'application", saisissez la chaîne d'ID unique de votre application à 32 caractères. La valeur de cet identifiant est indiquée 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. Il contient l'ID et le code secret du client.
  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 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 "Client OAuth créé" s'affiche. Il contient l'ID et le code secret du client.
  6. Cliquez sur OK. Les nouveaux identifiants s'affichent sous ID clients 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 "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 "Client OAuth créé" s'affiche. Il contient l'ID et le code secret du client.
  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 "Nom", saisissez un nom pour l'identifiant. Ce nom ne s'affiche que dans la console Google Cloud.
  5. Dans "ID de magasin" , saisissez la valeur unique de l'ID Microsoft Store de votre application à 12 caractères. 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 "Client OAuth créé" s'affiche. Il contient l'ID et le code secret du client.
  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 de code secret du client est une représentation JSON de l'ID client OAuth. que votre application Chat peut référencer en fournissant des identifiants.

  1. Dans la console Google Cloud, accédez au menu . > API et Services > Identifiants.

    Accéder à "Identifiants"

  2. Sous ID clients 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 Maven, modifiez le fichier pom.xml dans le répertoire de votre projet et ajoutez le 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 : 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 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 Service Chat avancé pour appeler l'API Google Chat. Pour activer le service sur votre Projet Apps Script:

  1. À 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 quelle langue prise en charge par notre bibliothèques clientes.

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

L'appel d'une API avec une autorisation OAuth est un processus en plusieurs étapes. Sur le Web ou applications 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 à l'utilisateur. par le champ d'application des autorisations. L'application s'identifie auprès du client identifiants d'identification.
  2. L'utilisateur examine les autorisations demandées par l'application et approuve les requête.
  3. Le serveur d'authentification de Google redirige le navigateur vers le protocole HTTP de l'application et un code d'autorisation.
  4. L'application envoie une autre requête au serveur d'autorisation de Google pour 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 Guide d'utilisation du protocole OAuth 2.0 pour l'accès aux API Google

Les exemples de code suivants (Java, Python et Node.js) utilisent un bibliothèque cliente pour exécuter le flux d'autorisation OAuth. Il ouvre un serveur HTTP local reçoivent le code d'autorisation du serveur d'autorisation, qu'il pour obtenir un jeton d'accès. Dans l'exemple de code Apps Script, ce flux d'autorisation gérées par Apps Script.

Une fois le flux d'authentification terminé, le script s'authentifie auprès du 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 du fichier 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, procédez comme suit : Modifiez le fichier pom.xml dans le répertoire de votre projet et ajoutez ce qui suit : configuration à la section <build>:

    <build>
      <!-- ... existing configurations ... -->
      <resources>
        <resource>
          <directory>resources</directory>
        </resource>
      </resources>
    </build>
    
  6. Configurer Maven de manière à inclure les dépendances dans le package de projet pour exécuter la classe principale de votre application, modifiez le fichier pom.xml dans votre dans le répertoire du projet et ajoutez la configuration suivante au 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 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 vos fichiers de 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 Apps Script. Editor et cliquez sur Run (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 pour authentifier l'application.

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

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

Résoudre les problèmes liés à l'exemple

Lors de l'exécution de chat_space_create_named.py, vous pouvez recevoir l'erreur suivante:

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é de la console Google Cloud ne commence pas par "web" ni par "installed" . Après vous être authentifié avec le fichier téléchargé, si votre code ne enregistrez le jeton d'accès dans un nouveau fichier tel que token.json. Le jeton d'accès est alors écrit dans client_secrets.json, ce qui peut entraîner cette erreur lors de de tentatives d'autorisation.

Pour résoudre l'erreur, téléchargez le fichier de code secret du client depuis la console Google Cloud et 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 même flux, il peut stocker les jetons 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 l'actualisation. la révocation et l'expiration des jetons. Pour en savoir plus, consultez 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