Update tests

Author: AllenAnthes

Pipfile.lock

@@ -10,7 +10,7 @@
 
 from pybot.endpoints import handle_health_check
 from . import endpoints
-from .plugins import AirtablePlugin
+from .plugins import AirtablePlugin, APIPlugin
 from pybot.endpoints.slack.utils import PORT, HOST
 from pybot.endpoints.slack.utils import slack_configs
 
@@ -50,10 +50,19 @@ def make_sentry_logger():
     endpoints.slack.create_endpoints(slack)
     bot.load_plugin(slack)
 
+    admin_configs = dict(**slack_configs)
+    admin_configs["token"] = os.environ.get("APP_ADMIN_OAUTH_TOKEN")
+    admin_slack = SlackPlugin(**admin_configs)
+    bot.load_plugin(admin_slack, name="admin_slack")
+
     airtable = AirtablePlugin()
     endpoints.airtable.create_endpoints(airtable)
     bot.load_plugin(airtable)
 
+    api_plugin = APIPlugin()
+    endpoints.api.create_endpoints(api_plugin)
+    bot.load_plugin(api_plugin)
+
     # Add route to respond to AWS health check
     bot.router.add_get("/health", handle_health_check)
     logging.getLogger("aiohttp.access").setLevel(logging.WARNING)

pybot/__main__.py

@@ -1,6 +1,6 @@
 from aiohttp.web_response import Response
 
-from . import slack, airtable
+from . import slack, airtable, api
 
 
 async def handle_health_check(request):

pybot/endpoints/__init__.py

@@ -0,0 +1,5 @@
+from . import slack_api
+
+
+def create_endpoints(plugin):
+    slack_api.create_endpoints(plugin)

pybot/endpoints/api/__init__.py

@@ -0,0 +1,52 @@
+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
+
+logger = logging.getLogger(__name__)
+
+
+def create_endpoints(plugin):
+    plugin.on_get("verify", verify, wait=True)
+    plugin.on_get("invite", invite, wait=True)
+
+
+async def verify(request: Request, app: SirBot) -> any:
+    """
+    Verifies whether a user exists in the configured slack group with
+    the given email
+
+    :return: The user's slack id and displayName if they exist
+    """
+    slack = app.plugins["slack"].api
+    email = request.query["email"]
+
+    user = await _slack_info_from_email(email, slack)
+    if user:
+        return {"exists": True, "id": user["id"], "displayName": user["name"]}
+    return {"exists": False}
+
+
+async def invite(request: Request, 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"]
+
+        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

pybot/endpoints/api/slack_api.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from slack import ROOT_URL
+from slack.exceptions import SlackAPIError
+from slack.io.abc import SlackAPI
+
+
+async def _slack_info_from_email(
+    email: str, slack: SlackAPI, fallback: Optional[str] = None
+):
+    try:
+        response = await slack.query(
+            url=ROOT_URL + "users.lookupByEmail", data={"email": email}
+        )
+        return response["user"]
+    except SlackAPIError:
+        return fallback

pybot/endpoints/api/utils.py

@@ -1 +1,2 @@
 from .airtable import AirtablePlugin
+from .api import APIPlugin

pybot/plugins/__init__.py

@@ -0,0 +1 @@
+from .plugin import APIPlugin

pybot/plugins/api/__init__.py

@@ -0,0 +1,53 @@
+import asyncio
+import json
+import logging
+
+from aiohttp.web_response import Response
+
+from pybot.plugins.api.request import SlackApiRequest
+
+logger = logging.getLogger(__name__)
+
+
+async def slack_api(request):
+    api_plugin = request.app.plugins["api"]
+    slack_request = SlackApiRequest.from_request(request)
+
+    if not slack_request.authorized:
+        logger.info(
+            f"Received unauthorized request Request: {slack_request} Token: {slack_request.token}"
+        )
+        return Response(status=403)
+
+    futures = list(_dispatch(api_plugin.routers["slack"], slack_request, request.app))
+
+    if futures:
+        return await _wait_and_check_result(futures)
+    return Response(status=200)
+
+
+def _dispatch(router, event, app):
+    for handler, configuration in router.dispatch(event):
+        f = asyncio.ensure_future(handler(event, app))
+        yield f
+
+
+async def _wait_and_check_result(futures):
+    dones, _ = await asyncio.wait(futures, return_when=asyncio.ALL_COMPLETED)
+    try:
+        results = [done.result() for done in dones]
+    except Exception as e:
+        logger.exception(e)
+        return Response(status=500)
+
+    if len(results) > 1:
+        logger.warning("Multiple web.Response for handler, returning none")
+
+    elif results:
+        result = (
+            results[0]
+            if isinstance(results[0], Response)
+            else Response(body=json.dumps(results[0]))
+        )
+
+        return result

pybot/plugins/api/endpoints.py

@@ -0,0 +1,44 @@
+import asyncio
+from collections import defaultdict
+import logging
+
+from pybot.plugins.api import endpoints
+
+logger = logging.getLogger(__name__)
+
+
+class APIPlugin:
+    __name__ = "api"
+
+    def __init__(self):
+        self.session = None
+        self.routers = {"slack": SlackAPIRequestRouter()}
+
+    def load(self, sirbot):
+        self.session = sirbot.http_session
+
+        sirbot.router.add_route("GET", "/api/v1/slack/{resource}", endpoints.slack_api)
+
+    def on_get(self, request, handler, **kwargs):
+        if not asyncio.iscoroutinefunction(handler):
+            handler = asyncio.coroutine(handler)
+        options = {**kwargs, "wait": False}
+        self.routers["slack"].register(request, (handler, options))
+
+
+class SlackAPIRequestRouter:
+    def __init__(self):
+        self._routes = defaultdict(list)
+
+    def register(self, resource, handler, **detail):
+        logger.info(f"Registering {resource}, {detail} to {handler}")
+        self._routes[resource].append(handler)
+
+    def dispatch(self, request):
+        resource = request.resource
+        logger.debug(f"Dispatching request {resource}")
+        if resource in self._routes:
+            for handler in self._routes.get(resource):
+                yield handler
+        else:
+            return