Add error notification when slack invite fails

Author: AllenAnthes

Pipfile

@@ -23,4 +23,4 @@ pytest-aiohttp = "*"
 asynctest = "*"
 
 [requires]
-python_version = "3.7"
+python_version = "3.7"

pybot/endpoints/api/slack_api.py

@@ -1,20 +1,22 @@
 import logging
+
 from sirbot import SirBot
 from slack import ROOT_URL
 from slack.exceptions import SlackAPIError
-from aiohttp.web_request import Request
 
-from pybot.endpoints.api.utils import _slack_info_from_email
+from pybot.endpoints.api.utils import _slack_info_from_email, handle_slack_invite_error
+from pybot.plugins import APIPlugin
+from pybot.plugins.api.request import SlackApiRequest
 
 logger = logging.getLogger(__name__)
 
 
-def create_endpoints(plugin):
+def create_endpoints(plugin: APIPlugin):
     plugin.on_get("verify", verify, wait=True)
     plugin.on_get("invite", invite, wait=True)
 
 
-async def verify(request: Request, app: SirBot) -> any:
+async def verify(request: SlackApiRequest, app: SirBot) -> dict:
     """
     Verifies whether a user exists in the configured slack group with
     the given email
@@ -30,23 +32,34 @@ async def verify(request: Request, app: SirBot) -> any:
     return {"exists": False}
 
 
-async def invite(request: Request, app: SirBot):
+async def invite(request: SlackApiRequest, app: SirBot):
     """
     Pulls an email out of the querystring and sends it an invite
     to the slack team
 
     :return: The request response from slack
     """
-    try:
-        slack = app.plugins["admin_slack"].api
-        email = request.query["email"]
+    slack = app.plugins["admin_slack"].api
+    body = await request.json()
+
+    if "email" not in body:
+        return {"error": "Must contain `email` JSON value"}
+    email = body["email"]
 
+    try:
         response = await slack.query(
             url=ROOT_URL + "users.admin.invite", data={"email": email}
         )
-        # logger.info("Response from slack: ", response)
         return response
 
     except SlackAPIError as e:
-        logger.info(e)
-        return e.data
+        logger.info("Slack invite resulted in SlackAPIError: " + e.error)
+        if e.data["error"] == "already_invited":
+            return e.data
+        else:
+            await handle_slack_invite_error(email, e, slack)
+
+    except Exception as e:
+        logger.exception(e)
+        await handle_slack_invite_error(email, e, slack)
+        return e

pybot/endpoints/api/utils.py

@@ -1,8 +1,14 @@
-from typing import Optional
-
-from slack import ROOT_URL
 from slack.exceptions import SlackAPIError
+from slack.methods import Methods
 from slack.io.abc import SlackAPI
+from slack import ROOT_URL
+from typing import Optional
+
+from pybot.endpoints.slack.utils import TICKET_CHANNEL
+from pybot.endpoints.slack.utils.action_messages import (
+    TICKET_OPTIONS,
+    not_claimed_attachment,
+)
 
 
 async def _slack_info_from_email(
@@ -15,3 +21,45 @@ async def _slack_info_from_email(
         return response["user"]
     except SlackAPIError:
         return fallback
+
+
+def invite_failure_attachments(email: str, error: str) -> list:
+    attachments = [
+        {
+            "text": "",
+            "callback_id": "ticket_status",
+            "response_type": "in_channel",
+            "fallback": "",
+            "fields": [
+                {"title": "Email", "value": f"{email}", "short": True},
+                {"title": "Error", "value": f"{error}", "short": True},
+            ],
+            "actions": [
+                {
+                    "name": "status",
+                    "text": "Current Status",
+                    "type": "select",
+                    "selected_options": [
+                        {"text": "Not Started", "value": "notStarted"}
+                    ],
+                    "options": [
+                        {"text": text, "value": value}
+                        for value, text in TICKET_OPTIONS.items()
+                    ],
+                }
+            ],
+        },
+        not_claimed_attachment(),
+    ]
+    return attachments
+
+
+async def handle_slack_invite_error(email, error, slack):
+    attachments = invite_failure_attachments(email, error)
+    response = {
+        "channel": TICKET_CHANNEL,
+        "attachments": attachments,
+        "text": "User Slack Invite Error",
+    }
+
+    return await slack.query(Methods.CHAT_POST_MESSAGE, response)

pybot/plugins/api/plugin.py

@@ -17,7 +17,12 @@ def __init__(self):
     def load(self, sirbot):
         self.session = sirbot.http_session
 
-        sirbot.router.add_route("GET", "/pybot/api/v1/slack/{resource}", endpoints.slack_api)
+        sirbot.router.add_route(
+            "GET", "/pybot/api/v1/slack/{resource}", endpoints.slack_api
+        )
+        sirbot.router.add_route(
+            "POST", "/pybot/api/v1/slack/{resource}", endpoints.slack_api
+        )
 
     def on_get(self, request, handler, **kwargs):
         if not asyncio.iscoroutinefunction(handler):

pybot/plugins/api/request.py

@@ -1,4 +1,5 @@
 import copy
+import json
 import os
 from typing import MutableMapping
 
@@ -29,13 +30,11 @@ def __init__(self, raw_request, resource, query):
     def authorized(self):
         return self.token is not None and self.token in self.auth_tokens
 
-    @staticmethod
-    def __get_token(raw_request):
-        if "Authorization" in raw_request.headers:
-            auth_header = raw_request.headers["Authorization"]
-            if auth_header.startswith("Bearer "):
-                return auth_header[7:]
-        return None
+    async def json(self):
+        if self.request.can_read_body:
+            return await self.request.json()
+        else:
+            return {}
 
     @classmethod
     def from_request(cls, raw_request):
@@ -44,6 +43,14 @@ def from_request(cls, raw_request):
 
         return cls(raw_request, resource, query)
 
+    @staticmethod
+    def __get_token(raw_request):
+        if "Authorization" in raw_request.headers:
+            auth_header = raw_request.headers["Authorization"]
+            if auth_header.startswith("Bearer "):
+                return auth_header[7:]
+        return None
+
     def __getitem__(self, item):
         return self.request[item]
 

tests/conftest.py

@@ -5,7 +5,7 @@
 from sirbot.plugins.slack import SlackPlugin
 
 from pybot import endpoints
-from pybot.plugins import AirtablePlugin
+from pybot.plugins import AirtablePlugin, APIPlugin
 from tests import data
 
 pytest_plugins = ("slack.tests.plugin",)
@@ -21,7 +21,7 @@ def action(request):
 
 
 @pytest.fixture
-def bot(loop) -> SirBot:
+async def bot(loop) -> SirBot:
     b = SirBot()
     slack = SlackPlugin(
         token="token",
@@ -31,8 +31,13 @@ def bot(loop) -> SirBot:
     )
     airtable = AirtablePlugin()
     endpoints.slack.create_endpoints(slack)
+
+    api = APIPlugin()
+    endpoints.api.create_endpoints(api)
+
     b.load_plugin(slack)
     b.load_plugin(airtable)
+    b.load_plugin(api)
 
     return b
 

tests/endpoints/__init__.py

@@ -0,0 +1,47 @@
+import json
+
+import pytest
+from asynctest import CoroutineMock
+from sirbot import SirBot
+
+MOCK_USER_NAME = "userName"
+MOCK_USER_ID = "U8N6XBL7Q"
+AUTH_HEADER = {"Authorization": "Bearer devBackendToken"}
+
+VALID_SLACK_RESPONSE = CoroutineMock(
+    return_value={"user": {"exists": True, "id": MOCK_USER_ID, "name": MOCK_USER_NAME}}
+)
+
+
+@pytest.mark.parametrize(
+    "headers, status",
+    [
+        ({"Authorization": "Bearer devBackendToken"}, 200),
+        ({"Authorization": "Bearer abc"}, 403),
+        (None, 403),
+    ],
+)
+async def test_detect_credentials(bot: SirBot, aiohttp_client, headers, status):
+    bot.plugins["slack"].api.query = VALID_SLACK_RESPONSE
+    client = await aiohttp_client(bot)
+
+    res = await client.get(
+        "/pybot/api/v1/slack/verify?email=test@test.test", headers=headers
+    )
+
+    assert res.status == status
+
+
+async def test_verify_returns_correct_success_params(bot: SirBot, aiohttp_client):
+    client = await aiohttp_client(bot)
+
+    bot.plugins["slack"].api.query = VALID_SLACK_RESPONSE
+
+    res = await client.get(
+        "/pybot/api/v1/slack/verify?email=test@test.test", headers=AUTH_HEADER
+    )
+    body = json.loads(await res.text())
+
+    assert body["exists"] is True
+    assert body["id"] == MOCK_USER_ID
+    assert body["displayName"] == MOCK_USER_NAME