X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=turbot%2Finteraction.py;h=94787b40fbc28e15c7773f0ca497b5dcf4bea1b9;hb=c6ad0733c2613b899a30291b14222ef6c322c6cb;hp=4e626f39fc0c7adc4ec2a3be32c63d9aec632216;hpb=1b5f5fe117c987ddb6cb446efea31b179f9a5c79;p=turbot

diff --git a/turbot/interaction.py b/turbot/interaction.py
index 4e626f3..94787b4 100644
--- a/turbot/interaction.py
+++ b/turbot/interaction.py
@@ -1,5 +1,26 @@
 from slack.errors import SlackApiError
-from turbot.blocks import input_block, section_block, text_block
+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,
+    hunt_puzzles_for_hunt_id
+)
+from turbot.puzzle import (
+    find_puzzle_for_url,
+    find_puzzle_for_sort_key,
+    find_puzzle_for_puzzle_id,
+    puzzle_update_channel_and_sheet,
+    puzzle_channel_name,
+    puzzle_id_from_name,
+    puzzle_blocks,
+    puzzle_sort_key,
+    puzzle_copy
+)
+from turbot.round import round_quoted_puzzles_titles_answers
+from turbot.help import turbot_help
+from turbot.have_you_tried import have_you_tried
 import turbot.rot
 import turbot.sheets
 import turbot.slack
@@ -7,13 +28,24 @@ 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 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
+#
+# 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
@@ -47,9 +79,439 @@ def submission_error(field, error):
         })
     }
 
-def new_hunt(turb, payload):
+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(turb, body, args):
+
+    """Implementation of the `/edit` command
+
+    This can be used as `/edit` (with no arguments) in either a hunt
+    or a puzzle channel to edit that hunt or puzzle. It can also be
+    called explicitly as `/edit hunt` to edit a hunt even from a
+    puzzle channel.
+
+    In any case, the operation is identical to `/hunt edit` or
+    `/puzzle edit`.
+    """
+
+    # If we have an explicit argument, do what it says to do
+    if args == "hunt":
+        return edit_hunt_command(turb, body)
+
+    if args == "puzzle":
+        return edit_puzzle_command(turb, body)
+
+    # Any other argument string is an error
+    if args:
+        return bot_reply("Error: Unexpected argument: {}\n".format(args) +
+                         "Usage: `/edit puzzle`, `/edit hunt`, or " +
+                         "`/edit` (to choose based on channel)"
+                         )
+
+    # No explicit argument, so select what to edit based on the current channel
+    channel_id = body['channel_id'][0]
+    trigger_id = body['trigger_id'][0]
+
+    puzzle = puzzle_for_channel(turb, channel_id)
+    if puzzle:
+        return edit_puzzle(turb, puzzle, trigger_id)
+
+    hunt = hunt_for_channel(turb, channel_id)
+    if hunt:
+        return edit_hunt(turb, hunt, trigger_id)
+
+    return bot_reply("Sorry, `/edit` only works in a hunt or puzzle channel.")
+
+commands["/edit"] = edit
+
+
+def edit_puzzle_command(turb, body):
+    """Implementation of the `/puzzle edit` command
+
+    As dispatched from the puzzle() function.
+    """
+
+    channel_id = body['channel_id'][0]
+    trigger_id = body['trigger_id'][0]
+
+    puzzle = puzzle_for_channel(turb, channel_id)
+
+    if not puzzle:
+        return bot_reply("Sorry, this does not appear to be a puzzle channel.")
+
+    return edit_puzzle(turb, puzzle, trigger_id)
+
+def edit_puzzle_button(turb, payload):
+    """Handler for the action of user pressing an edit_puzzle button"""
+
+    action_id = payload['actions'][0]['action_id']
+    trigger_id = payload['trigger_id']
+
+    (hunt_id, sort_key) = action_id.split('-', 1)
+
+    puzzle = find_puzzle_for_sort_key(turb, hunt_id, sort_key)
+
+    if not puzzle:
+        return bot_reply("Error: Puzzle not found.")
+
+    return edit_puzzle(turb, puzzle, trigger_id)
+
+actions['button']['edit_puzzle'] = edit_puzzle_button
+
+def edit_puzzle(turb, puzzle, trigger_id):
+    """Common code for implementing an edit puzzle dialog
+
+    This implementation is common whether the edit operation was invoked
+    by a button (edit_puzzle_button) or a command (edit_puzzle_command).
+    """
+
+    round_options = hunt_rounds(turb, puzzle['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": puzzle['hunt_id'],
+            "SK": puzzle["SK"],
+            "puzzle_id": puzzle['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),
+            checkbox_block("Is this a meta puzzle?", "Meta", "meta",
+                           checked=(puzzle.get('type', 'plain') == 'meta')),
+            * 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
+
+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']
+    user_id = payload['user']['id']
+
+    puzzle['name'] = state['name']['name']['value']
+    url = state['url']['url']['value']
+    if url:
+        puzzle['url'] = url
+    if state['meta']['meta']['selected_options']:
+        puzzle['type'] = 'meta'
+    else:
+        puzzle['type'] = 'plain'
+    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
+                }
+            )
+
+    # Get old puzzle from the database (to determine what's changed)
+    old_puzzle = find_puzzle_for_sort_key(turb,
+                                          puzzle['hunt_id'],
+                                          puzzle['SK'])
+
+    # If we are changing puzzle type (meta -> plain or plain -> meta)
+    # the the sort key has to change, so compute the new one and delete
+    # the old item from the database.
+    #
+    # XXX: We should really be using a transaction here to combine the
+    # delete_item and the put_item into a single transaction, but
+    # the boto interface is annoying in that transactions are only on
+    # the "Client" object which has a totally different interface than
+    # the "Table" object I've been using so I haven't figured out how
+    # to do that yet.
+
+    if puzzle['type'] != old_puzzle.get('type', 'plain'):
+        puzzle['SK'] = puzzle_sort_key(puzzle)
+        turb.table.delete_item(Key={
+            'hunt_id': old_puzzle['hunt_id'],
+            'SK': old_puzzle['SK']
+        })
+
+    # Update the puzzle in the database
+    turb.table.put_item(Item=puzzle)
+
+    # Inform the puzzle channel about the edit
+    edit_message = "Puzzle edited by <@{}>".format(user_id)
+    blocks = ([section_block(text_block(edit_message+":\n"))] +
+              puzzle_blocks(puzzle, include_rounds=True))
+    slack_send_message(
+        turb.slack_client, puzzle['channel_id'],
+        edit_message, blocks=blocks)
+
+    # Also inform the hunt if the puzzle's solved status changed
+    if puzzle['status'] != old_puzzle['status']:
+        hunt = find_hunt_for_hunt_id(turb, puzzle['hunt_id'])
+        if puzzle['status'] == 'solved':
+            message = "Puzzle <{}|{}> has been solved!".format(
+                puzzle['channel_url'],
+                puzzle['name'])
+        else:
+            message = "Oops. Puzzle <{}|{}> has been marked unsolved!".format(
+                puzzle['channel_url'],
+                puzzle['name'])
+        slack_send_message(turb.slack_client, hunt['channel_id'], message)
+
+    # 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, old_puzzle=old_puzzle)
+
+    return lambda_ok
+
+def edit_hunt_command(turb, body):
+    """Implementation of the `/hunt edit` command
+
+    As dispatched from the hunt() function.
+    """
+
+    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 does not appear to be a hunt channel.")
+
+    return edit_hunt(turb, hunt, trigger_id)
+
+def edit_hunt_button(turb, payload):
+    """Handler for the action of user pressing an edit_hunt button"""
+
+    hunt_id = payload['actions'][0]['action_id']
+    trigger_id = payload['trigger_id']
+
+    hunt = find_hunt_for_hunt_id(turb, hunt_id)
+
+    if not hunt:
+        return bot_reply("Error: Hunt not found.")
+
+    return edit_hunt(turb, hunt, trigger_id)
+
+actions['button']['edit_hunt'] = edit_hunt_button
+
+def edit_hunt(turb, hunt, trigger_id):
+    """Common code for implementing an edit hunt dialog
+
+    This implementation is common whether the edit operation was invoked
+    by a button (edit_hunt_button) or a command (edit_hunt_command).
+    """
+
+    view = {
+        "type": "modal",
+        "private_metadata": json.dumps({
+            "hunt_id": hunt["hunt_id"],
+            "SK": hunt["SK"],
+            "is_hunt": hunt["is_hunt"],
+            "channel_id": hunt["channel_id"],
+            "sheet_url": hunt["sheet_url"],
+            "folder_id": hunt["folder_id"],
+        }),
+        "title": { "type": "plain_text", "text": "Edit Hunt" },
+        "submit": { "type": "plain_text", "text": "Save" },
+        "blocks": [
+            input_block("Hunt name", "name", "Name of the hunt",
+                        initial_value=hunt["name"]),
+            input_block("Hunt URL", "url", "External URL of hunt",
+                        initial_value=hunt.get("url", None),
+                        optional=True),
+            checkbox_block("Is this hunt active?", "Active", "active",
+                           checked=(hunt.get('active', False)))
+        ]
+    }
+
+    result = turb.slack_client.views_open(trigger_id=trigger_id,
+                                          view=view)
+
+    if result['ok']:
+        submission_handlers[result['view']['id']] = edit_hunt_submission
+
+    return lambda_ok
+
+def edit_hunt_submission(turb, payload, metadata):
+    """Handler for the user submitting the edit hunt modal
+
+    This is the modal view presented by the edit_hunt function above.
+    """
+
+    hunt={}
+
+    # First, read all the various data from the request
+    meta = json.loads(metadata)
+    hunt['hunt_id'] = meta['hunt_id']
+    hunt['SK'] = meta['SK']
+    hunt['is_hunt'] = meta['is_hunt']
+    hunt['channel_id'] = meta['channel_id']
+    hunt['sheet_url'] = meta['sheet_url']
+    hunt['folder_id'] = meta['folder_id']
+
+    state = payload['view']['state']['values']
+    user_id = payload['user']['id']
+
+    hunt['name'] = state['name']['name']['value']
+    url = state['url']['url']['value']
+    if url:
+        hunt['url'] = url
+
+    if state['active']['active']['selected_options']:
+        hunt['active'] = True
+    else:
+        hunt['active'] = False
+
+    # Update the hunt in the database
+    turb.table.put_item(Item=hunt)
+
+    # Inform the hunt channel about the edit
+    edit_message = "Hunt edited by <@{}>".format(user_id)
+    blocks = [
+        section_block(text_block(edit_message)),
+        section_block(text_block("Hunt name: {}".format(hunt['name']))),
+    ]
+
+    url = hunt.get('url', None)
+    if url:
+        blocks.append(
+            section_block(text_block("Hunt URL: {}".format(hunt['url'])))
+        )
+
+    slack_send_message(
+        turb.slack_client, hunt['channel_id'],
+        edit_message, blocks=blocks)
+
+    return lambda_ok
+
+def new_hunt_command(turb, body):
+    """Implementation of the '/hunt new' command
+
+    As dispatched from the hunt() function.
+    """
+
+    trigger_id = body['trigger_id'][0]
+
+    return new_hunt(turb, trigger_id)
+
+def new_hunt_button(turb, payload):
     """Handler for the action of user pressing the new_hunt button"""
 
+    trigger_id = payload['trigger_id']
+
+    return new_hunt(turb, trigger_id)
+
+def new_hunt(turb, trigger_id):
+    """Common code for implementing a new hunt dialog
+
+    This implementation is common whether the operations was invoked
+    by a button (new_hunt_button) or a command (new_hunt_command).
+    """
+
     view = {
         "type": "modal",
         "private_metadata": json.dumps({}),
@@ -65,17 +527,14 @@ def new_hunt(turb, payload):
         ],
     }
 
-    result = turb.slack_client.views_open(trigger_id=payload['trigger_id'],
+    result = turb.slack_client.views_open(trigger_id=trigger_id,
                                           view=view)
     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}
+actions['button']['new_hunt'] = new_hunt
 
 def new_hunt_submission(turb, payload, metadata):
     """Handler for the user submitting the new hunt modal
@@ -92,35 +551,90 @@ 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'},
+                {'AttributeName': 'url', 'AttributeType': 'S'},
+                {'AttributeName': 'puzzle_id', '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'
+                    }
+                },
+                {
+                    'IndexName': 'puzzle_id_index',
+                    'KeySchema': [
+                        {'AttributeName': 'hunt_id', 'KeyType': 'HASH'},
+                        {'AttributeName': 'puzzle_id', 'KeyType': 'RANGE'},
+                    ],
+                    'Projection': {
+                        'ProjectionType': 'ALL'
+                    }
+                }
+            ]
         )
-        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 +649,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,73 +712,257 @@ 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 find_hunt_for_channel(turb, channel_id, channel_name):
-    """Given a channel ID/name find the id/name of the hunt for this channel
+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 a tuple of (hunt_name, hunt_id) or (None, None)."""
+    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.).
+    """
 
-    hunts_table = turb.db.Table("hunts")
-    response = hunts_table.get_item(Key={'channel_id': channel_id})
+    entry = db_entry_for_channel(turb, channel_id)
 
-    if 'Item' in response:
-        item = response['Item']
-        return (item['hunt_id'], item['name'])
+    # 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'])
 
-    # 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]
+# 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
 
-    response = hunts_table.scan(
-        FilterExpression='hunt_id = :hunt_id',
-        ExpressionAttributeValues={':hunt_id': hunt_id}
+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 'Items' in response:
-        item = response['Items'][0]
-        return (item['hunt_id'], item['name'])
+    if response['Count'] == 0:
+        return []
 
-    return (None, None)
+    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)."""
+    The args string can be a sub-command:
+
+        /puzzle new: Bring up a dialog to create a new puzzle
+
+        /puzzle edit: Edit the puzzle for the current channel
+
+    Or with no argument at all:
+
+        /puzzle: Print details of the current puzzle (if in a puzzle channel)
+    """
+
+    if args == 'new':
+        return new_puzzle(turb, body)
+
+    if args == 'edit':
+        return edit_puzzle_command(turb, body)
+
+    if len(args):
+        return bot_reply("Unknown syntax for `/puzzle` command. " +
+                         "Valid commands are: `/puzzle`, `/puzzle edit`, " +
+                         "and `/puzzle new` to display, edit, or create " +
+                         "a puzzle.")
+
+    # For no arguments we print the current puzzle as a reply
+    channel_id = body['channel_id'][0]
+    response_url = body['response_url'][0]
+
+    puzzle = puzzle_for_channel(turb, channel_id)
+
+    if not puzzle:
+        hunt = hunt_for_channel(turb, channel_id)
+        if hunt:
+            return bot_reply(
+                "This is not a puzzle channel, but is a hunt channel. "
+                + "If you want to create a new puzzle for this hunt, use "
+                + "`/puzzle new`.")
+        else:
+            return bot_reply(
+                "Sorry, this channel doesn't appear to be a hunt or a puzzle "
+                + "channel, so the `/puzzle` command cannot work here.")
+
+    blocks = puzzle_blocks(puzzle, include_rounds=True)
+
+    # For a meta puzzle, also display the titles and solutions for all
+    # puzzles in the same round.
+    if puzzle.get('type', 'plain') == 'meta':
+        puzzles = hunt_puzzles_for_hunt_id(turb, puzzle['hunt_id'])
+
+        # Drop this puzzle itself from the report
+        puzzles = [p for p in puzzles if p['puzzle_id'] != puzzle['puzzle_id']]
+
+        for round in puzzle.get('rounds', [None]):
+            answers = round_quoted_puzzles_titles_answers(round, puzzles)
+            blocks += [
+                section_block(text_block(
+                    "*Feeder solutions from round {}*".format(
+                        round if round else "<none>"
+                    ))),
+                section_block(text_block(answers))
+            ]
+
+    requests.post(response_url,
+                  json = {'blocks': blocks},
+                  headers = {'Content-type': 'application/json'}
+                  )
+
+    return lambda_ok
+
+commands["/puzzle"] = puzzle
+
+def new(turb, body, args):
+    """Implementation of the `/new` command
+
+    This can be used to create a new hunt ("/new hunt") or a new
+    puzzle ("/new puzzle" or simply "/new"). So puzzle creation is the
+    default behavior (as it is much more common).
+
+    This operations are identical to the existing "/hunt new" and
+    "/puzzle new". I don't know that that redundancy is actually
+    helpful in the interface. But at least having both allows us to
+    experiment and decide which is more natural and should be kept
+    around long-term.
+    """
+
+    if args == 'hunt':
+        return new_hunt_command(turb, body)
+
+    return new_puzzle(turb, body)
+
+commands["/new"] = new
+
+def new_puzzle(turb, body):
+    """Implementation of the "/puzzle new" command
+
+    This brings up a dialog box for creating a new puzzle.
+    """
 
     channel_id = body['channel_id'][0]
-    channel_name = body['channel_name'][0]
     trigger_id = body['trigger_id'][0]
 
-    (hunt_id, hunt_name) = find_hunt_for_channel(turb, channel_id, channel_name)
+    hunt = hunt_for_channel(turb, channel_id)
 
-    if not hunt_id:
+    if not hunt:
         return bot_reply("Sorry, this channel doesn't appear to "
                          + "be a hunt or puzzle channel")
 
+    # We used puzzle (if available) to select the initial round(s)
+    puzzle = puzzle_for_channel(turb, channel_id)
+    initial_rounds = None
+    if puzzle:
+        initial_rounds=puzzle.get("rounds", None)
+
+    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,
+                               initial_options=initial_rounds)
+        ]
+    else:
+        round_options_block = []
+
     view = {
         "type": "modal",
         "private_metadata": json.dumps({
-            "hunt_id": hunt_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),
+            checkbox_block("Is this a meta puzzle?", "Meta", "meta"),
+            * round_options_block,
+            input_block("New round(s)", "new_rounds",
+                        "New round(s) this puzzle belongs to " +
+                        "(comma separated)",
                         optional=True)
         ]
     }
@@ -273,60 +971,429 @@ def puzzle(turb, body, args):
                                           view=view)
 
     if (result['ok']):
-        submission_handlers[result['view']['id']] = puzzle_submission
-
-    return {
-        'statusCode': 200
-    }
+        submission_handlers[result['view']['id']] = new_puzzle_submission
 
-commands["/puzzle"] = puzzle
+    return lambda_ok
 
-def puzzle_submission(turb, payload, metadata):
+def new_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."""
+    This is the modal view presented to the user by the new_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']
-    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")
+    # And start loading data into a puzzle dict
+    puzzle = {}
+    puzzle['hunt_id'] = hunt_id
+    puzzle['name'] = state['name']['name']['value']
+    url = state['url']['url']['value']
+    if url:
+        puzzle['url'] = url
+    if state['meta']['meta']['selected_options']:
+        puzzle['type'] = 'meta'
+    else:
+        puzzle['type'] = 'plain'
+    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']
+
+    # Create a Slack-channel-safe puzzle_id
+    puzzle['puzzle_id'] = puzzle_id_from_name(puzzle['name'])
+
+    # Before doing anything, reject this puzzle if a puzzle already
+    # exists with the same puzzle_id or url
+    existing = find_puzzle_for_puzzle_id(turb, hunt_id, puzzle['puzzle_id'])
+    if existing:
+        return submission_error(
+            "name",
+            "Error: This name collides with an existing puzzle.")
+
+    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.")
+
+    # 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
+                }
+            )
+
+    if rounds:
+        puzzle['rounds'] = rounds
+
+    puzzle['solution'] = []
+    puzzle['status'] = 'unsolved'
 
     # Create a channel for the puzzle
-    hunt_dash_channel = "{}-{}".format(hunt_id, puzzle_id)
+    channel_name = puzzle_channel_name(puzzle)
 
     try:
         response = turb.slack_client.conversations_create(
-            name=hunt_dash_channel)
+            name=channel_name)
     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(channel_name, e.response['error']))
+
+    puzzle['channel_id'] = response['channel']['id']
 
-    puzzle_channel_id = response['channel']['id']
+    # Finally, compute the appropriate sort key
+    puzzle["SK"] = puzzle_sort_key(puzzle)
 
     # 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,
-        }
+    turb.table.put_item(Item=puzzle)
+
+    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]
+
+    old_puzzle = puzzle_for_channel(turb, channel_id)
+
+    if not old_puzzle:
+        return bot_reply(
+            "Sorry, the /state command only works in a puzzle channel")
+
+    # Make a deep copy of the puzzle object
+    puzzle = puzzle_copy(old_puzzle)
+
+    # Update the puzzle in the database
+    puzzle['state'] = args
+    turb.table.put_item(Item=puzzle)
+
+    puzzle_update_channel_and_sheet(turb, puzzle, old_puzzle=old_puzzle)
+
+    return lambda_ok
+
+commands["/state"] = state
+
+def tag(turb, body, args):
+    """Implementation of the `/tag` command.
+
+    Arg is either a tag to add (optionally prefixed with '+'), or if
+    prefixed with '-' is a tag to remove.
+    """
+
+    if not args:
+        return bot_reply("Usage: `/tag [+]TAG_TO_ADD` "
+                         + "or `/tag -TAG_TO_REMOVE`.")
+
+    channel_id = body['channel_id'][0]
+
+    old_puzzle = puzzle_for_channel(turb, channel_id)
+
+    if not old_puzzle:
+        return bot_reply(
+            "Sorry, the /tag command only works in a puzzle channel")
+
+    if args[0] == '-':
+        tag = args[1:]
+        action = 'remove'
+    else:
+        tag = args
+        if tag[0] == '+':
+            tag = tag[1:]
+        action = 'add'
+
+    # Force tag to all uppercase
+    tag = tag.upper()
+
+    # Reject a tag that is not alphabetic or underscore A-Z_
+    if not re.match(r'^[A-Z0-9_]*$', tag):
+        return bot_reply("Sorry, tags can only contain letters, numbers, "
+                         + "and the underscore character.")
+
+    if action == 'remove':
+        if 'tags' not in old_puzzle or tag not in old_puzzle['tags']:
+            return bot_reply("Nothing to do. This puzzle is not tagged "
+                             + "with the tag: {}".format(tag))
+    else:
+        if 'tags' in old_puzzle and tag in old_puzzle['tags']:
+            return bot_reply("Nothing to do. This puzzle is already tagged "
+                             + "with the tag: {}".format(tag))
+
+    # OK. Error checking is done. Let's get to work
+
+    # Make a deep copy of the puzzle object
+    puzzle = puzzle_copy(old_puzzle)
+
+    if action == 'remove':
+        puzzle['tags'] = [t for t in puzzle['tags'] if t != tag]
+    else:
+        if 'tags' not in puzzle:
+            puzzle['tags'] = [tag]
+        else:
+            puzzle['tags'].append(tag)
+
+    turb.table.put_item(Item=puzzle)
+
+    puzzle_update_channel_and_sheet(turb, puzzle, old_puzzle=old_puzzle)
+
+    return lambda_ok
+
+commands["/tag"] = tag
+
+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_id = body['user_id'][0]
+
+    old_puzzle = puzzle_for_channel(turb, channel_id)
+
+    if not old_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`")
+
+    # Make a deep copy of the puzzle object
+    puzzle = puzzle_copy(old_puzzle)
+
+    # 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_id, 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
+    puzzle_update_channel_and_sheet(turb, puzzle, old_puzzle=old_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. If this first word is missing, this command will display
+    only unsolved puzzles by default.
+
+    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, puzzle type, tags, 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]
+
+    # First, farm off "/hunt new" and "/hunt edit" a separate commands
+    if args == "new":
+        return new_hunt_command(turb, body)
+
+    if args == "edit":
+        return edit_hunt_command(turb, body)
+
+    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)
+
+    for block in blocks:
+        requests.post(response_url,
+                      json = { 'blocks': block },
+                      headers = {'Content-type': 'application/json'}
+                      )
+
+    return lambda_ok
+
+commands["/hunt"] = hunt
+
+def round(turb, body, args):
+    """Implementation of the /round command
+
+    Displays puzzles in the same round(s) as the puzzle for the
+    current channel.
+
+    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. If this first word is missing, this command will display
+    all puzzles in the round by default.
+
+    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]
+
+    puzzle = puzzle_for_channel(turb, channel_id)
+    hunt = hunt_for_channel(turb, channel_id)
+
+    if not puzzle:
+        if hunt:
+            return bot_reply(
+                "This is not a puzzle channel, but is a hunt channel. "
+                + "Use /hunt if you want to see all rounds for this hunt.")
+        else:
+            return bot_reply(
+                "Sorry, this channel doesn't appear to be a puzzle channel "
+                + "so the `/round` command cannot work here.")
+
+    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 = 'all'
+    else:
+        status = 'all'
+
+    # Separate search terms on spaces (but allow for quotation marks
+    # to capture spaces in a search term)
+    if terms:
+        terms = shlex.split(terms)
+
+    blocks = hunt_blocks(turb, hunt,
+                         puzzle_status=status, search_terms=terms,
+                         limit_to_rounds=puzzle.get('rounds', [])
+                         )
+
+    for block in blocks:
+        requests.post(response_url,
+                      json = { 'blocks': block },
+                      headers = {'Content-type': 'application/json'}
+                      )
+
+    return lambda_ok
+
+commands["/round"] = round
+
+def help_command(turb, body, args):
+    """Implementation of the /help command
+
+    Displays help on how to use Turbot.
+    """
+
+    channel_id = body['channel_id'][0]
+    response_url = body['response_url'][0]
+    user_id = body['user_id'][0]
+
+    # Process "/help me" first. It calls out to have_you_tried rather
+    # than going through our help system.
+    #
+    # Also, it reports in the current channel, (where all other help
+    # output is reported privately to the invoking user).
+    if args == "me":
+        to_try = "In response to <@{}> asking `/help me`:\n\n{}\n".format(
+            user_id, have_you_tried())
+
+        # We'll try first to reply directly to the channel (for the benefit
+        # of anyone else in the same channel that might be stuck too.
+        #
+        # But if this doesn't work, (direct message or private channel),
+        # then we can instead reply with an ephemeral message by using
+        # the response_url.
+        try:
+            turb.slack_client.chat_postMessage(
+                channel=channel_id, text=to_try)
+        except SlackApiError:
+            requests.post(response_url,
+                          json = {"text": to_try},
+                          headers = {"Content-type": "application/json"})
+        return lambda_ok
+
+    help_string = turbot_help(args)
+
+    requests.post(response_url,
+                  json = {"text": help_string},
+                  headers = {"Content-type": "application/json"})
+
+    return lambda_ok
+
+commands["/help"] = help_command