Créer une application Google Chat derrière un pare-feu avec Pub/Sub

Java

• Un compte Google Workspace ayant accès à Google Chat
• Un projet Google Cloud.
• Assurez-vous d'activer la facturation pour votre projet Cloud. Découvrez comment vérifier l'état de facturation de vos projets.
• Java 11 ou version ultérieure.
• Apache Maven

Java

1. Dans une CLI, fournissez les identifiants du compte de service:

   export GOOGLE_APPLICATION_CREDENTIALS=SERVICE_ACCOUNT_FILE_PATH
   

2. Dans votre répertoire de travail, créez un fichier nommé pom.xml.

3. Dans le fichier pom.xml, collez le code suivant:

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   
   <groupId>com.google.chat.pubsub</groupId>
   <artifactId>java-pubsub-app</artifactId>
   <version>0.1.0</version>
   
   <name>java-pubsub-app</name>
   
   <properties>
     <maven.compiler.target>11</maven.compiler.target>
     <maven.compiler.source>11</maven.compiler.source>
   </properties>
   
   <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.google.cloud</groupId>
         <artifactId>libraries-bom</artifactId>
         <version>26.26.0</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>
     </dependencies>
   </dependencyManagement>
   
   <dependencies>
     <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>
       <version>2.9.1</version>
     </dependency>
     <dependency>
       <groupId>com.google.api-client</groupId>
       <artifactId>google-api-client</artifactId>
       <version>1.32.1</version>
     </dependency>
     <dependency>
       <groupId>com.google.cloud</groupId>
       <artifactId>google-cloud-pubsub</artifactId>
     </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.14.2</version>
     </dependency>
   </dependencies>
   
   <build>
     <pluginManagement>
       <plugins>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.0</version>
         </plugin>
       </plugins>
     </pluginManagement>
   </build>
   </project>
   

4. Dans votre répertoire de travail, créez la structure de répertoires src/main/java.

5. Dans le répertoire src/main/java, créez un fichier nommé Main.java.

6. Dans Main.java, collez le code suivant:

   import com.fasterxml.jackson.databind.JsonNode;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import com.fasterxml.jackson.databind.node.JsonNodeFactory;
   import com.fasterxml.jackson.databind.node.ObjectNode;
   import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
   import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
   import com.google.api.client.http.ByteArrayContent;
   import com.google.api.client.http.GenericUrl;
   import com.google.api.client.http.HttpContent;
   import com.google.api.client.http.HttpRequest;
   import com.google.api.client.http.HttpRequestFactory;
   import com.google.api.client.http.HttpTransport;
   import com.google.cloud.pubsub.v1.AckReplyConsumer;
   import com.google.cloud.pubsub.v1.MessageReceiver;
   import com.google.cloud.pubsub.v1.Subscriber;
   import com.google.pubsub.v1.PubsubMessage;
   import com.google.pubsub.v1.ProjectSubscriptionName;
   import java.io.FileInputStream;
   import java.util.Collections;
   
   public class Main {
   
     public static final String CREDENTIALS_PATH_ENV_PROPERTY = "GOOGLE_APPLICATION_CREDENTIALS";
   
     // Google Cloud Project ID
     public static final String PROJECT_ID = PROJECT_ID;
   
     // Cloud Pub/Sub Subscription ID
     public static final String SUBSCRIPTION_ID = SUBSCRIPTION_ID
   
     public static void main(String[] args) throws Exception {
       ProjectSubscriptionName subscriptionName =
           ProjectSubscriptionName.of(PROJECT_ID, SUBSCRIPTION_ID);
   
       // Instantiate app, which implements an asynchronous message receiver.
       EchoApp echoApp = new EchoApp();
   
       // Create a subscriber for <var>SUBSCRIPTION_ID</var> bound to the message receiver
       final Subscriber subscriber =
           Subscriber.newBuilder(subscriptionName, echoApp).build();
       System.out.println("Starting subscriber...");
       subscriber.startAsync();
   
       // Wait for termination
       subscriber.awaitTerminated();
     }
   }
   
   / **
   * A demo app which implements {@link MessageReceiver} to receive messages. It simply echoes the
   * incoming messages.
   */
   class EchoApp implements MessageReceiver {
   
     // Path to the private key JSON file of the service account to be used for posting response
     // messages to Google Chat.
     // In this demo, we are using the same service account for authorizing with Cloud Pub/Sub to
     // receive messages and authorizing with Google Chat to post messages. If you are using
     // different service accounts, please set the path to the private key JSON file of the service
     // account used to post messages to Google Chat here.
     private static final String SERVICE_ACCOUNT_KEY_PATH =
         System.getenv(Main.CREDENTIALS_PATH_ENV_PROPERTY);
   
     // Developer code for Google Chat API scope.
     private static final String GOOGLE_CHAT_API_SCOPE = "https://www.googleapis.com/auth/chat.bot";
   
     // Response URL Template with placeholders for space id.
     private static final String RESPONSE_URL_TEMPLATE =
         "https://chat.googleapis.com/v1/__SPACE_ID__/messages";
   
     // Response echo message template.
     private static final String RESPONSE_TEMPLATE = "You said: `__MESSAGE__`";
   
     private static final String ADDED_RESPONSE = "Thank you for adding me!";
   
     GoogleCredential credential;
     HttpTransport httpTransport;
     HttpRequestFactory requestFactory;
   
     EchoApp() throws Exception {
       credential =
           GoogleCredential.fromStream(new FileInputStream(SERVICE_ACCOUNT_KEY_PATH))
               .createScoped(Collections.singleton(GOOGLE_CHAT_API_SCOPE));
       httpTransport = GoogleNetHttpTransport.newTrustedTransport();
       requestFactory = httpTransport.createRequestFactory(credential);
     }
   
     // Called when a message is received by the subscriber.
     @Override
     public void receiveMessage(PubsubMessage pubsubMessage, AckReplyConsumer consumer) {
       System.out.println("Id : " + pubsubMessage.getMessageId());
       // handle incoming message, then ack/nack the received message
       try {
         ObjectMapper mapper = new ObjectMapper();
         JsonNode dataJson = mapper.readTree(pubsubMessage.getData().toStringUtf8());
         System.out.println("Data : " + dataJson.toString());
         handle(dataJson);
         consumer.ack();
       } catch (Exception e) {
         System.out.println(e);
         consumer.nack();
       }
     }
   
     public void handle(JsonNode eventJson) throws Exception {
       JsonNodeFactory jsonNodeFactory = new JsonNodeFactory(false);
       ObjectNode responseNode = jsonNodeFactory.objectNode();
   
       // Construct the response depending on the event received.
   
       String eventType = eventJson.get("type").asText();
       switch (eventType) {
         case "ADDED_TO_SPACE":
           responseNode.put("text", ADDED_RESPONSE);
           // An app can also be added to a space by @mentioning it in a message. In that case, we fall
           // through to the MESSAGE case and let the app respond. If the app was added using the
           // invite flow, we just post a thank you message in the space.
           if(!eventJson.has("message")) {
             break;
           }
         case "MESSAGE":
           responseNode.put("text",
               RESPONSE_TEMPLATE.replaceFirst(
                   "__MESSAGE__", eventJson.get("message").get("text").asText()));
           // In case of message, post the response in the same thread.
           ObjectNode threadNode = jsonNodeFactory.objectNode();
           threadNode.put("name", eventJson.get("message").get("thread").get("name").asText());
           responseNode.put("thread", threadNode);
           break;
         case "REMOVED_FROM_SPACE":
         default:
           // Do nothing
           return;
       }
   
       // Post the response to Google Chat.
   
       String URI =
           RESPONSE_URL_TEMPLATE.replaceFirst(
               "__SPACE_ID__", eventJson.get("space").get("name").asText());
       GenericUrl url = new GenericUrl(URI);
   
       HttpContent content =
           new ByteArrayContent("application/json", responseNode.toString().getBytes("UTF-8"));
       HttpRequest request = requestFactory.buildPostRequest(url, content);
       com.google.api.client.http.HttpResponse response = request.execute();
     }
   }
   

   Remplacez les éléments suivants :

   • PROJECT_ID : ID de projet Google Cloud.
   • SUBSCRIPTION_ID: ID de l'abonnement Pub/Sub que vous avez créé précédemment.

Java

mvn compile exec:java -Dexec.mainClass=Main