Questa guida spiega come utilizzare OAuth 2.0 con le API le credenziali Google per accedi al API Chat. Autenticazione e autorizzazione le credenziali utente consentono alle app di Chat di accedere ai dati utente per conto dell'utente autenticato. Autenticando sul database di un utente Google, l'app ha le stesse autorizzazioni dell'utente e può eseguire azioni come se fosse eseguita da quell'utente.
Dopo l'autenticazione e l'autorizzazione una chiamata API con credenziali utente, le app di chat possono seguenti:
- Creare spazi di Chat.
- Aggiungere utenti agli spazi di Chat e alle conversazioni di gruppo.
- Lavora con i dati utente in altre API Workspace come le seguenti:
- Creare eventi in Google Calendar.
- Elementi dei log in Fogli Google.
- Inviare un'email con Gmail.
Quando un'app esegue un'azione con l'autenticazione utente ad esempio creando uno spazio, in Google Chat viene mostrato un messaggio di attribuzione che indica agli utenti il nome dell'app che ha eseguito l'azione per dall'utente che l'ha autorizzata.
![L'app Google Chat crea uno spazio per un utente.](https://developers-dot-devsite-v2-prod.appspot.com/static/workspace/chat/images/auth-user-create-space.png?authuser=6&hl=it)
Per scoprire di più su quando le app di chat richiedono l'autenticazione e quale tipo di autenticazione usare, vedi Tipi di autenticazione richiesta nella panoramica dell'autenticazione e dell'autorizzazione dell'API Chat.
Autenticazione e autorizzazione utilizzando la delega a livello di dominio
Se sei un amministratore di dominio, puoi concedere delega dell'autorità a livello di dominio per autorizzare l'account di servizio di un'applicazione ad accedere ai tuoi utenti senza dati richiedere a ciascun utente di dare il proprio consenso. Dopo aver configurato la delega a livello di dominio, il l'account di servizio può simulare l'identità di un account utente. Anche se un account di servizio viene utilizzato autenticazione, la delega a livello di dominio simula un utente ed è pertanto considerata autenticazione dell'utente. Qualsiasi funzionalità che richiede all'utente autenticazione, puoi usare la delega a livello di dominio.
Autenticazione e autorizzazione mediante privilegi amministrativi
Se sei un amministratore di dominio o un utente con delega di amministratore con privilegi di amministratore, puoi autenticare e autorizzare le chiamate all'API Google Chat con privilegi amministrativi impostando il campo use_admin_access
nelle richieste dei metodi applicabili. Per ulteriori informazioni, consulta la documentazione di riferimento API.
Tieni presente che quando un'app di Google Chat esegue un'azione con privilegi di amministratore, Chat non comunica agli utenti il nome dell'app di Chat che ha eseguito l'azione né il nome dell'amministratore che l'ha autorizzata, ma comunica soltanto agli utenti che l'azione è stata eseguita dall'amministratore della loro organizzazione.
Prerequisiti
Java
- Un'azienda o un'impresa Google Workspace con accesso a Google Chat.
- Creare un progetto Google Cloud.
- Abilita e configura l'API Google Chat con un nome, l'icona e la descrizione dell'app Chat.
- JDK 1.7 o versioni successive
- Lo strumento di gestione dei pacchetti Maven
-
Un progetto Maven inizializzato. Per inizializzare un nuovo progetto, esegui questo comando
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
- Un'azienda o un'impresa Google Workspace con accesso a Google Chat.
- Creare un progetto Google Cloud.
- Abilita e configura l'API Google Chat con un nome, l'icona e la descrizione dell'app Chat.
- Python 3.6 o versioni successive
- Lo strumento di gestione dei pacchetti pip
Node.js
- Un'azienda o un'impresa Google Workspace con accesso a Google Chat.
- Creare un progetto Google Cloud.
- Abilita e configura l'API Google Chat con un nome, l'icona e la descrizione dell'app Chat.
- Node.js 14 o versioni successive
- npm strumento di gestione dei pacchetti
-
Un progetto Node.js inizializzato. Per inizializzare un nuovo progetto, crea
passa a una nuova cartella, quindi esegui il comando seguente nell'interfaccia a riga di comando:
npm init
Apps Script
- Un'azienda o un'impresa Google Workspace con accesso a Google Chat.
- Creare un progetto Google Cloud.
- Abilita e configura l'API Google Chat con un nome, l'icona e la descrizione dell'app Chat.
- Creare un progetto Apps Script autonomo e attivare il Servizio di chat avanzato.
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 una schermata di consenso per l'utente, includendo un riepilogo del progetto, i suoi criteri e ambiti di autorizzazione. Configurare la schermata per il consenso OAuth dell'app definisce ciò che Google mostra 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 per il consenso, ma devi devi elencare gli ambiti per le app utilizzate da persone al di fuori di Google Workspace dell'organizzazione.
Nella console Google Cloud, vai al Menu > API e Servizi > Schermata consenso OAuth.
Seleziona il tipo di utente per la tua app, poi fai clic su Crea.
Compila il modulo di registrazione dell'app, quindi fai clic su Salva e continua.
Fai clic su Aggiungi o rimuovi ambiti. Aggiungi e verifica il parametro ambiti di autorizzazione richiesti dalla tua app, fai clic su Aggiorna e poi su Salva e continua.
Esamina 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 eseguire l'autenticazione come utente finale e accedere ai dati utente nella tua app, devi: Creare uno o più ID client OAuth 2.0. L'ID client viene utilizzato per identificare singola app ai server OAuth di Google. Se l'app viene eseguita su più piattaforme come Android, iOS e Web, devi creare un ID client separato per ogni piattaforma.
di Gemini Advanced.Crea credenziali con ID client OAuth
Scegli il tipo di applicazione per istruzioni specifiche su come creare un ID client OAuth:
Applicazione web
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > Applicazione web.
- Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- 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 la tua 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 un URI dell'endpoint a cui il server OAuth 2.0 può inviare le risposte.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
Prendi nota dell'ID client. I client secret non vengono utilizzati per le applicazioni web.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione ID client OAuth 2.0.
Android
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > Android.
- Nella sezione "Nome" digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Nella sezione "Nome pacchetto" inserisci il nome del pacchetto dal file
AndroidManifest.xml
. - Nella sezione "Impronta certificato SHA-1" inserisci l'impronta digitale del certificato SHA-1 generata.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione "ID client OAuth 2.0".
iOS
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > iOS.
- Nella sezione "Nome" digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Nella sezione "ID pacchetto" inserisci l'identificatore pacchetto come elencato nel file
Info.plist
dell'app. - (Facoltativo) Se la tua app viene visualizzata nell'App Store di Apple, inserisci l'ID App Store.
- (Facoltativo) Nella sezione "ID team" inserisci la stringa univoca di 10 caratteri generata da Apple e assegnata al tuo team.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione "ID client OAuth 2.0".
App Chrome
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > App Chrome.
- Nella sezione "Nome" digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Nella sezione "ID applicazione" inserisci la stringa di ID univoco 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.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione "ID client OAuth 2.0".
Applicazione desktop
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > App desktop.
- Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione ID client OAuth 2.0.
TV e Dispositivi di input limitati
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > TV e Dispositivi di input limitati.
- Nella sezione "Nome" digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione "ID client OAuth 2.0".
Universal Windows Platform (UWP)
- Nella console Google Cloud, vai a Menu > API e Servizi > Credenziali.
- Fai clic su Crea credenziali > ID client OAuth.
- Fai clic su Tipo di applicazione > Universal Windows Platform (UWP).
- Nella sezione "Nome" digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
- Nella sezione "ID negozio" inserisci il valore ID Microsoft Store univoco di 12 caratteri dell'app. Puoi trovare questo ID nell'URL Microsoft Store della tua app e nel Centro partner.
- Fai clic su Crea. Viene visualizzata la schermata di creazione del client OAuth, che mostra il nuovo ID client e il nuovo client secret.
- Fai clic su OK. Le credenziali appena create vengono visualizzate nella sezione "ID client OAuth 2.0".
Scarica il file JSON del client secret
Il file client secret è una rappresentazione JSON dell'ID client OAuth le credenziali a cui l'app di Chat può fare riferimento fornendo le credenziali.
Nella console Google Cloud, vai al Menu > API e Servizi > Credenziali.
In ID client OAuth 2.0, fai clic sull'ID client che hai creato.
Fai clic su Scarica JSON.
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 ai tuoi
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 il seguente 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 ai tuoi 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
Questo esempio utilizza Servizio Chat avanzato per chiamare l'API Google Chat. Per attivare il servizio per il tuo Progetto Apps Script:
- A sinistra, fai clic su Editor .
- A sinistra, accanto a Servizi, fai clic su Aggiungi un servizio. .
- Seleziona API Google Chat.
- In Versione, seleziona v1.
- Fai clic su Aggiungi.
Puoi utilizzare qualsiasi lingua supportata dalle nostre librerie client.
Passaggio 4: scrivi uno script che chiami l'API Chat
La chiamata a un'API con autorizzazione OAuth è un processo a più passaggi. Sul web o applicazioni desktop, la procedura è generalmente la seguente:
- L'app indirizza l'utente a una pagina di autorizzazione che richiede l'accesso all'utente specificati dagli ambiti di autorizzazione. L'app si identifica con il client credenziali dell'ID.
- L'utente esamina le autorizzazioni richieste dall'app e approva i richiesta.
- Il server di autenticazione di Google reindirizza il browser al server HTTP dell'app dell'endpoint insieme a un codice di autorizzazione.
- L'applicazione invia un'altra richiesta al server di autorizzazione di Google all'indirizzo scambia il codice di autorizzazione con un token di accesso.
- L'applicazione utilizza il token di accesso per chiamare l'API per conto dell'utente.
Per saperne di più sul processo di autorizzazione OAuth, consulta Guida all'utilizzo di OAuth 2.0 per accedere alle API di Google.
I seguenti esempi di codice in Java, Python e Node.js utilizzano un oggetto libreria client per eseguire il flusso di autorizzazione OAuth. Apre un server HTTP locale ricevere il codice di autorizzazione dal server di autorizzazione, che a sua volta gli scambi per ottenere un token di accesso. Nell'esempio di codice di Apps Script, questo flusso di autorizzazione è gestite da Apps Script.
Dopo aver completato il flusso di autenticazione, lo script autentica con API Chat utilizzando il token di accesso dell'utente; e poi crea uno spazio.
Java
- Nella directory del progetto, apri il file
src/main/java/com/google/chat/app/authsample/App.java
. 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(); } }
Crea una nuova sottodirectory denominata
resources
all'interno della directory del progetto.Copia il file
client_secrets.json
nella sottodirectoryresources
.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 quanto segue configurazione alla sezione<build>
:<build> <!-- ... existing configurations ... --> <resources> <resource> <directory>resources</directory> </resource> </resources> </build>
Per configurare Maven in modo da includere le dipendenze nel pacchetto di progetto e per eseguire la classe principale della tua applicazione, modifica il file
pom.xml
nel del progetto e aggiungi la seguente configurazione 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
Salva il seguente codice in un file denominato
chat_space_create_named.py
nel stessa directory che contieneclient_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
Salva il seguente codice in un file denominato
chat_space_create_named.js
nel nella stessa directory che contiene il progetto Node.js eclient_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
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" ]
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 passa 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
in Apps Script
Editor e fai clic su Esegui.
Si apre un browser che ti chiede di accedere al tuo Account Google:
Dopo aver eseguito l'accesso, viene visualizzata la schermata per il consenso OAuth che ti chiede di concedere autorizzazione all'app.
Dopo aver concesso l'autorizzazione, lo script chiama la classe
L'API Chat, che risponde creando il parametro
Spazio di Chat con nome visualizzato API-made
. La console stampa
dettagli della chiamata API. Per trovare lo spazio, vai al riquadro Spazi in
Google Chat.
Risolvi l'esempio
Quando esegui chat_space_create_named.py
, potresti ricevere il seguente errore:
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 "web"
o "installed"
proprietà. Dopo l'autenticazione con il file scaricato, se il codice non viene
salvare il token di accesso in un nuovo file come token.json
, il token di accesso verrà
scritto in client_secrets.json
, il che può causare questo errore durante le
tentativi di autorizzazione.
Per risolvere l'errore, scarica il file client secret dalla console Google Cloud e salva il nuovo file nella posizione attuale.
Argomenti correlati
Se l'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 l'aggiornamento la revoca e la scadenza del token. Per ulteriori informazioni, vedi Guida alle best practice per l'utilizzo di OAuth 2.0.
Per scoprire cos'altro può fare l'API Chat, consulta le documentazione di riferimento dell'API Chat.