Improve flexibility of Slack connector

rasa/core/channels/slack.py

@@ -170,6 +170,20 @@ def __init__(
         self.retry_reason_header = slack_retry_reason_header
         self.retry_num_header = slack_retry_number_header
 
+    @staticmethod
+    def _is_app_mention(slack_event: Dict) -> bool:
+        try:
+            return slack_event["event"]["type"] == "app_mention"
+        except KeyError:
+            return False
+
+    @staticmethod
+    def _is_direct_message(slack_event: Dict) -> bool:
+        try:
+            return slack_event["event"]["channel_type"] == "im"
+        except KeyError:
+            return False
+
     @staticmethod
     def _is_user_message(slack_event: Dict) -> bool:
         return (
@@ -294,11 +308,15 @@ async def process_message(
 
             return response.text(None, status=201, headers={"X-Slack-No-Retry": 1})
 
+        if metadata is not None:
+            output_channel = metadata.get("out_channel")
+        else:
+            output_channel = None
+
         try:
-            out_channel = self.get_output_channel()
             user_msg = UserMessage(
                 text,
-                out_channel,
+                self.get_output_channel(output_channel),
                 sender_id,
                 input_channel=self.name(),
                 metadata=metadata,
@@ -311,6 +329,25 @@ async def process_message(
 
         return response.text("")
 
+    def get_metadata(self, request: Request) -> Dict[Text, Any]:
+        """Extracts the metadata from a slack API event (https://api.slack.com/types/event).
+
+        Args:
+            request: a `Request` object that contains a slack API event in the body.
+
+        Returns:
+            A `dict` containing the output channel for the response, the text from the user, the sender's ID, and
+            users that have installed the bot.
+        """
+        slack_event = request.json
+        event = slack_event.get("event")
+        return {
+            "out_channel": event.get("channel"),
+            "text": event.get("text"),
+            "sender": event.get("user"),
+            "users": slack_event.get("authed_users"),
+        }
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -348,19 +385,36 @@ async def webhook(request: Request) -> HTTPResponse:
 
                 elif self._is_user_message(output):
                     metadata = self.get_metadata(request)
-                    return await self.process_message(
-                        request,
-                        on_new_message,
-                        self._sanitize_user_message(
-                            output["event"]["text"], output["authed_users"]
-                        ),
-                        output.get("event").get("user"),
-                        metadata,
-                    )
+                    if (
+                        self._is_direct_message(output)
+                        or self._is_app_mention(output)
+                        or metadata["out_channel"] == self.slack_channel
+                    ):
+                        return await self.process_message(
+                            request,
+                            on_new_message,
+                            text=self._sanitize_user_message(
+                                metadata["text"], metadata["users"]
+                            ),
+                            sender_id=metadata["sender"],
+                            metadata=metadata,
+                        )
+                    else:
+                        return response.text(
+                            "Received message on unsupported channel: {}".format(
+                                metadata["out_channel"]
+                            )
+                        )
 
             return response.text("Bot message delivered")
 
         return slack_webhook
 
-    def get_output_channel(self) -> OutputChannel:
-        return SlackBot(self.slack_token, self.slack_channel)
+    def get_output_channel(self, channel: Optional[Text] = None) -> OutputChannel:
+        if channel is not None:
+            return SlackBot(self.slack_token, channel)
+        else:
+            return SlackBot(self.slack_token, self.slack_channel)
+
+    def set_output_channel(self, channel: Text) -> None:
+        self.slack_channel = channel

tests/core/test_channels.py

@@ -462,6 +462,50 @@ def test_botframework_attachments():
     assert ch.add_attachments_to_metadata(payload, metadata) == updated_metadata
 
 
+def test_slack_metadata():
+    from rasa.core.channels.slack import SlackInput
+    from sanic.request import Request
+
+    user = "user1"
+    channel = "channel1"
+    direct_message_event = {
+        "authed_users": ["test"],
+        "event": {
+            "client_msg_id": "XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
+            "type": "message",
+            "text": "hello world",
+            "user": user,
+            "ts": "1579802617.000800",
+            "team": "XXXXXXXXX",
+            "blocks": [
+                {
+                    "type": "rich_text",
+                    "block_id": "XXXXX",
+                    "elements": [
+                        {
+                            "type": "rich_text_section",
+                            "elements": [{"type": "text", "text": "hi"}],
+                        }
+                    ],
+                }
+            ],
+            "channel": channel,
+            "event_ts": "1579802617.000800",
+            "channel_type": "im",
+        },
+    }
+
+    input_channel = SlackInput(
+        slack_token="YOUR_SLACK_TOKEN", slack_channel="YOUR_SLACK_CHANNEL"
+    )
+
+    r = Request(None, None, None, None, None, app="test")
+    r.parsed_json = direct_message_event
+    metadata = input_channel.get_metadata(request=r)
+    assert metadata["sender"] == user
+    assert metadata["out_channel"] == channel
+
+
 def test_slack_message_sanitization():
     from rasa.core.channels.slack import SlackInput