Merge pull request #1982 from CreditMutuelArkea/dercbot-1777

[DERCBOT-1777] Make thread usage configurable and unify message sending

Author: assouktim

bot/admin/server/src/main/kotlin/BotAdminVerticle.kt

@@ -540,11 +540,9 @@ open class BotAdminVerticle : AdminVerticle() {
                                 connectorProvider
                                     .configuration()
                                     .fields
-                                    .filter { it.mandatory && !bot.parameters.containsKey(it.key) }
-                                    .map {
+                                    .filter { it.mandatory && !bot.parameters.containsKey(it.key) }.associate {
                                         it.key to "Please fill a value"
                                     }
-                                    .toMap()
                             conf.copy(parameters = conf.parameters + additionalProperties)
                         } else {
                             conf

bot/connector-google-chat/src/main/kotlin/GoogleChatConnector.kt

@@ -36,7 +36,6 @@ import com.github.salomonbrys.kodein.instance
 import com.google.api.client.json.jackson2.JacksonFactory
 import com.google.api.services.chat.v1.HangoutsChat
 import com.google.api.services.chat.v1.model.DeprecatedEvent
-import com.google.api.services.chat.v1.model.Thread
 import mu.KotlinLogging
 import java.time.Duration
 
@@ -47,6 +46,7 @@ class GoogleChatConnector(
     private val authorisationHandler: GoogleChatAuthorisationHandler,
     private val useCondensedFootnotes: Boolean,
     private val introMessage: String? = null,
+    private val useThread: Boolean = false,
 ) : ConnectorBase(GoogleChatConnectorProvider.connectorType) {
     private val logger = KotlinLogging.logger {}
     private val executor: Executor by injector.instance()
@@ -79,6 +79,7 @@ class GoogleChatConnector(
                                             threadName,
                                             chatService,
                                             introMessage,
+                                            useThread,
                                         ),
                                     ),
                                 )
@@ -99,37 +100,18 @@ class GoogleChatConnector(
         delayInMs: Long,
     ) {
         logger.debug { "event: $event" }
-        if (event is Action) {
-            val message = GoogleChatMessageConverter.toMessageOut(event, useCondensedFootnotes)
-            if (message != null) {
-                callback as GoogleChatConnectorCallback
-                executor.executeBlocking(Duration.ofMillis(delayInMs)) {
-                    try {
-                        logger.info {
-                            "Sending to Google Chat: space=${callback.spaceName}, thread=${callback.threadName}"
-                        }
-                        logger.debug {
-                            "Message content: ${message.toGoogleMessage()}"
-                        }
+        if (event !is Action) return
 
-                        val response =
-                            chatService
-                                .spaces()
-                                .messages()
-                                .create(
-                                    callback.spaceName,
-                                    message.toGoogleMessage().setThread(Thread().setName(callback.threadName)),
-                                ).setMessageReplyOption("REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD")
-                                .execute()
-
-                        logger.info { "Google Chat API response: ${response?.name}" }
-                    } catch (e: Exception) {
-                        logger.error(e) {
-                            "Failed to send message to Google Chat (space=${callback.spaceName}, thread=${callback.threadName})"
-                        }
-                    }
-                }
-            }
+        val message =
+            GoogleChatMessageConverter.toMessageOut(event, useCondensedFootnotes)
+                ?: return
+
+        callback as GoogleChatConnectorCallback
+
+        executor.executeBlocking(Duration.ofMillis(delayInMs)) {
+            callback.sendGoogleMessage(
+                message,
+            )
         }
     }
 

bot/connector-google-chat/src/main/kotlin/GoogleChatConnectorCallback.kt

@@ -29,6 +29,7 @@ data class GoogleChatConnectorCallback(
     val threadName: String,
     private val chatService: HangoutsChat,
     private val introMessage: String?,
+    val useThread: Boolean,
 ) : ConnectorCallbackBase(applicationId, googleChatConnectorType) {
     private val logger = KotlinLogging.logger {}
 
@@ -54,29 +55,50 @@ data class GoogleChatConnectorCallback(
      * Sends the intro message to the Google Chat space/thread.
      */
     private fun sendIntroMessage() {
-        if (introMessage == null) return
+        val message = introMessage ?: return
+        logger.info {
+            "Sending Google Chat intro message: space=$spaceName" +
+                if (useThread) ", thread=$threadName" else ""
+        }
+        sendGoogleMessage(
+            GoogleChatConnectorTextMessageOut(message),
+        )
+    }
 
+    /**
+     * Sends message to the Google Chat space/thread.
+     */
+    fun sendGoogleMessage(message: GoogleChatConnectorMessage) {
         try {
+            val googleMessage = message.toGoogleMessage()
+            logger.debug { "Google Message content: $googleMessage" }
+
+            if (useThread) {
+                googleMessage.thread = Thread().setName(threadName)
+            }
+
             logger.info {
-                "Sending intro message to Google Chat: space=$spaceName, thread=$threadName"
+                "Sending Google Chat message: space=$spaceName" +
+                    if (useThread) ", thread=$threadName" else ""
             }
 
-            val response =
+            val request =
                 chatService
                     .spaces()
                     .messages()
-                    .create(
-                        spaceName,
-                        GoogleChatConnectorTextMessageOut(introMessage)
-                            .toGoogleMessage()
-                            .setThread(Thread().setName(threadName)),
-                    ).setMessageReplyOption("REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD")
-                    .execute()
+                    .create(spaceName, googleMessage)
+
+            if (useThread) {
+                request.messageReplyOption = "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
+            }
 
-            logger.info { "Google Chat API intro response: ${response?.name}" }
+            val response = request.execute()
+            logger.info { "Google Chat API response: ${response?.name}" }
         } catch (e: Exception) {
             logger.error(e) {
-                "Failed to send intro message to Google Chat (space=$spaceName, thread=$threadName)"
+                "Failed to send Google Chat message: " +
+                    "space=$spaceName" +
+                    if (useThread) ", thread=$threadName" else ""
             }
         }
     }

bot/connector-google-chat/src/main/kotlin/GoogleChatConnectorProvider.kt

@@ -45,6 +45,7 @@ private const val BOT_PROJECT_NUMBER_PARAMETER = "botProjectNumber"
 private const val CONDENSED_FOOTNOTES_PARAMETER = "useCondensedFootnotes"
 private const val GSA_TO_IMPERSONATE_PARAMETER = "gsaToImpersonate"
 private const val INTRO_MESSAGE_PARAMETER = "introMessage"
+private const val USE_THREAD_PARAMETER = "useThread"
 
 // Lifetime (in seconds) of each impersonated access token.
 // This is the TTL of a single token, not a hard limit on the connector:
@@ -101,13 +102,17 @@ internal object GoogleChatConnectorProvider : ConnectorProvider {
             val introMessage =
                 connectorConfiguration.parameters[INTRO_MESSAGE_PARAMETER]?.takeIf { it.isNotBlank() }
 
+            val useThread =
+                connectorConfiguration.parameters[USE_THREAD_PARAMETER] == "1"
+
             return GoogleChatConnector(
                 connectorId,
                 path,
                 chatService,
                 authorisationHandler,
                 useCondensedFootnotes,
                 introMessage,
+                useThread,
             )
         }
     }
@@ -199,6 +204,11 @@ internal object GoogleChatConnectorProvider : ConnectorProvider {
                     INTRO_MESSAGE_PARAMETER,
                     false,
                 ),
+                ConnectorTypeConfigurationField(
+                    "Use thread (true = 1, false = 0)",
+                    USE_THREAD_PARAMETER,
+                    false,
+                ),
             ),
             svgIcon = resourceAsString("/google_chat.svg"),
         )