以 Google Chat 用户的身份进行身份验证和授权

Java

• Business 或 Enterprise 有权访问以下内容的 Google Workspace 账号： Google Chat。
• 创建 Google Cloud 项目。
• 启用并配置 Google Chat API，指定一个名称， 图标和说明。
• JDK 1.7 或更高版本
• Maven 软件包管理工具
• 一个初始化的 Maven 项目。要初始化新项目，请在 命令行界面：

  mvn archetype:generate -DgroupId=com.google.chat.app.authsample -DartifactId=auth-sample-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Python

• Business 或 Enterprise 有权访问以下内容的 Google Workspace 账号： Google Chat。
• 创建 Google Cloud 项目。
• 启用并配置 Google Chat API，指定一个名称， 图标和说明。
• Python 3.6 或更高版本
• pip 软件包管理工具

Node.js

• Business 或 Enterprise 有权访问以下内容的 Google Workspace 账号： Google Chat。
• 创建 Google Cloud 项目。
• 启用并配置 Google Chat API，指定一个名称， 图标和说明。
• Node.js 14 或更高版本
• npm 软件包管理工具
• 一个已初始化的 Node.js 项目。要初始化新项目，请创建 切换到新文件夹，然后在命令行界面中运行以下命令：

  npm init

Apps 脚本

• Business 或 Enterprise 有权访问以下内容的 Google Workspace 账号： Google Chat。
• 创建 Google Cloud 项目。
• 启用并配置 Google Chat API，指定一个名称， 图标和说明。
• 创建一个独立的 Apps 脚本项目， 然后启用高级聊天服务。

Java

要将 Google 客户端库和其他所需的依赖项添加到您的 Maven 项目中，请修改项目目录中的 pom.xml 文件，并将 以下依赖项：

<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

如果尚未安装 Python 版 Google 客户端库，请运行 在命令行界面中运行以下命令：

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

Node.js

要将 Google 客户端库和其他所需的依赖项添加到您的 Node.js 项目中，切换到项目的目录并运行以下命令 命令：

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

Apps 脚本

此示例使用 高级 Chat 服务 来调用 Google Chat API。要启用该服务，请执行以下操作： Apps 脚本项目：

1. 点击左侧的编辑器 code。
2. 在左侧的服务旁边，点击添加服务。 add。
3. 选择 Google Chat API。
4. 在版本中，选择 v1。
5. 点击添加。

Java

1. 在项目的目录中，打开文件 src/main/java/com/google/chat/app/authsample/App.java。

2. 将 App.java 中的内容替换为以下代码：

   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. 在项目的目录中创建一个名为 resources 的新子目录。

4. 将文件 client_secrets.json 复制到 resources 子目录。

5. 如需将 Maven 配置为在项目软件包中包含客户端密钥文件，请按以下步骤操作： 修改项目目录中的 pom.xml 文件，并添加以下内容 添加到 <build> 部分：

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

6. 要将 Maven 配置为在项目软件包中包含依赖项，请执行以下操作： 要执行应用的主类，请在pom.xml 项目的目录中，并将以下配置添加到 “<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. 将以下代码保存到名为 chat_space_create_named.py 的文件中，该文件位于 包含 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. 将以下代码保存到名为 chat_space_create_named.js 的文件中，该文件位于 保存 Node.js 项目和 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 脚本

1. 在 Apps 脚本编辑器中，修改文件 appsscript.json 并添加调用 API 所需的 OAuth 范围：

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

2. 将以下代码保存到名为 ChatSpaceCreateNamed.gs 的文件中， Apps 脚本项目：

   /**
    * 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);
     }
   }
   

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 脚本

在 Apps 脚本中打开 ChatSpaceCreateNamed.gs 文件 Editor，然后点击 Run。