Google Chat 사용자로 인증 및 승인하기

자바

• 비즈니스 또는 기업 다음 액세스 권한이 있는 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

• 비즈니스 또는 기업 다음 액세스 권한이 있는 Google Workspace 계정 Google Chat
• Google Cloud 프로젝트를 만듭니다.
• Google Chat API를 사용 설정 및 구성합니다. 아이콘, 채팅 앱 설명이 있습니다.
• Python 3.6 이상
• pip 패키지 관리 도구

Node.js

• 비즈니스 또는 기업 다음 액세스 권한이 있는 Google Workspace 계정 Google Chat
• Google Cloud 프로젝트를 만듭니다.
• Google Chat API를 사용 설정 및 구성합니다. 아이콘, 채팅 앱 설명이 있습니다.
• Node.js 14 이상
• npm 패키지 관리 도구
• 초기화된 Node.js 프로젝트 새 프로젝트를 초기화하려면 새 폴더로 전환한 후 명령줄 인터페이스에서 다음 명령어를 실행합니다.

  npm init

Apps Script

• 비즈니스 또는 기업 다음 액세스 권한이 있는 Google Workspace 계정 Google Chat
• Google Cloud 프로젝트를 만듭니다.
• Google Chat API를 사용 설정 및 구성합니다. 아이콘, 채팅 앱 설명이 있습니다.
• 독립형 Apps Script 프로젝트 만들기 그런 다음 고급 채팅 서비스를 사용 설정합니다.

자바

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 Script

이 샘플은 고급 Chat 서비스 Google Chat API를 호출할 수 있습니다 다음에 대해 서비스를 사용 설정하려면 다음 단계를 따르세요. Apps Script 프로젝트:

1. 왼쪽에서 편집기 code를 클릭합니다.
2. 왼쪽의 서비스 옆에 있는 서비스 추가를 클릭합니다. add입니다.
3. Google Chat API를 선택합니다.
4. 버전에서 v1을 선택합니다.
5. 추가를 클릭합니다.

자바

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 Script

1. Apps Script 편집기에서 appsscript.json 파일을 수정합니다. API를 호출하는 데 필요한 OAuth 범위를 추가합니다.

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

2. 다음 코드를ChatSpaceCreateNamed.gs 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);
     }
   }
   

자바

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

Apps Script에서 ChatSpaceCreateNamed.gs 파일을 엽니다. 편집하고 실행을 클릭합니다.