[turbot] / turbot / interaction.py

from slack.errors import SlackApiError
from turbot.blocks import (
    input_block, section_block, text_block, multi_select_block, checkbox_block
)
from turbot.hunt import find_hunt_for_hunt_id, hunt_blocks
from turbot.puzzle import (
    find_puzzle_for_url,
    find_puzzle_for_puzzle_id,
    puzzle_update_channel_and_sheet,
    puzzle_id_from_name
)
import turbot.rot
import turbot.sheets
import turbot.slack
import json
import re
import requests
from botocore.exceptions import ClientError
from boto3.dynamodb.conditions import Key
from turbot.slack import slack_send_message
import shlex

actions = {}
actions['button'] = {}
commands = {}
submission_handlers = {}

# Hunt/Puzzle IDs are restricted to lowercase letters, numbers, and underscores
#
# Note: This restriction not only allows for hunt and puzzle ID values to
# be used as Slack channel names, but it also allows for '-' as a valid
# separator between a hunt and a puzzle ID (for example in the puzzle
# edit dialog where a single attribute must capture both values).
valid_id_re = r'^[_a-z0-9]+$'

lambda_ok = {'statusCode': 200}

def bot_reply(message):
    """Construct a return value suitable for a bot reply

    This is suitable as a way to give an error back to the user who
    initiated a slash command, for example."""

    return {
        'statusCode': 200,
        'body': message
    }

def submission_error(field, error):
    """Construct an error suitable for returning for an invalid submission.

    Returning this value will prevent a submission and alert the user that
    the given field is invalid because of the given error."""

    print("Rejecting invalid modal submission: {}".format(error))

    return {
        'statusCode': 200,
        'headers': {
            "Content-Type": "application/json"
        },
        'body': json.dumps({
            "response_action": "errors",
            "errors": {
                field: error
            }
        })
    }

def multi_static_select(turb, payload):
    """Handler for the action of user entering a multi-select value"""

    return lambda_ok

actions['multi_static_select'] = {"*": multi_static_select}

def edit_puzzle(turb, payload):
    """Handler for the action of user pressing an edit_puzzle button"""

    action_id = payload['actions'][0]['action_id']
    response_url = payload['response_url']
    trigger_id = payload['trigger_id']

    (hunt_id, puzzle_id) = action_id.split('-', 1)

    puzzle = find_puzzle_for_puzzle_id(turb, hunt_id, puzzle_id)

    if not puzzle:
        requests.post(response_url,
                      json = {"text": "Error: Puzzle not found!"},
                      headers = {"Content-type": "application/json"})
        return bot_reply("Error: Puzzle not found.")

    round_options = hunt_rounds(turb, hunt_id)

    if len(round_options):
        round_options_block = [
            multi_select_block("Round(s)", "rounds",
                               "Existing round(s) this puzzle belongs to",
                               round_options,
                               initial_options=puzzle.get("rounds", None)),
        ]
    else:
        round_options_block = []

    solved = False
    if puzzle.get("status", "unsolved") == solved:
        solved = True

    solution_str = None
    solution_list = puzzle.get("solution", [])
    if solution_list:
        solution_str = ", ".join(solution_list)

    view = {
        "type": "modal",
        "private_metadata": json.dumps({
            "hunt_id": hunt_id,
            "SK": puzzle["SK"],
            "puzzle_id": puzzle_id,
            "channel_id": puzzle["channel_id"],
            "channel_url": puzzle["channel_url"],
            "sheet_url": puzzle["sheet_url"],
        }),
        "title": {"type": "plain_text", "text": "Edit Puzzle"},
        "submit": { "type": "plain_text", "text": "Save" },
        "blocks": [
            input_block("Puzzle name", "name", "Name of the puzzle",
                        initial_value=puzzle["name"]),
            input_block("Puzzle URL", "url", "External URL of puzzle",
                        initial_value=puzzle.get("url", None),
                        optional=True),
            * round_options_block,
            input_block("New round(s)", "new_rounds",
                        "New round(s) this puzzle belongs to " +
                        "(comma separated)",
                        optional=True),
            input_block("State", "state",
                        "State of this puzzle (partial progress, next steps)",
                        initial_value=puzzle.get("state", None),
                        optional=True),
            checkbox_block(
                "Puzzle status", "Solved", "solved",
                checked=(puzzle.get('status', 'unsolved') == 'solved')),
            input_block("Solution", "solution",
                        "Solution(s) (comma-separated if multiple)",
                        initial_value=solution_str,
                        optional=True),
        ]
    }

    result = turb.slack_client.views_open(trigger_id=trigger_id,
                                          view=view)

    if (result['ok']):
        submission_handlers[result['view']['id']] = edit_puzzle_submission

    return lambda_ok

actions['button']['edit_puzzle'] = edit_puzzle

def edit_puzzle_submission(turb, payload, metadata):
    """Handler for the user submitting the edit puzzle modal

    This is the modal view presented to the user by the edit_puzzle
    function above.
    """

    puzzle={}

    # First, read all the various data from the request
    meta = json.loads(metadata)
    puzzle['hunt_id'] = meta['hunt_id']
    puzzle['SK'] = meta['SK']
    puzzle['puzzle_id'] = meta['puzzle_id']
    puzzle['channel_id'] = meta['channel_id']
    puzzle['channel_url'] = meta['channel_url']
    puzzle['sheet_url'] = meta['sheet_url']

    state = payload['view']['state']['values']

    puzzle['name'] = state['name']['name']['value']
    url = state['url']['url']['value']
    if url:
        puzzle['url'] = url
    rounds = [option['value'] for option in
              state['rounds']['rounds']['selected_options']]
    if rounds:
        puzzle['rounds'] = rounds
    new_rounds = state['new_rounds']['new_rounds']['value']
    puzzle_state = state['state']['state']['value']
    if puzzle_state:
        puzzle['state'] = puzzle_state
    if state['solved']['solved']['selected_options']:
        puzzle['status'] = 'solved'
    else:
        puzzle['status'] = 'unsolved'
    puzzle['solution'] = []
    solution = state['solution']['solution']['value']
    if solution:
        puzzle['solution'] = [
            sol.strip() for sol in solution.split(',')
        ]

    # Verify that there's a solution if the puzzle is mark solved
    if puzzle['status'] == 'solved' and not puzzle['solution']:
        return submission_error("solution",
                                "A solved puzzle requires a solution.")

    if puzzle['status'] == 'unsolved' and puzzle['solution']:
        return submission_error("solution",
                                "An unsolved puzzle should have no solution.")

    # Add any new rounds to the database
    if new_rounds:
        if 'rounds' not in puzzle:
            puzzle['rounds'] = []
        for round in new_rounds.split(','):
            # Drop any leading/trailing spaces from the round name
            round = round.strip()
            # Ignore any empty string
            if not len(round):
                continue
            puzzle['rounds'].append(round)
            turb.table.put_item(
                Item={
                    'hunt_id': puzzle['hunt_id'],
                    'SK': 'round-' + round
                }
            )

    # Update the puzzle in the database
    turb.table.put_item(Item=puzzle)

    # We need to set the channel topic if any of puzzle name, url,
    # state, status, or solution, has changed. Let's just do that
    # unconditionally here.
    puzzle_update_channel_and_sheet(turb, puzzle)

    return lambda_ok

def new_hunt(turb, payload):
    """Handler for the action of user pressing the new_hunt button"""

    view = {
        "type": "modal",
        "private_metadata": json.dumps({}),
        "title": { "type": "plain_text", "text": "New Hunt" },
        "submit": { "type": "plain_text", "text": "Create" },
        "blocks": [
            input_block("Hunt name", "name", "Name of the hunt"),
            input_block("Hunt ID", "hunt_id",
                        "Used as puzzle channel prefix "
                        + "(no spaces nor punctuation)"),
            input_block("Hunt URL", "url", "External URL of hunt",
                        optional=True)
        ],
    }

    result = turb.slack_client.views_open(trigger_id=payload['trigger_id'],
                                          view=view)
    if (result['ok']):
        submission_handlers[result['view']['id']] = new_hunt_submission

    return lambda_ok

actions['button']['new_hunt'] = new_hunt

def new_hunt_submission(turb, payload, metadata):
    """Handler for the user submitting the new hunt modal

    This is the modal view presented to the user by the new_hunt
    function above."""

    state = payload['view']['state']['values']
    user_id = payload['user']['id']
    name = state['name']['name']['value']
    hunt_id = state['hunt_id']['hunt_id']['value']
    url = state['url']['url']['value']

    # 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 lowercase letters, "
                                + "numbers, and underscores")

    # Check to see if the turbot table exists
    try:
        exists = turb.table.table_status in ("CREATING", "UPDATING",
                                             "ACTIVE")
    except ClientError:
        exists = False

    # Create the turbot table if necessary.
    if not exists:
        turb.table = turb.db.create_table(
            TableName='turbot',
            KeySchema=[
                {'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'},
                {'AttributeName': 'url', '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
                    }
                }
            ],
            LocalSecondaryIndexes = [
                {
                    'IndexName': 'url_index',
                    'KeySchema': [
                        {'AttributeName': 'hunt_id', 'KeyType': 'HASH'},
                        {'AttributeName': 'url', 'KeyType': 'RANGE'},
                    ],
                    'Projection': {
                        'ProjectionType': 'ALL'
                    }
                }
            ]
        )
        return submission_error(
            "hunt_id",
            "Still bootstrapping turbot table. Try again in a minute, please.")

    # Create a channel for the hunt
    try:
        response = turb.slack_client.conversations_create(name=hunt_id)
    except SlackApiError as e:
        return submission_error("hunt_id",
                                "Error creating Slack channel: {}"
                                .format(e.response['error']))

    channel_id = response['channel']['id']

    # 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)
    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 lambda_ok

def view_submission(turb, payload):
    """Handler for Slack interactive view submission

    Specifically, those that have a payload type of 'view_submission'"""

    view_id = payload['view']['id']
    metadata = payload['view']['private_metadata']

    if view_id in submission_handlers:
        return submission_handlers[view_id](turb, payload, metadata)

    print("Error: Unknown view ID: {}".format(view_id))
    return {
        'statusCode': 400
    }

def rot(turb, 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 = turbot.rot.rot(args)

    if (channel_name == "directmessage"):
        requests.post(response_url,
                      json = {"text": result},
                      headers = {"Content-type": "application/json"})
    else:
        turb.slack_client.chat_postMessage(channel=channel_id, text=result)

    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 db_entry_for_channel(turb, channel_id):
    """Given a channel ID return the database item for this channel

    If this channel is a registered hunt or puzzle channel, return the
    corresponding row from the database for this channel. Otherwise,
    return None.

    Note: If you need to specifically ensure that the channel is a
    puzzle or a hunt, please call puzzle_for_channel or
    hunt_for_channel respectively.
    """

    response = turb.table.query(
        IndexName = "channel_id_index",
        KeyConditionExpression=Key("channel_id").eq(channel_id)
    )

    if response['Count'] == 0:
        return None

    return response['Items'][0]


def puzzle_for_channel(turb, channel_id):

    """Given a channel ID return the puzzle from the database for this channel

    If the given channel_id is a puzzle's channel, this function
    returns a dict filled with the attributes from the puzzle's entry
    in the database.

    Otherwise, this function returns None.
    """

    entry = db_entry_for_channel(turb, channel_id)

    if entry and entry['SK'].startswith('puzzle-'):
        return entry
    else:
        return None

def hunt_for_channel(turb, channel_id):

    """Given a channel ID return the hunt from the database 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.).
    """

    entry = db_entry_for_channel(turb, channel_id)

    # We're done if this channel doesn't exist in the database at all
    if not entry:
        return None

    # Also done if this channel is a hunt channel
    if entry['SK'].startswith('hunt-'):
        return entry

    # Otherwise, (the channel is in the database, but is not a hunt),
    # we expect this to be a puzzle channel instead
    return find_hunt_for_hunt_id(turb, entry['hunt_id'])

# python3.9 has a built-in removeprefix but AWS only has python3.8
def remove_prefix(text, prefix):
    if text.startswith(prefix):
        return text[len(prefix):]
    return text

def hunt_rounds(turb, hunt_id):
    """Returns array of strings giving rounds that exist in the given hunt"""

    response = turb.table.query(
        KeyConditionExpression=(
            Key('hunt_id').eq(hunt_id) &
            Key('SK').begins_with('round-')
        )
    )

    if response['Count'] == 0:
        return []

    return [remove_prefix(option['SK'], 'round-')
            for option in response['Items']]

def puzzle(turb, body, args):
    """Implementation of the /puzzle command

    The args string is currently ignored (this command will bring up
    a modal dialog for user input instead)."""

    channel_id = body['channel_id'][0]
    trigger_id = body['trigger_id'][0]

    hunt = hunt_for_channel(turb, channel_id)

    if not hunt:
        return bot_reply("Sorry, this channel doesn't appear to "
                         + "be a hunt or puzzle channel")

    round_options = hunt_rounds(turb, hunt['hunt_id'])

    if len(round_options):
        round_options_block = [
            multi_select_block("Round(s)", "rounds",
                               "Existing round(s) this puzzle belongs to",
                               round_options)
        ]
    else:
        round_options_block = []

    view = {
        "type": "modal",
        "private_metadata": json.dumps({
            "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']))),
            input_block("Puzzle name", "name", "Name of the puzzle"),
            input_block("Puzzle URL", "url", "External URL of puzzle",
                        optional=True),
            * round_options_block,
            input_block("New round(s)", "new_rounds",
                        "New round(s) this puzzle belongs to " +
                        "(comma separated)",
                        optional=True)
        ]
    }

    result = turb.slack_client.views_open(trigger_id=trigger_id,
                                          view=view)

    if (result['ok']):
        submission_handlers[result['view']['id']] = puzzle_submission

    return lambda_ok

commands["/puzzle"] = puzzle

def puzzle_submission(turb, payload, metadata):
    """Handler for the user submitting the new puzzle modal

    This is the modal view presented to the user by the puzzle function
    above."""

    # First, read all the various data from the request
    meta = json.loads(metadata)
    hunt_id = meta['hunt_id']

    state = payload['view']['state']['values']
    name = state['name']['name']['value']
    url = state['url']['url']['value']
    if 'rounds' in state:
        rounds = [option['value'] for option in
                  state['rounds']['rounds']['selected_options']]
    else:
        rounds = []
    new_rounds = state['new_rounds']['new_rounds']['value']

    # Before doing anything, reject this puzzle if a puzzle already
    # exists with the same URL.
    if url:
        existing = find_puzzle_for_url(turb, hunt_id, url)
        if existing:
            return submission_error(
                "url",
                "Error: A puzzle with this URL already exists.")

    # Create a Slack-channel-safe puzzle_id
    puzzle_id = puzzle_id_from_name(name)

    # Create a channel for the puzzle
    hunt_dash_channel = "{}-{}".format(hunt_id, puzzle_id)

    try:
        response = turb.slack_client.conversations_create(
            name=hunt_dash_channel)
    except SlackApiError as e:
        return submission_error(
            "name",
            "Error creating Slack channel {}: {}"
            .format(hunt_dash_channel, e.response['error']))

    channel_id = response['channel']['id']

    # Add any new rounds to the database
    if new_rounds:
        for round in new_rounds.split(','):
            # Drop any leading/trailing spaces from the round name
            round = round.strip()
            # Ignore any empty string
            if not len(round):
                continue
            rounds.append(round)
            turb.table.put_item(
                Item={
                    'hunt_id': hunt_id,
                    'SK': 'round-' + round
                }
            )

    # Insert the newly-created puzzle into the database
    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
    if rounds:
        item['rounds'] = rounds
    turb.table.put_item(Item=item)

    return lambda_ok

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]

    puzzle = puzzle_for_channel(turb, channel_id)

    if not puzzle:
        return bot_reply(
            "Sorry, the /state command only works in a puzzle channel")

    # Set the state field in the database
    puzzle['state'] = args
    turb.table.put_item(Item=puzzle)

    puzzle_update_channel_and_sheet(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]
    user_name = body['user_name'][0]

    puzzle = puzzle_for_channel(turb, channel_id)

    if not puzzle:
        return bot_reply("Sorry, this is not a puzzle channel.")

    if not args:
        return bot_reply(
            "Error, no solution provided. Usage: `/solved SOLUTION HERE`")

    # Set the status and solution fields in the database
    puzzle['status'] = 'solved'
    puzzle['solution'].append(args)
    if 'state' in puzzle:
        del puzzle['state']
    turb.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'])
    )

    # And update the puzzle's description
    puzzle_update_channel_and_sheet(turb, puzzle)

    return lambda_ok

commands["/solved"] = solved


def hunt(turb, body, args):
    """Implementation of the /hunt command

    The (optional) args string can be used to filter which puzzles to
    display. The first word can be one of 'all', 'unsolved', or
    'solved' and can be used to display only puzzles with the given
    status. Any remaining text in the args string will be interpreted
    as search terms. These will be split into separate terms on space
    characters, (though quotation marks can be used to include a space
    character in a term). All terms must match on a puzzle in order
    for that puzzle to be included. But a puzzle will be considered to
    match if any of the puzzle title, round title, puzzle URL, puzzle
    state, or puzzle solution match. Matching will be performed
    without regard to case sensitivity and the search terms can
    include regular expression syntax.
    """

    channel_id = body['channel_id'][0]
    response_url = body['response_url'][0]

    terms = None
    if args:
        # The first word can be a puzzle status and all remaining word
        # (if any) are search terms. _But_, if the first word is not a
        # valid puzzle status ('all', 'unsolved', 'solved'), then all
        # words are search terms and we default status to 'unsolved'.
        split_args = args.split(' ', 1)
        status = split_args[0]
        if (len(split_args) > 1):
            terms = split_args[1]
        if status not in ('unsolved', 'solved', 'all'):
            terms = args
            status = 'unsolved'
    else:
        status = 'unsolved'

    # Separate search terms on spaces (but allow for quotation marks
    # to capture spaces in a search term)
    if terms:
        terms = shlex.split(terms)

    hunt = hunt_for_channel(turb, channel_id)

    if not hunt:
        return bot_reply("Sorry, this channel doesn't appear to "
                         + "be a hunt or puzzle channel")

    blocks = hunt_blocks(turb, hunt, puzzle_status=status, search_terms=terms)

    requests.post(response_url,
                  json = { 'blocks': blocks },
                  headers = {'Content-type': 'application/json'}
                  )

    return lambda_ok

commands["/hunt"] = hunt