Autentícate y autoriza como usuario de Google Chat

En esta guía, se explica cómo usar OAuth 2.0 con las claves las credenciales de Google para acceder a la API de Chat Autenticación y autorización con credenciales de usuario permite que las apps de Chat accedan a los datos del usuario y realicen las operaciones en nombre del usuario autenticado. A través de la autenticación en su nombre, la app tiene los mismos permisos que ese usuario y puede realizar acciones como si la hubiera llevado a cabo ese usuario.

Después de la autenticación y autorización una llamada a la API con credenciales de usuario, las apps de Chat pueden lo siguiente:

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

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

Para saber 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 la autorización de la API de Chat.

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

Si eres un administrador de dominio, puedes otorgar delegación de autoridad de todo el dominio para autorizar que una cuenta de servicio de una aplicación acceda a las contraseñas datos sin por lo que cada usuario deberá dar su consentimiento. Después de configurar la delegación de todo el dominio, el la cuenta de servicio puede usar la identidad de una cuenta de usuario. Aunque las cuentas de servicio se usan para autenticación, la delegación de todo el dominio se hace pasar por un usuario y, por lo tanto, se se considera autenticación de usuarios. Cualquier funcionalidad que requiera el uso autenticación, puedes usar la delegación de todo el dominio.

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 estableciendo el campo use_admin_access en las solicitudes de los métodos aplicables. Si deseas 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 dirá a los usuarios el nombre de la app que realizó la acción ni el nombre del administrador que la autorizó, sino que solo les indicará que la realiza el administrador de su organización.

Requisitos previos

Para ejecutar el ejemplo de esta guía, necesitas los siguientes requisitos previos:

Además, necesitas los siguientes requisitos previos específicos para cada lenguaje:

Java

  • JDK 1.7 o superior
  • Maven herramienta de administración de paquetes

  • Un proyecto de Maven inicializado. Para inicializar un proyecto nuevo, ejecuta siguiente comando en tu 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

  • Python 3.6 o superior
  • El valor pip herramienta de administración de paquetes

Node.js

  • Node.js
  • La herramienta npm herramienta de administración de paquetes

  • Un proyecto de Node.js inicializado. Para inicializar un proyecto nuevo, crea cambia a una nueva carpeta, luego ejecuta el siguiente comando en tu interfaz de línea de comandos:

    npm init

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 para usuario, incluyendo un resumen de tu proyecto, sus políticas y los documentos permisos de autorización. Configura la pantalla de consentimiento de OAuth de tu app define lo que Google muestra a los usuarios y revisores de la app, y registra tu app para que puedas publicarlo más tarde.

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 Google Workspace para que se adapten a las necesidades de tu organización.

  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 para tu app y, luego, haz clic en Crear.

  3. Completa el formulario de registro de apps y, luego, haz clic en Guardar y continuar.

  4. Haz clic en Add or Remove Scopes. Agrega y verifica el 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. Haz clic 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 hacer lo siguiente: crear uno o varios ID 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 múltiples como Android, iOS y la Web, necesitas crear un ID de cliente para para cada plataforma.

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 aplicación:
    • Apps del cliente (JavaScript): En Orígenes autorizados de JavaScript, haz clic en Agregar URI. Luego, ingresa un URI para usar en las solicitudes del navegador. Esto identifica los dominios desde los cuales tu aplicación puede enviar solicitudes de API al servidor OAuth 2.0.
    • Apps del servidor (Java, Python y más): en Authorized redirect URIs, haz clic en Add 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 de creación del cliente de OAuth, en la que se mostrará tu nuevo ID de cliente y secreto del cliente.

    Anota el ID de cliente. Los secretos del cliente no se usan para las aplicaciones web.

  7. Haz clic en Aceptar. La credencial creada recientemente aparece en ID 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 la sección “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 la “Huella digital del certificado SHA-1” ingresa tu huella digital del certificado SHA-1 generada.
  7. Haz clic en Crear. Aparecerá la pantalla de creación del cliente de OAuth, en la que se mostrará 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 la sección “Nombre” escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En "ID del paquete", ingresa el identificador de paquete como aparece en el archivo Info.plist de la app.
  6. Opcional: Si tu aplicación aparece en la App Store de Apple, ingresa el ID de la tienda de aplicaciones.
  7. Opcional: En "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 de creación del cliente de OAuth, en la que se mostrará tu nuevo ID de cliente y secreto del cliente.
  9. Haz clic en Aceptar. La credencial creada recientemente aparecerá en "ID 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 la sección “Nombre” escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En "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 del desarrollador de Chrome Web Store.
  6. 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.
  7. Haz clic en Aceptar. La credencial creada recientemente aparecerá en "ID 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 > Aplicación 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 nueva aparece en ID de cliente de OAuth 2.0.

TVs y Dispositivos de entrada limitados

  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 limitados
  4. En la sección “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 creada recientemente aparecerá en "ID 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 la sección “Nombre” escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
  5. En "ID de tienda", ingresa el valor único de 12 caracteres de ID de Microsoft Store de tu app. Puedes encontrar este ID en la URL de Microsoft Store de tu app y en el Centro de socios.
  6. 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.
  7. Haz clic en Aceptar. La credencial creada recientemente aparecerá en "ID de cliente de OAuth 2.0".

Descarga el archivo JSON del secreto del cliente

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

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

    Ir a Credenciales

  2. En ID de cliente 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 requeridas a tu Para tu proyecto de Maven, edita el archivo pom.xml en el directorio de tu proyecto y agrega el archivo 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 tu 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 tu interfaz de línea de comandos:

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

Apps Script

En este ejemplo, se usan Servicio de chat avanzado llamar a la API de Google Chat. Para activar el servicio en tu Proyecto de Apps Script:

  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 idioma que admita nuestra 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 la Web o de escritorio, el proceso suele ser el siguiente:

  1. La app dirige al usuario a una página de autorización para solicitar acceso al usuario. datos especificados por los permisos de autorización. La app se identifica con el cliente Credenciales de ID.
  2. El usuario revisa los permisos solicitados por la aplicación y aprueba el para cada solicitud.
  3. El servidor de autenticación de Google redirecciona el navegador al HTTP de la app extremo junto con un código de autorización.
  4. La aplicación envía otra solicitud al servidor de autorización de Google al 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.

Para obtener más información sobre el proceso de autorización de OAuth, consulta Guía sobre 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 un biblioteca cliente para ejecutar el flujo de autorización de OAuth. Abre un servidor HTTP local para el código de autorización del servidor de autorización, que luego intercambios por un token de acceso. En la muestra de código de Apps Script, este flujo de autorización se manejadas por Apps Script.

Después de completar el flujo de autenticación, la secuencia de comandos se autentica con el La API de Chat con 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 con 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 nuevo subdirectorio llamado resources dentro del directorio de tu proyecto.

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

  5. Para configurar Maven a fin de que incluya el archivo de secretos del cliente en el paquete del proyecto, Edita el archivo pom.xml en el directorio de tu proyecto y agrega lo siguiente: de Terraform en 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 Para ejecutar la clase principal de tu aplicación, edita el archivo pom.xml en tu directorio del proyecto y agrega la siguiente configuración al 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 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 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 Apps Script. Editor y haz clic en Ejecutar.

Se abre un navegador y se te indica que accedas a tu Cuenta de Google:

Acceder para autorizar una app de Chat

Figura 2. Pantalla de consentimiento de OAuth en la que se selecciona la cuenta que se autenticará de 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 que otorgues permiso, la secuencia de comandos llamará a API de Chat, que responde creando la Espacio de Chat con el nombre visible API-made. La consola imprime los detalles de la llamada a la API. Para encontrar el espacio, ve al panel Espacios de Google Chat.

Soluciona problemas del ejemplo

Cuando ejecutas chat_space_create_named.py, es posible que recibas el siguiente error:

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 "web" ni "installed" propiedad. Después de la autenticación con el archivo descargado, si el código no guarda el token de acceso en un archivo nuevo como token.json; luego, el token de acceso se escribe en client_secrets.json, lo que puede causar este error durante intentos de autorización.

Para resolver el error, descarga el archivo de secretos del cliente desde la consola de Google Cloud y guarda el archivo nuevo en el lugar del archivo actual.

  • Si tu aplicación necesita seguir usando los tokens de usuario fuera del permiso, haz lo siguiente: de un solo flujo, puede almacenar los tokens para reutilizarlos más tarde. En este caso, Tu aplicación necesita manejar los tokens de usuario de forma segura y las actualizaciones. y el vencimiento de tokens. Para obtener más información, consulta Guía de prácticas recomendadas para el uso de OAuth 2.0

  • Para descubrir qué más puede hacer la API de Chat, revisa el Documentación de referencia de la API de Chat