Allow opsdroid to reply in a thread with Blocks (#1903)

* Allow opsdroid to post interactive messages in a thread

* Revert imports order

* Tox removed mock.py :(

opsdroid/connector/slack/connector.py

@@ -9,6 +9,7 @@
 import aiohttp
 import certifi
 from emoji import demojize
+
 from slack_sdk.errors import SlackApiError
 from slack_sdk.socket_mode.aiohttp import SocketModeClient
 from slack_sdk.socket_mode.request import SocketModeRequest
@@ -149,6 +150,35 @@ async def disconnect(self):
     async def listen(self):
         """Listen for and parse new messages."""
 
+    def _generate_base_data(self, event: opsdroid.events.Event) -> dict:
+        """Generate a base data dict to send to the slack API.
+
+        The data dictionary will always contain `channel`, `username`
+        and `icon_emoj` which can be derived from the event or the
+        slack config.
+
+        If we want to send messages in a thread, we need to include
+        thread_ts from the linked event (the message received by opsdroid) and the slack api will know that this new message
+        should be included in a thread and not in the channel.
+
+        """
+        data = {
+            "channel": event.target,
+            "username": self.bot_name,
+            "icon_emoji": self.icon_emoji,
+        }
+
+        if event.linked_event:
+            raw_event = event.linked_event.raw_event
+
+            if isinstance(raw_event, dict) and "thread_ts" in raw_event:
+                if event.linked_event.event_id != raw_event["thread_ts"]:
+                    # Linked Event is inside a thread
+                    data["thread_ts"] = raw_event["thread_ts"]
+            elif self.start_thread:
+                data["thread_ts"] = event.linked_event.event_id
+        return data
+
     async def event_handler(self, payload):
         """Handle different payload types and parse the resulting events"""
 
@@ -313,22 +343,9 @@ async def _send_message(self, message):
         _LOGGER.debug(
             _("Responding with: '%s' in room  %s."), message.text, message.target
         )
-        data = {
-            "channel": message.target,
-            "text": message.text,
-            "username": self.bot_name,
-            "icon_emoji": self.icon_emoji,
-        }
 
-        if message.linked_event:
-            raw_event = message.linked_event.raw_event
-
-            if isinstance(raw_event, dict) and "thread_ts" in raw_event:
-                if message.linked_event.event_id != raw_event["thread_ts"]:
-                    # Linked Event is inside a thread
-                    data["thread_ts"] = raw_event["thread_ts"]
-            elif self.start_thread:
-                data["thread_ts"] = message.linked_event.event_id
+        data = self._generate_base_data(message)
+        data["text"] = message.text
 
         return await self.slack_web_client.api_call(
             "chat.postMessage",
@@ -361,16 +378,10 @@ async def _send_blocks(self, blocks):
         _LOGGER.debug(
             _("Responding with interactive blocks in room %s."), blocks.target
         )
+        data = self._generate_base_data(blocks)
+        data["blocks"] = blocks.blocks
 
-        return await self.slack_web_client.api_call(
-            "chat.postMessage",
-            data={
-                "channel": blocks.target,
-                "username": self.bot_name,
-                "blocks": blocks.blocks,
-                "icon_emoji": self.icon_emoji,
-            },
-        )
+        return await self.slack_web_client.api_call("chat.postMessage", data=data)
 
     @register_event(EditedBlocks)
     async def _edit_blocks(self, blocks):