Autenticare e autorizzare come utente di Google Chat

Questa guida spiega come utilizzare OAuth 2.0 con le credenziali Google degli utenti per accedere all'API Chat. L'autenticazione e l'autorizzazione con credenziali utente consentono alle app di Chat di accedere ai dati utente ed eseguire operazioni per conto dell'utente autenticato. Grazie all'autenticazione per conto di un utente, l'app ha le stesse autorizzazioni dell'utente e può eseguire azioni come se fosse stata eseguita da quell'utente.

Dopo aver autenticato e autorizzato una chiamata API con le credenziali utente, le app di chat possono:

  • Creare spazi di Chat.
  • Aggiungere utenti agli spazi di Chat e alle conversazioni di gruppo.
  • Utilizza i dati utente in altre API Workspace come queste:

Quando un'app esegue un'azione con autenticazione dell'utente (ad esempio, la creazione di uno spazio), Google Chat mostra un messaggio di attribuzione che indica agli utenti il nome dell'app che ha eseguito l'azione per l'utente che l'ha autorizzata.

L'app Google Chat crea uno spazio per un utente.
Figura 1. Il messaggio di attribuzione mostrato da Google Chat quando un'app di Chat crea uno spazio per conto di un utente.

Per scoprire di più su quando le app di Chat richiedono l'autenticazione e sul tipo di autenticazione da utilizzare, consulta Tipi di autenticazione richiesta nella panoramica dell'autenticazione e dell'autorizzazione dell'API Chat.

Se sei un amministratore di dominio, puoi concedere la delega dell'autorità a livello di dominio per autorizzare l'account di servizio di un'applicazione ad accedere ai dati degli utenti senza richiedere il consenso di ogni utente. Dopo aver configurato la delega a livello di dominio, l'account di servizio può impersonare un account utente. Sebbene un account di servizio venga utilizzato per l'autenticazione, la delega a livello di dominio impersona un utente ed è quindi considerata un'autenticazione utente. Per qualsiasi funzionalità che richieda l'autenticazione dell'utente, puoi utilizzare la delega a livello di dominio.

Prerequisiti

Per eseguire l'esempio in questa guida, sono necessari i seguenti prerequisiti:

Inoltre, devi disporre dei seguenti prerequisiti specifici della lingua:

Java

  • JDK 1.7 o superiore
  • Lo strumento di gestione dei pacchetti di Maven
  • Un progetto Maven inizializzato. Per inizializzare un nuovo progetto, esegui questo comando nell'interfaccia a riga di comando:

    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 o versioni successive
  • Lo strumento di gestione dei pacchetti pip

Node.js

  • Node.js
  • Lo strumento di gestione dei pacchetti npm
  • Un progetto Node.js inizializzato. Per inizializzare un nuovo progetto, crea e passa a una nuova cartella, quindi esegui questo comando nell'interfaccia a riga di comando:

    npm init
    

Apps Script

Passaggio 1: configura la schermata per il consenso OAuth, specifica gli ambiti e registra l'app

Quando utilizzi OAuth 2.0 per l'autorizzazione, Google mostra all'utente una schermata per il consenso, che include un riepilogo del progetto, i relativi criteri e gli ambiti di autorizzazione richiesti. La configurazione della schermata per il consenso OAuth dell'app definisce cosa viene mostrata da Google a utenti e revisori di app e registra la tua app per poterla pubblicare in un secondo momento.

Tutte le app che utilizzano OAuth 2.0 richiedono una configurazione della schermata di consenso, ma devi solo elencare gli ambiti per le app utilizzate da persone esterne all'organizzazione Google Workspace.

  1. Nella console Google Cloud, vai a Menu > API e servizi > Schermata consenso OAuth.

    Vai alla schermata per il consenso OAuth

  2. Seleziona il tipo di utente per l'app e fai clic su Crea.

  3. Compila il modulo di registrazione dell'app, poi fai clic su Salva e continua.

  4. Fai clic su Aggiungi o rimuovi ambiti. Aggiungi e verifica gli ambiti di autorizzazione richiesti dalla tua app, fai clic su Aggiorna e poi su Salva e continua.

  5. Rivedi il riepilogo della registrazione dell'app. Fai clic su Modifica per apportare modifiche oppure fai clic su Torna alla dashboard.

Passaggio 2: crea le credenziali dell'ID client OAuth nella console Google Cloud

Per autenticarti come utente finale e accedere ai dati utente nella tua app, devi creare uno o più ID client OAuth 2.0. Un ID client viene utilizzato per identificare una singola app nei server OAuth di Google. Se la tua app viene eseguita su più piattaforme, come Android, iOS e web, devi creare un ID client separato per ogni piattaforma.

Crea credenziali ID client OAuth

Scegli il tipo di applicazione per istruzioni specifiche su come creare un ID client OAuth:

Applicazione web

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > Applicazione web.
  4. Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Aggiungi gli URI autorizzati relativi alla tua app:
    • App lato client (JavaScript): in Origini JavaScript autorizzate, fai clic su Aggiungi URI. Quindi, inserisci un URI da utilizzare per le richieste del browser. Identifica i domini da cui l'applicazione può inviare richieste API al server OAuth 2.0.
    • App lato server (Java, Python e altri): in URI di reindirizzamento autorizzati, fai clic su Aggiungi URI. Quindi, inserisci l'URI dell'endpoint a cui il server OAuth 2.0 può inviare le risposte.
  6. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.

    Prendi nota dell'ID client. I client secret non vengono utilizzati per le applicazioni web.

  7. Fai clic su Ok. La credenziale appena creata viene visualizzata in ID client OAuth 2.0.

Android

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > Android.
  4. Nel campo "Nome", digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Nel campo "Nome pacchetto", inserisci il nome del pacchetto presente nel file AndroidManifest.xml.
  6. Nel campo "Impronta digitale del certificato SHA-1", inserisci l'impronta digitale del certificato SHA-1 generata.
  7. Fai clic su Crea. Viene visualizzata la schermata creata dal client OAuth, che mostra il nuovo ID client.
  8. Fai clic su Ok. La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

iOS

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > iOS.
  4. Nel campo "Nome", digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Nel campo "ID bundle", inserisci l'identificatore gruppo elencato nel file Info.plist dell'app.
  6. (Facoltativo) Se la tua app viene visualizzata nell'App Store di Apple, inserisci l'ID App Store.
  7. (Facoltativo) Nel campo "Team ID", inserisci la stringa univoca di 10 caratteri, generata da Apple e assegnata al tuo team.
  8. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
  9. Fai clic su Ok. La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

App Chrome

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > App Chrome.
  4. Nel campo "Nome", digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Nel campo "ID applicazione", inserisci la stringa ID univoca di 32 caratteri della tua app. Puoi trovare questo valore ID nell'URL del Chrome Web Store della tua app e nella Dashboard per sviluppatori del Chrome Web Store.
  6. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
  7. Fai clic su Ok. La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

Applicazione desktop

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > App desktop.
  4. Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
  6. Fai clic su Ok. La credenziale appena creata viene visualizzata in ID client OAuth 2.0.

TV e dispositivi di input limitato

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > TV e dispositivi di input con limitazioni.
  4. Nel campo "Nome", digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
  6. Fai clic su Ok. La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

Universal Windows Platform (UWP)

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. Fai clic su Crea credenziali > ID client OAuth.
  3. Fai clic su Tipo di applicazione > Universal Windows Platform (UWP).
  4. Nel campo "Nome", digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
  5. Nel campo "ID store", inserisci il valore ID Microsoft Store univoco di 12 caratteri della tua app. Puoi trovare questo ID nell'URL del Microsoft Store della tua app e nel Centro partner.
  6. Fai clic su Crea. Viene visualizzata la schermata Creazione del client OAuth, in cui sono indicati il nuovo ID client e il client secret.
  7. Fai clic su Ok. La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

Scarica il file JSON del client secret

Il file client secret è una rappresentazione JSON delle credenziali ID client OAuth a cui l'app Chat può fare riferimento quando fornisce le credenziali.

  1. Nella console Google Cloud, vai a Menu > API e servizi > Credenziali.

    Vai a Credenziali

  2. In ID client OAuth 2.0, fai clic sull'ID client che hai creato.

  3. Fai clic su Scarica JSON.

  4. Salva il file come client_secrets.json.

Passaggio 3: installa la libreria client di Google e altre dipendenze

Installa la libreria client di Google e le altre dipendenze necessarie per il progetto.

Java

Per aggiungere le librerie client di Google e altre dipendenze necessarie al tuo progetto Maven, modifica il file pom.xml nella directory del progetto e aggiungi le seguenti dipendenze:

<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

Se non hai già installato le librerie client di Google per Python, esegui questo comando nell'interfaccia a riga di comando:

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

Node.js

Per aggiungere le librerie client di Google e altre dipendenze necessarie al progetto Node.js, passa alla directory del progetto ed esegui questo comando nell'interfaccia a riga di comando:

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

Apps Script

In questo esempio viene utilizzato il servizio Chat avanzato per chiamare l'API Google Chat. Per attivare il servizio per il tuo progetto Apps Script:

  1. A sinistra, fai clic su Editor .
  2. Sulla sinistra, accanto a Servizi, fai clic su Aggiungi un servizio .
  3. Seleziona API Google Chat.
  4. In Versione, seleziona v1.
  5. Fai clic su Add (Aggiungi).

Puoi utilizzare qualsiasi linguaggio supportato dalle nostre librerie client.

Passaggio 4: scrivi uno script che chiami l'API Chat

La chiamata a un'API con autorizzazione OAuth è un processo in più passaggi. Nelle applicazioni web o desktop, la procedura è generalmente la seguente:

  1. L'app indirizza l'utente a una pagina di autorizzazione che richiede l'accesso ai dati utente specificati dagli ambiti di autorizzazione. L'app si identifica con le credenziali dell'ID client.
  2. L'utente esamina le autorizzazioni richieste dall'app e approva la richiesta.
  3. Il server di autenticazione di Google reindirizza il browser all'endpoint HTTP dell'app insieme a un codice di autorizzazione.
  4. L'applicazione invia un'altra richiesta al server di autorizzazione di Google per scambiare il codice di autorizzazione con un token di accesso.
  5. L'applicazione utilizza il token di accesso per chiamare l'API per conto dell'utente.

Per scoprire di più sul processo di autorizzazione OAuth, consulta la guida sull'utilizzo di OAuth 2.0 per accedere alle API di Google.

I seguenti esempi di codice in Java, Python e Node.js utilizzano una libreria client per eseguire il flusso di autorizzazione OAuth. Apre un server HTTP locale per ricevere il codice di autorizzazione dal server di autorizzazione, che poi scambia con un token di accesso. Nell'esempio di codice di Apps Script, questo flusso di autorizzazione è gestito da Apps Script.

Dopo aver completato il flusso di autenticazione, lo script si autentica con l'API Chat utilizzando il token di accesso dell'utente, quindi crea uno spazio.

Java

  1. Nella directory del progetto, apri il file src/main/java/com/google/chat/app/authsample/App.java.
  2. Sostituisci i contenuti in App.java con il seguente codice:

    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. Crea una nuova sottodirectory denominata resources all'interno della directory del progetto.

  4. Copia il file client_secrets.json nella sottodirectory resources.

  5. Per configurare Maven in modo da includere il file client secret nel pacchetto del progetto, modifica il file pom.xml nella directory del progetto e aggiungi la seguente configurazione alla sezione <build>:

    <build>
      <!-- ... existing configurations ... -->
      <resources>
        <resource>
          <directory>resources</directory>
        </resource>
      </resources>
    </build>
    
  6. Per configurare Maven in modo da includere le dipendenze nel pacchetto del progetto ed eseguire la classe principale dell'applicazione, modifica il file pom.xml nella directory del progetto e aggiungi la seguente configurazione alla sezione <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. Salva il seguente codice in un file denominato chat_space_create_named.py nella stessa directory che contiene 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. Salva il seguente codice in un file denominato chat_space_create_named.js nella stessa directory che contiene il progetto Node.js e 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. Nell'editor di Apps Script, modifica il file appsscript.json e aggiungi l'ambito OAuth necessario per chiamare l'API:

      "oauthScopes": [
        "https://www.googleapis.com/auth/chat.spaces.create"
      ]
    
  2. Salva il seguente codice in un file denominato ChatSpaceCreateNamed.gs nel tuo progetto 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);
      }
    }
    

Passaggio 5: esegui lo script di esempio

Per eseguire l'esempio, dalla riga di comando vai alla directory che contiene i file di progetto, quindi esegui questo comando:

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

Apri il file ChatSpaceCreateNamed.gs nell'editor di Apps Script e fai clic su Esegui.

Si apre un browser che ti chiede di accedere al tuo Account Google:

Accedere per autorizzare un&#39;app di Chat.

Figura 2. Schermata per il consenso OAuth in cui devi selezionare l'account per autenticare l'app.

Dopo aver eseguito l'accesso, viene visualizzata la schermata per il consenso OAuth in cui ti viene chiesto di concedere l'autorizzazione all'app.

Dopo aver concesso l'autorizzazione, lo script chiama l'API Chat, che risponde creando lo spazio Chat con il nome visualizzato API-made. La console stampa i dettagli della chiamata API. Per trovare lo spazio, vai al riquadro Spazi in Google Chat.

Risolvere i problemi relativi all'esempio

Quando esegui chat_space_create_named.py, potresti ricevere un errore che dice:

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

Questo messaggio di errore indica che il file client_secrets.json che hai scaricato dalla console Google Cloud non inizia con la proprietà "web" o "installed". Dopo l'autenticazione con il file scaricato, se il codice non salva il token di accesso in un nuovo file come token.json, il token di accesso viene scritto in client_secrets.json, il che può causare questo errore durante i successivi tentativi di autorizzazione.

Per risolvere l'errore, scarica nuovamente il file client secret dalla console Google Cloud e salva il nuovo file nella posizione del file corrente.

  • Se la tua applicazione deve continuare a utilizzare i token utente al di fuori dell'ambito di un singolo flusso, può archiviare i token per riutilizzarli in un secondo momento. In questo caso, l'applicazione deve gestire i token utente in modo sicuro e gestire la revoca e la scadenza dei token di aggiornamento. Per ulteriori informazioni, consulta la Guida alle best practice per l'utilizzo di OAuth 2.0.

  • Per scoprire cos'altro può fare l'API Chat, consulta la documentazione di riferimento dell'API Chat.