Autentícate y autoriza como usuario de Google Chat

En esta guía, se explica cómo usar OAuth 2.0 con las credenciales de Google de los usuarios para acceder a la API de Chat. La autenticación y la autorización con credenciales del usuario permiten que las apps de Chat accedan a los datos del usuario y realicen operaciones en nombre del usuario autenticado. Cuando se autentica en nombre de un usuario, la app tiene los mismos permisos que ese usuario y puede realizar acciones como si las realizara ese usuario.

Después de autenticar y autorizar una llamada a la API con credenciales del usuario, las apps de chat pueden hacer lo siguiente:

Cuando una app realiza una acción con la autenticación del usuario (como crear un espacio), Google Chat muestra un mensaje de atribución que indica a los usuarios el nombre de la app que realizó la acción en nombre del usuario que la autorizó.

La app de Google Chat crea un espacio para un usuario.
Figura 1: Es el mensaje de atribución que muestra Google Chat cuando una app de Chat crea un espacio en nombre de un usuario.

Para obtener más información sobre cuándo las apps de Chat requieren autenticación y qué tipo de autenticación usar, consulta Tipos de autenticación obligatoria en la descripción general de la autenticación y autorización de la API de Chat.

Autentícate y autoriza como administrador de Google Workspace.

En esta sección, se explica cómo los administradores de Google Workspace pueden administrar las apps y los espacios de Google Chat en su organización con la autenticación de usuarios.

Autentica y autoriza con la delegación de todo el dominio

Si eres administrador de dominio, puedes otorgar una delegación de autoridad en todo el dominio para autorizar a la cuenta de servicio de una aplicación a acceder a los datos de tus usuarios sin que cada uno de ellos deba dar su consentimiento. Después de configurar la delegación de todo el dominio, la cuenta de servicio puede usar la identidad de una cuenta de usuario. Aunque una cuenta de servicio se usa para la autenticación, la delegación de todo el dominio se hace pasar por un usuario y, por lo tanto, se considera autenticación de usuario. Puedes usar la delegación en todo el dominio para cualquier funcionalidad que requiera la autenticación del usuario.

Autentica y autoriza con privilegios de administrador

Si eres administrador de dominio o administrador delegado con privilegios de administrador, puedes autenticar y autorizar tus llamadas a la API de Google Chat con privilegios de administrador configurando el campo useAdminAccess en las solicitudes de los métodos aplicables. Para obtener más información, consulta la documentación de referencia de la API.

Ten en cuenta que, cuando una app de Google Chat realiza una acción con privilegios de administrador, Chat no les indica a los usuarios el nombre de la app de Chat que realizó la acción ni el nombre del administrador que la autorizó, sino solo que el administrador de su organización realizó la acción.

Requisitos previos

Java

  • Una cuenta de Google Workspace para empresas o empresas con acceso a Google Chat
  • Crea un proyecto de Google Cloud
  • Habilita y configura la API de Google Chat con un nombre, un ícono y una descripción para tu app de Chat.
  • JDK 1.7 o superior
  • La herramienta de administración de paquetes Maven
  • Un proyecto de Maven inicializado Para inicializar un proyecto nuevo, ejecuta el siguiente comando en la interfaz de línea de comandos: 
    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

Paso 1: Configura la pantalla de consentimiento de OAuth, especifica los permisos y registra tu app

Cuando usas OAuth 2.0 para la autorización, Google muestra una pantalla de consentimiento al usuario que incluye un resumen de tu proyecto, sus políticas y los permisos de acceso solicitados. Cuando configuras la pantalla de consentimiento de OAuth de tu app, se define lo que Google muestra a los usuarios y revisores de apps, y se registra tu app para que puedas publicarla más adelante.

Todas las apps que usan OAuth 2.0 requieren una configuración de pantalla de consentimiento, pero solo debes enumerar los permisos de las apps que usan personas ajenas a tu organización de Google Workspace.

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Pantalla de consentimiento de OAuth.

    Ir a la pantalla de consentimiento de OAuth

  2. Selecciona el tipo de usuario de tu app y, luego, haz clic en Crear.

  3. Completa el formulario de registro de la aplicación y, luego, haz clic en Guardar y continuar.

  4. Haz clic en Agregar o quitar alcances. Agrega y verifica los permisos de autorización que requiere tu app, haz clic en Actualizar y, luego, en Guardar y continuar.

  5. Revisa el resumen del registro de tu app. Haz clic en Editar para realizar cambios o en Volver al panel.

Paso 2: Crea credenciales de ID de cliente de OAuth en la consola de Google Cloud

Para autenticarte como usuario final y acceder a los datos del usuario en tu app, debes crear uno o más IDs de cliente de OAuth 2.0. Un ID de cliente se usa con el fin de identificar una sola app para los servidores de OAuth de Google. Si tu app se ejecuta en varias plataformas, como Android, iOS y la Web, debes crear un ID de cliente independiente para cada una.

Crea credenciales de ID de cliente de OAuth

Elige tu tipo de aplicación para obtener instrucciones específicas sobre cómo crear un ID de cliente de OAuth:

Aplicación web

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > Aplicación web.
  4. En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. Agrega URI autorizados relacionados con tu app:
    • Aplicaciones del cliente (JavaScript): En Orígenes de JavaScript autorizados, haz clic en Agregar URI. Luego, ingresa un URI para usarlo en las solicitudes del navegador. Esto identifica los dominios desde los que tu aplicación puede enviar solicitudes a la API al servidor de OAuth 2.0.
    • Apps del servidor (Java, Python y mucho más): En URI de redireccionamiento autorizados, haz clic en Agregar URI. Luego, ingresa un URI de extremo al que el servidor de OAuth 2.0 pueda enviar respuestas.
  6. Haz clic en Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente y secreto de cliente.

    Toma nota del ID de cliente. Los secretos de cliente no se usan para aplicaciones web.

  7. Haz clic en Aceptar. La credencial recién creada aparecerá en IDs de cliente de OAuth 2.0.

Android

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > Android.
  4. En el campo "Nombre", escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En el campo "Nombre del paquete", ingresa el nombre del paquete de tu archivo AndroidManifest.xml.
  6. En el campo “Huella digital del certificado SHA-1”, ingresa tu huella digital del certificado SHA-1 generada.
  7. Haz clic en Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente.
  8. Haz clic en Aceptar. La credencial creada recientemente aparecerá en "ID de cliente de OAuth 2.0".

iOS

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > iOS.
  4. En el campo "Nombre", escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En el campo "ID del paquete", ingresa el identificador de paquete que aparece en el archivo Info.plist de la app.
  6. Opcional: Si tu app aparece en la App Store de Apple, ingresa el ID de la App Store.
  7. Opcional: En el campo "ID de equipo", ingresa la cadena única de 10 caracteres generada por Apple y asignada a tu equipo.
  8. Haz clic en Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente y secreto de cliente.
  9. Haz clic en Aceptar. La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".

App de Chrome

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > Aplicación de Chrome.
  4. En el campo "Nombre", escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En el campo "ID de aplicación", ingresa la cadena de ID única de 32 caracteres de tu app. Puedes encontrar este valor de ID en la URL de Chrome Web Store de tu app y en el Panel de desarrollador de Chrome Web Store.
  6. Haz clic en Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente y secreto de cliente.
  7. Haz clic en Aceptar. La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".

App de escritorio

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > App para computadoras.
  4. En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. Haz clic en Crear. Aparecerá la pantalla de creación del cliente de OAuth, en la que se mostrará tu nuevo ID de cliente y secreto del cliente.
  6. Haz clic en Aceptar. La credencial recién creada aparecerá en IDs de cliente de OAuth 2.0.

TVs y dispositivos de entrada limitada

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > TVs y dispositivos de entrada limitada.
  4. En el campo "Nombre", escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. Haz clic en Crear. Aparecerá la pantalla de creación del cliente de OAuth, en la que se mostrará tu nuevo ID de cliente y secreto del cliente.
  6. Haz clic en Aceptar. La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".

Plataforma universal de Windows (UWP)

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales > ID de cliente de OAuth.
  3. Haz clic en Tipo de aplicación > Plataforma universal de Windows (UWP).
  4. En el campo "Nombre", escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En el campo "ID de tienda", ingresa el valor único de ID de Microsoft Store de 12 caracteres de tu app. Puedes encontrar este ID en la URL de Microsoft Store de tu app y en Partner Center.
  6. Haz clic en Crear. Aparecerá la pantalla Se creó el cliente de OAuth, que muestra tu nuevo ID de cliente y secreto de cliente.
  7. Haz clic en Aceptar. La credencial recién creada aparecerá en "IDs de cliente de OAuth 2.0".

Descarga el archivo JSON del secreto de cliente

El archivo de secreto de cliente es una representación JSON de las credenciales del ID de cliente de OAuth a las que puede hacer referencia tu app de Chat cuando proporciona credenciales.

  1. En la consola de Google Cloud, ve a Menú > APIs y servicios > Credenciales.

    Ir a Credenciales

  2. En IDs de cliente de OAuth 2.0, haz clic en el ID de cliente que creaste.

  3. Haz clic en Descargar JSON.

  4. Guarda el archivo como client_secrets.json.

Paso 3: Instala la biblioteca cliente de Google y otras dependencias

Instala la biblioteca cliente de Google y otras dependencias necesarias para el proyecto.

Java

Para agregar las bibliotecas cliente de Google y otras dependencias necesarias a tu proyecto de Maven, edita el archivo pom.xml en el directorio de tu proyecto y agrega las siguientes dependencias:

<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 aún no instalaste las bibliotecas cliente de Google para Python, ejecuta el siguiente comando en la interfaz de línea de comandos:

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

Node.js

Para agregar las bibliotecas cliente de Google y otras dependencias requeridas a tu proyecto de Node.js, cambia al directorio de tu proyecto y ejecuta el siguiente comando en la interfaz de línea de comandos:

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

Apps Script

En esta muestra, se usa el servicio de Chat avanzado para llamar a la API de Google Chat. Para activar el servicio en tu proyecto de Apps Script, haz lo siguiente:

  1. A la izquierda, haz clic en Editor .
  2. A la izquierda, junto a Servicios, haz clic en Agregar un servicio .
  3. Selecciona API de Google Chat.
  4. En Versión, selecciona v1.
  5. Haz clic en Agregar.

Puedes usar cualquier lenguaje compatible con nuestras bibliotecas cliente.

Paso 4: Escribe una secuencia de comandos que llame a la API de Chat

Llamar a una API con autorización de OAuth es un proceso de varios pasos. En las aplicaciones web o para computadoras de escritorio, el proceso suele ser el siguiente:

  1. La app dirige al usuario a una página de autorización que solicita acceso a los datos del usuario especificados por los alcances de autorización. La app se identifica con credenciales de ID de cliente.
  2. El usuario revisa los permisos que solicitó la app y los aprueba.
  3. El servidor de autenticación de Google redirecciona el navegador al extremo HTTP de la app junto con un código de autorización.
  4. La aplicación envía otra solicitud al servidor de autorización de Google para intercambiar el código de autorización por un token de acceso.
  5. La aplicación usa el token de acceso para llamar a la API en nombre del usuario.

Si deseas obtener más información sobre el proceso de autorización de OAuth, consulta la Guía de Cómo usar OAuth 2.0 para acceder a las APIs de Google.

Las siguientes muestras de código en Java, Python y Node.js usan una biblioteca cliente para ejecutar el flujo de autorización de OAuth. Abre un servidor HTTP local para recibir el código de autorización del servidor de autorización, que luego intercambia por un token de acceso. En la muestra de código de Apps Script, Apps Script controla este flujo de autorización.

Después de completar el flujo de autenticación, la secuencia de comandos se autentica con la API de Chat mediante el token de acceso del usuario y, luego, crea un espacio.

Java

  1. En el directorio de tu proyecto, abre el archivo src/main/java/com/google/chat/app/authsample/App.java.

  2. Reemplaza el contenido de App.java por el siguiente código:

    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 un subdirectorio nuevo llamado resources dentro del directorio de tu proyecto.

  4. Copia el archivo client_secrets.json en el subdirectorio resources.

  5. Si quieres configurar Maven para incluir el archivo de secretos del cliente en el paquete del proyecto, edita el archivo pom.xml en el directorio de tu proyecto y agrega la siguiente configuración a la sección <build>:

    <build>
  <!-- ... existing configurations ... -->
  <resources>
    <resource>
      <directory>resources</directory>
    </resource>
  </resources>
</build>

  6. Para configurar Maven de modo que incluya las dependencias en el paquete del proyecto y ejecute la clase principal de tu aplicación, edita el archivo pom.xml en el directorio de tu proyecto y agrega la siguiente configuración a la sección <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. Guarda el siguiente código en un archivo llamado chat_space_create_named.py en el mismo directorio que 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. Guarda el siguiente código en un archivo llamado chat_space_create_named.js en el mismo directorio que contiene el proyecto de Node.js y 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. En el editor de Apps Script, edita el archivo appsscript.json y agrega el permiso de OAuth necesario para llamar a la API:

      "oauthScopes": [
    "https://www.googleapis.com/auth/chat.spaces.create"
  ]

  2. Guarda el siguiente código en un archivo llamado ChatSpaceCreateNamed.gs en tu proyecto de 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);
  }
}

Paso 5: Ejecuta la secuencia de comandos de ejemplo

Para ejecutar el ejemplo, desde la línea de comandos, navega al directorio que contiene los archivos de tu proyecto y, luego, ejecuta el siguiente 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

Abre el archivo ChatSpaceCreateNamed.gs en el editor de Apps Script y haz clic en Run.

Se abrirá un navegador y se te pedirá que accedas a tu Cuenta de Google:

Acceder para autorizar una app de Chat

Figura 2. Pantalla de consentimiento de OAuth en la que seleccionas la cuenta para autenticar la app.

Después de acceder, aparecerá la pantalla de consentimiento de OAuth y se te pedirá que otorgues permiso a la app.

Después de otorgar el permiso, la secuencia de comandos llama a la API de Chat, que responde creando el espacio de Chat con el nombre visible API-made. La consola imprime detalles de la llamada a la API. Para encontrar el espacio, ve al panel Espacios en Google Chat.

Soluciona el problema del ejemplo

Cuando ejecutes chat_space_create_named.py, es posible que recibas un error que diga lo siguiente:

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

Este mensaje de error significa que el archivo client_secrets.json que descargaste de la consola de Google Cloud no comienza con la propiedad "web" o "installed". Después de autenticar con el archivo descargado, si tu código no guarda el token de acceso en un archivo nuevo, como token.json, el token de acceso se escribe en client_secrets.json, lo que puede causar este error durante los intentos de autorización posteriores.

Para resolver el error, vuelve a descargar el archivo de secreto cliente de la consola de Google Cloud y guárdalo en lugar del archivo actual.

  • Si tu aplicación necesita seguir usando los tokens del usuario fuera del alcance de un solo flujo, puede almacenarlos para volver a usarlos más adelante. En este caso, tu aplicación debe controlar los tokens de usuario de forma segura y controlar la revocación y el vencimiento de los tokens de actualización. Para obtener más información, consulta la Guía de prácticas recomendadas para usar OAuth 2.0.

  • Revisa la documentación de referencia de la API de Chat para descubrir qué más puede hacer.