X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=turbot%2Finteraction.py;h=b6fa7d7e12efc8cfd5c4809d3ea5ee91ef98413b;hb=ef8d8f359be149adbbdbeda88ec4b6bbbebf928e;hp=3bdd794b8b457e5a8190928cc669a47ac43042ee;hpb=8222f54de4a0b5c03c959b9b66c7ee9436506154;p=turbot diff --git a/turbot/interaction.py b/turbot/interaction.py index 3bdd794..b6fa7d7 100644 --- a/turbot/interaction.py +++ b/turbot/interaction.py @@ -1,5 +1,6 @@ from slack.errors import SlackApiError from turbot.blocks import input_block, section_block, text_block +from turbot.hunt import find_hunt_for_hunt_id import turbot.rot import turbot.sheets import turbot.slack @@ -7,13 +8,17 @@ import json import re import requests from botocore.exceptions import ClientError +from boto3.dynamodb.conditions import Key +from turbot.slack import slack_send_message actions = {} commands = {} submission_handlers = {} -# Hunt and Puzzle IDs are restricted to letters, numbers, and underscores -valid_id_re = r'^[_a-zA-Z0-9]+$' +# Hunt/Puzzle IDs are restricted to lowercase letters, numbers, and underscores +valid_id_re = r'^[_a-z0-9]+$' + +lambda_ok = {'statusCode': 200} def bot_reply(message): """Construct a return value suitable for a bot reply @@ -70,10 +75,7 @@ def new_hunt(turb, payload): if (result['ok']): submission_handlers[result['view']['id']] = new_hunt_submission - return { - 'statusCode': 200, - 'body': 'OK' - } + return lambda_ok actions['button'] = {"new_hunt": new_hunt} @@ -92,35 +94,66 @@ def new_hunt_submission(turb, payload, metadata): # Validate that the hunt_id contains no invalid characters if not re.match(valid_id_re, hunt_id): return submission_error("hunt_id", - "Hunt ID can only contain letters, " + "Hunt ID can only contain lowercase letters, " + "numbers, and underscores") - # Check to see if the hunts table exists - hunts_table = turb.db.Table("hunts") - + # Check to see if the turbot table exists try: - exists = hunts_table.table_status in ("CREATING", "UPDATING", - "ACTIVE") + exists = turb.table.table_status in ("CREATING", "UPDATING", + "ACTIVE") except ClientError: exists = False - # Create the hunts table if necessary. + # Create the turbot table if necessary. if not exists: - hunts_table = turb.db.create_table( - TableName='hunts', + turb.table = turb.db.create_table( + TableName='turbot', KeySchema=[ - {'AttributeName': 'channel_id', 'KeyType': 'HASH'}, + {'AttributeName': 'hunt_id', 'KeyType': 'HASH'}, + {'AttributeName': 'SK', 'KeyType': 'RANGE'}, ], AttributeDefinitions=[ + {'AttributeName': 'hunt_id', 'AttributeType': 'S'}, + {'AttributeName': 'SK', 'AttributeType': 'S'}, {'AttributeName': 'channel_id', 'AttributeType': 'S'}, + {'AttributeName': 'is_hunt', 'AttributeType': 'S'}, ], ProvisionedThroughput={ 'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5 - } + }, + GlobalSecondaryIndexes=[ + { + 'IndexName': 'channel_id_index', + 'KeySchema': [ + {'AttributeName': 'channel_id', 'KeyType': 'HASH'} + ], + 'Projection': { + 'ProjectionType': 'ALL' + }, + 'ProvisionedThroughput': { + 'ReadCapacityUnits': 5, + 'WriteCapacityUnits': 5 + } + }, + { + 'IndexName': 'is_hunt_index', + 'KeySchema': [ + {'AttributeName': 'is_hunt', 'KeyType': 'HASH'} + ], + 'Projection': { + 'ProjectionType': 'ALL' + }, + 'ProvisionedThroughput': { + 'ReadCapacityUnits': 5, + 'WriteCapacityUnits': 5 + } + } + ] ) - return submission_error("hunt_id", - "Still bootstrapping hunts table. Try again.") + return submission_error( + "hunt_id", + "Still bootstrapping turbot table. Try again in a minute, please.") # Create a channel for the hunt try: @@ -135,22 +168,22 @@ def new_hunt_submission(turb, payload, metadata): # Insert the newly-created hunt into the database # (leaving it as non-active for now until the channel-created handler # finishes fixing it up with a sheet and a companion table) - hunts_table.put_item( - Item={ - 'channel_id': channel_id, - "active": False, - "name": name, - "hunt_id": hunt_id, - "url": url - } - ) + item={ + "hunt_id": hunt_id, + "SK": "hunt-{}".format(hunt_id), + "is_hunt": hunt_id, + "channel_id": channel_id, + "active": False, + "name": name, + } + if url: + item['url'] = url + turb.table.put_item(Item=item) # Invite the initiating user to the channel turb.slack_client.conversations_invite(channel=channel_id, users=user_id) - return { - 'statusCode': 200, - } + return lambda_ok def view_submission(turb, payload): """Handler for Slack interactive view submission @@ -198,13 +231,85 @@ def rot(turb, body, args): else: turb.slack_client.chat_postMessage(channel=channel_id, text=result) - return { - 'statusCode': 200, - 'body': "" - } + return lambda_ok commands["/rot"] = rot +def get_table_item(turb, table_name, key, value): + """Get an item from the database 'table_name' with 'key' as 'value' + + Returns a tuple of (item, table) if found and (None, None) otherwise.""" + + table = turb.db.Table(table_name) + + response = table.get_item(Key={key: value}) + + if 'Item' in response: + return (response['Item'], table) + else: + return (None, None) + +def channel_is_puzzle(turb, channel_id, channel_name): + """Given a channel ID/name return the database item for the puzzle + + If this channel is a puzzle, this function returns a tuple: + + (puzzle, table) + + Where puzzle is dict filled with database entries, and table is a + database table that can be used to update the puzzle in the + database. + + Otherwise, this function returns (None, None).""" + + hunt_id = channel_name.split('-')[0] + + # Not a puzzle channel if there is no hyphen in the name + if hunt_id == channel_name: + return (None, None) + + return get_table_item(turb, hunt_id, 'channel_id', channel_id) + +def channel_is_hunt(turb, channel_id): + + """Given a channel ID/name return the database item for the hunt + + Returns a dict (filled with database entries) if there is a hunt + for this channel, otherwise returns None.""" + + response = turb.table.query( + IndexName = "channel_id_index", + KeyConditionExpression=Key("channel_id").eq(channel_id) + ) + + if 'Items' not in response: + return None + + return response['Items'][0] + +def find_hunt_for_channel(turb, channel_id, channel_name): + """Given a channel ID/name find the id/name of the hunt for this channel + + This works whether the original channel is a primary hunt channel, + or if it is one of the channels of a puzzle belonging to the hunt. + + Returns None if channel does not belong to a hunt, otherwise a + dictionary with all fields from the hunt's row in the table, + (channel_id, active, hunt_id, name, url, sheet_url, etc.). + + """ + + hunt = channel_is_hunt(turb, channel_id) + + if hunt: + return hunt + + # So we're not a hunt channel, let's look to see if we are a + # puzzle channel with a hunt-id prefix. + hunt_id = channel_name.split('-')[0] + + return find_hunt_for_hunt_id(turb, hunt_id) + def puzzle(turb, body, args): """Implementation of the /puzzle command @@ -212,32 +317,27 @@ def puzzle(turb, body, args): a modal dialog for user input instead).""" channel_id = body['channel_id'][0] + channel_name = body['channel_name'][0] trigger_id = body['trigger_id'][0] - hunts_table = turb.db.Table("hunts") - response = hunts_table.get_item(Key={'channel_id': channel_id}) + hunt = find_hunt_for_channel(turb, + channel_id, + channel_name) - if 'Item' in response: - hunt_name = response['Item']['name'] - hunt_id = response['Item']['hunt_id'] - else: + if not hunt: return bot_reply("Sorry, this channel doesn't appear to " - + "be a hunt channel") + + "be a hunt or puzzle channel") view = { "type": "modal", "private_metadata": json.dumps({ - "hunt_id": hunt_id, - "hunt_channel_id": channel_id + "hunt_id": hunt['hunt_id'], }), "title": {"type": "plain_text", "text": "New Puzzle"}, "submit": { "type": "plain_text", "text": "Create" }, "blocks": [ - section_block(text_block("*For {}*".format(hunt_name))), + section_block(text_block("*For {}*".format(hunt['name']))), input_block("Puzzle name", "name", "Name of the puzzle"), - input_block("Puzzle ID", "puzzle_id", - "Used as part of channel name " - + "(no spaces nor punctuation)"), input_block("Puzzle URL", "url", "External URL of puzzle", optional=True) ] @@ -249,9 +349,7 @@ def puzzle(turb, body, args): if (result['ok']): submission_handlers[result['view']['id']] = puzzle_submission - return { - 'statusCode': 200 - } + return lambda_ok commands["/puzzle"] = puzzle @@ -263,18 +361,13 @@ def puzzle_submission(turb, payload, metadata): meta = json.loads(metadata) hunt_id = meta['hunt_id'] - hunt_channel_id = meta['hunt_channel_id'] state = payload['view']['state']['values'] name = state['name']['name']['value'] - puzzle_id = state['puzzle_id']['puzzle_id']['value'] url = state['url']['url']['value'] - # Validate that the puzzle_id contains no invalid characters - if not re.match(valid_id_re, puzzle_id): - return submission_error("puzzle_id", - "Puzzle ID can only contain letters, " - + "numbers, and underscores") + # Create a Slack-channel-safe puzzle_id + puzzle_id = re.sub(r'[^a-zA-Z0-9_]', '', name).lower() # Create a channel for the puzzle hunt_dash_channel = "{}-{}".format(hunt_id, puzzle_id) @@ -283,25 +376,132 @@ def puzzle_submission(turb, payload, metadata): response = turb.slack_client.conversations_create( name=hunt_dash_channel) except SlackApiError as e: - return submission_error("puzzle_id", - "Error creating Slack channel: {}" - .format(e.response['error'])) + return submission_error( + "name", + "Error creating Slack channel {}: {}" + .format(hunt_dash_channel, e.response['error'])) - puzzle_channel_id = response['channel']['id'] + channel_id = response['channel']['id'] # Insert the newly-created puzzle into the database - table = turb.db.Table(hunt_id) - table.put_item( - Item={ - "channel_id": puzzle_channel_id, - "solution": [], - "status": 'unsolved', - "name": name, - "puzzle_id": puzzle_id, - "url": url, - } + item={ + "hunt_id": hunt_id, + "SK": "puzzle-{}".format(puzzle_id), + "puzzle_id": puzzle_id, + "channel_id": channel_id, + "solution": [], + "status": 'unsolved', + "name": name, + } + if url: + item['url'] = url + turb.table.put_item(Item=item) + + return lambda_ok + +# XXX: This duplicates functionality eith events.py:set_channel_description +def set_channel_topic(turb, puzzle): + channel_id = puzzle['channel_id'] + name = puzzle['name'] + url = puzzle.get('url', None) + sheet_url = puzzle.get('sheet_url', None) + state = puzzle.get('state', None) + status = puzzle['status'] + + description = '' + + if status == 'solved': + description += "SOLVED: `{}` ".format('`, `'.join(puzzle['solution'])) + + description += name + + links = [] + if url: + links.append("<{}|Puzzle>".format(url)) + if sheet_url: + links.append("<{}|Sheet>".format(sheet_url)) + + if len(links): + description += "({})".format(', '.join(links)) + + if state: + description += " {}".format(state) + + turb.slack_client.conversations_setTopic(channel=channel_id, + topic=description) + +def state(turb, body, args): + """Implementation of the /state command + + The args string should be a brief sentence describing where things + stand or what's needed.""" + + channel_id = body['channel_id'][0] + channel_name = body['channel_name'][0] + + (puzzle, table) = channel_is_puzzle(turb, channel_id, channel_name) + + if not puzzle: + return bot_reply("Sorry, this is not a puzzle channel.") + + # Set the state field in the database + puzzle['state'] = args + table.put_item(Item=puzzle) + + set_channel_topic(turb, puzzle) + + return lambda_ok + +commands["/state"] = state + +def solved(turb, body, args): + """Implementation of the /solved command + + The args string should be a confirmed solution.""" + + channel_id = body['channel_id'][0] + channel_name = body['channel_name'][0] + user_name = body['user_name'][0] + + (puzzle, table) = channel_is_puzzle(turb, channel_id, channel_name) + + if not puzzle: + return bot_reply("Sorry, this is not a puzzle channel.") + + # Set the status and solution fields in the database + puzzle['status'] = 'solved' + puzzle['solution'].append(args) + table.put_item(Item=puzzle) + + # Report the solution to the puzzle's channel + slack_send_message( + turb.slack_client, channel_id, + "Puzzle mark solved by {}: `{}`".format(user_name, args)) + + # Also report the solution to the hunt channel + hunt = find_hunt_for_hunt_id(turb, puzzle['hunt_id']) + slack_send_message( + turb.slack_client, hunt['channel_id'], + "Puzzle <{}|{}> has been solved!".format( + puzzle['channel_url'], + puzzle['name']) ) - return { - 'statusCode': 200 - } + # And update the puzzle's description + set_channel_topic(turb, puzzle) + + # And rename the sheet to prefix with "SOLVED: " + turbot.sheets.renameSheet(turb, puzzle['sheet_url'], + 'SOLVED: ' + puzzle['name']) + + # Finally, rename the Slack channel to add the suffix '-solved' + channel_name = "{}-{}-solved".format( + puzzle['hunt_id'], + puzzle['puzzle_id']) + turb.slack_client.conversations_rename( + channel=puzzle['channel_id'], + name=channel_name) + + return lambda_ok + +commands["/solved"] = solved