Move rot function down into turbot/commands.py

[turbot] / turbot_lambda / turbot_lambda.py

diff --git a/turbot_lambda/turbot_lambda.py b/turbot_lambda/turbot_lambda.py
index ba8d06db20c66e4ada2d8a0dabc1279ecea4dd4d..be8e099b5b2c25de64d052e77d8f9a6fa80ff739 100644 (file)
--- a/turbot_lambda/turbot_lambda.py
+++ b/turbot_lambda/turbot_lambda.py
@@ -1,17 +1,23 @@
 from urllib.parse import parse_qs
-from turbot.rot import rot
-from turbot import views
 from slack import WebClient
 import boto3
 import requests
-import hashlib
-import hmac
 import json
+import os
+
+import turbot.actions
+import turbot.commands
+import turbot.events
+import turbot.views
 
 ssm = boto3.client('ssm')
 
 response = ssm.get_parameter(Name='SLACK_SIGNING_SECRET', WithDecryption=True)
-slack_signing_secret = bytes(response['Parameter']['Value'], 'utf-8')
+slack_signing_secret = response['Parameter']['Value']
+os.environ['SLACK_SIGNING_SECRET'] = slack_signing_secret
+
+# Note: Late import here to have the environment variable above available
+from turbot.slack import slack_is_valid_request # noqa
 
 response = ssm.get_parameter(Name='SLACK_BOT_TOKEN', WithDecryption=True)
 slack_bot_token = response['Parameter']['Value']
@@ -31,24 +37,6 @@ def error(message):
         'body': ''
     }
 
-def slack_is_valid_request(slack_signature, timestamp, body):
-    """Returns True if the timestamp and body correspond to signature.
-
-    This implements the Slack signature verification using the slack
-    signing secret (obtained via an SSM parameter in code above)."""
-
-    content = "v0:{}:{}".format(timestamp,body).encode('utf-8')
-
-    signature = 'v0=' + hmac.new(slack_signing_secret,
-                                 content,
-                                 hashlib.sha256).hexdigest()
-
-    if hmac.compare_digest(signature, slack_signature):
-        return True
-    else:
-        print("Bad signature: {} != {}".format(signature, slack_signature))
-        return False
-
 def turbot_lambda(event, context):
     """Top-level entry point for our lambda function.
 
@@ -111,15 +99,9 @@ def event_callback_handler(body):
     type = body['event']['type']
 
     if type == 'app_home_opened':
-        return app_home_opened_handler(body)
+        return turbot.events.app_home_opened(slack_client, body)
     return error("Unknown event type: {}".format(type))
 
-def app_home_opened_handler(body):
-    user_id = body['event']['user']
-    view = views.home(user_id, body)
-    slack_client.views_publish(user_id=user_id, view=view)
-    return "OK"
-
 def turbot_interactive_or_slash_command(event, context):
     """Handler for Slack interactive things (buttons, shortcuts, etc.)
     as well as slash commands.
@@ -145,7 +127,31 @@ def turbot_interactive(payload):
     a shortcut or some other interactive element that our app has made
     available to the user."""
 
-    print("In turbot_interactive, payload is: {}".format(str(payload)))
+    type = payload['type']
+
+    if type == 'block_actions':
+        return turbot_block_action(payload)
+    return error("Unrecognized interactive type: {}".format(type))
+
+def turbot_block_action(payload):
+    """Handler for Slack interactive block actions
+
+    Specifically, those that have a payload type of 'block_actions'"""
+
+    actions = payload['actions']
+
+    if len(actions) != 1:
+        return error("No support for multiple actions ({}) in a single request"
+                     .format(len(actions)))
+
+    action = actions[0]
+
+    atype = action['type']
+    avalue = action['value']
+
+    if atype == 'button' and avalue == 'new_hunt':
+        return turbot.actions.new_hunt(payload)
+    return error("Unknown action of type/value: {}/{}".format(atype, avalue))
 
 def turbot_slash_command(body):
     """Implementation for Slack slash commands.
@@ -158,41 +164,6 @@ def turbot_slash_command(body):
     args = body['text'][0]
 
     if (command == "/rotlambda" or command == "/rot"):
-        return rot_slash_command(body, args)
+        return turbot.commands.rot(slack_client, body, args)
 
     return error("Command {} not implemented".format(command))
-
-def rot_slash_command(body, args):
-    """Implementation of the /rot command
-
-    The args string should be as follows:
-
-        [count|*] String to be rotated
-
-    That is, the first word of the string is an optional number (or
-    the character '*'). If this is a number it indicates an amount to
-    rotate each character in the string. If the count is '*' or is not
-    present, then the string will be rotated through all possible 25
-    values.
-
-    The result of the rotation is returned (with Slack formatting) in
-    the body of the response so that Slack will provide it as a reply
-    to the user who submitted the slash command."""
-
-    channel_name = body['channel_name'][0]
-    response_url = body['response_url'][0]
-    channel_id = body['channel_id'][0]
-
-    result = rot(args)
-
-    if (channel_name == "directmessage"):
-        requests.post(response_url,
-                      json = {"text": result},
-                      headers = {"Content-type": "application/json"})
-    else:
-        slack_client.chat_postMessage(channel=channel_id, text=result)
-
-    return {
-        'statusCode': 200,
-        'body': ""
-    }