Some style fixes pointed out by flake8

[turbot] / turbot_lambda / turbot_lambda.py

diff --git a/turbot_lambda/turbot_lambda.py b/turbot_lambda/turbot_lambda.py
index b34c6f7cd209100264b9429161b6461279007e28..80cc4d27a26bee30c7a8fbde7c90ecb80b88f541 100644 (file)
--- a/turbot_lambda/turbot_lambda.py
+++ b/turbot_lambda/turbot_lambda.py
@@ -1,15 +1,18 @@
 from urllib.parse import parse_qs
 from slack import WebClient
+import base64
 import boto3
 import requests
 import json
 import os
+import pickle
 from types import SimpleNamespace
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
 
 import turbot.actions
 import turbot.commands
 import turbot.events
-import turbot.views
 
 ssm = boto3.client('ssm')
 
@@ -24,11 +27,34 @@ response = ssm.get_parameter(Name='SLACK_BOT_TOKEN', WithDecryption=True)
 slack_bot_token = response['Parameter']['Value']
 slack_client = WebClient(slack_bot_token)
 
+response = ssm.get_parameter(Name='GSHEETS_PICKLE_BASE64', WithDecryption=True)
+gsheets_pickle_base64 = response['Parameter']['Value']
+gsheets_pickle = base64.b64decode(gsheets_pickle_base64)
+gsheets_creds = pickle.loads(gsheets_pickle)
+if gsheets_creds:
+    if gsheets_creds.valid:
+        print("Loaded valid GSheets credentials from SSM")
+    else:
+        gsheets_creds.refresh(Request())
+        gsheets_pickle = pickle.dumps(gsheets_creds)
+        gsheets_pickle_base64 = base64.b64encode(gsheets_pickle)
+        print("Storing refreshed GSheets credentials into SSM")
+        ssm.put_parameter(Name='GSHEETS_PICKLE_BASE64',
+                          Type='SecureString',
+                          Value=str(gsheets_pickle_base64),
+                          Overwrite=True)
+service = build('sheets',
+                'v4',
+                credentials=gsheets_creds,
+                cache_discovery=False)
+sheets = service.spreadsheets()
+
 db = boto3.resource('dynamodb')
 
 turb = SimpleNamespace()
 turb.slack_client = slack_client
 turb.db = db
+turb.sheets = sheets
 
 def error(message):
     """Generate an error response for a Slack request
@@ -72,12 +98,12 @@ def turbot_lambda(event, context):
     content_type = headers['content-type']
 
     if (content_type == "application/json"):
-        return turbot_event_handler(event, context)
+        return turbot_event_handler(turb, event, context)
     if (content_type == "application/x-www-form-urlencoded"):
-        return turbot_interactive_or_slash_command(event, context)
+        return turbot_interactive_or_slash_command(turb, event, context)
     return error("Unknown content-type: {}".format(content_type))
 
-def turbot_event_handler(event, context):
+def turbot_event_handler(turb, event, context):
     """Handler for all subscribed Slack events"""
 
     body = json.loads(event['body'])
@@ -85,12 +111,12 @@ def turbot_event_handler(event, context):
     type = body['type']
 
     if type == 'url_verification':
-        return url_verification_handler(body)
+        return url_verification_handler(turb, body)
     if type == 'event_callback':
-        return event_callback_handler(body)
+        return event_callback_handler(turb, body)
     return error("Unknown event type: {}".format(type))
 
-def url_verification_handler(body):
+def url_verification_handler(turb, body):
 
     # First, we have to properly respond to url_verification
     # challenges or else Slack won't let us configure our URL as an
@@ -102,14 +128,14 @@ def url_verification_handler(body):
         'body': challenge
     }
 
-def event_callback_handler(body):
+def event_callback_handler(turb, body):
     type = body['event']['type']
 
     if type in turbot.events.events:
         return turbot.events.events[type](turb, body)
     return error("Unknown event type: {}".format(type))
 
-def turbot_interactive_or_slash_command(event, context):
+def turbot_interactive_or_slash_command(turb, event, context):
     """Handler for Slack interactive things (buttons, shortcuts, etc.)
     as well as slash commands.
 
@@ -122,12 +148,12 @@ def turbot_interactive_or_slash_command(event, context):
     # The difference is that an interactive thingy has a 'payload'
     # while a slash command has a 'command'
     if 'payload' in body:
-        return turbot_interactive(json.loads(body['payload'][0]))
+        return turbot_interactive(turb, json.loads(body['payload'][0]))
     if 'command' in body:
-        return turbot_slash_command(body)
+        return turbot_slash_command(turb, body)
     return error("Unrecognized event (neither interactive nor slash command)")
 
-def turbot_interactive(payload):
+def turbot_interactive(turb, payload):
     """Handler for Slack interactive requests
 
     These are the things that come from a user interacting with a button
@@ -137,10 +163,12 @@ def turbot_interactive(payload):
     type = payload['type']
 
     if type == 'block_actions':
-        return turbot_block_action(payload)
+        return turbot_block_action(turb, payload)
+    if type == 'view_submission':
+        return turbot.actions.view_submission(turb, payload)
     return error("Unrecognized interactive type: {}".format(type))
 
-def turbot_block_action(payload):
+def turbot_block_action(turb, payload):
     """Handler for Slack interactive block actions
 
     Specifically, those that have a payload type of 'block_actions'"""
@@ -160,10 +188,10 @@ def turbot_block_action(payload):
             atype in turbot.actions.actions
             and avalue in turbot.actions.actions[atype]
     ):
-        return turbot.actions.actions[atype][avalue](payload)
+        return turbot.actions.actions[atype][avalue](turb, payload)
     return error("Unknown action of type/value: {}/{}".format(atype, avalue))
 
-def turbot_slash_command(body):
+def turbot_slash_command(turb, body):
     """Implementation for Slack slash commands.
 
     This parses the request and arguments and farms out to