X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=turbot%2Finteraction.py;h=8ae4a53556d45542ec19dca22471e46b89f8f702;hb=c6ce6535d35284aad823b9f325e54ddb67ea1f3e;hp=76eb061d024a29475bc01a368ab67abd3b3e162f;hpb=8bfdfeb7e02851ac34d1933b8d4311964e562b0d;p=turbot

diff --git a/turbot/interaction.py b/turbot/interaction.py
index 76eb061..8ae4a53 100644
--- a/turbot/interaction.py
+++ b/turbot/interaction.py
@@ -1,8 +1,9 @@
 from slack.errors import SlackApiError
 from turbot.blocks import (
-    input_block, section_block, text_block, multi_select_block
+    input_block, section_block, text_block, multi_select_block, checkbox_block
 )
-from turbot.hunt import find_hunt_for_hunt_id
+from turbot.hunt import find_hunt_for_hunt_id, hunt_blocks
+from turbot.puzzle import find_puzzle_for_url, find_puzzle_for_puzzle_id
 import turbot.rot
 import turbot.sheets
 import turbot.slack
@@ -12,12 +13,19 @@ 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}
@@ -61,6 +69,169 @@ def multi_static_select(turb, payload):
 
 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(',')
+        ]
+
+    # 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.
+
+    # XXX: What we really want here is a single function that sets the
+    # channel name, the channel topic, and the sheet name. That single
+    # function should be called anywhere there is code changing any of
+    # these things. This function could then also accept an optional
+    # "old_puzzle" argument and avoid changing any of those things
+    # that are unnecessary.
+    set_channel_topic(turb, puzzle)
+
+    return lambda_ok
+
 def new_hunt(turb, payload):
     """Handler for the action of user pressing the new_hunt button"""
 
@@ -86,7 +257,7 @@ def new_hunt(turb, payload):
 
     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
@@ -119,13 +290,14 @@ def new_hunt_submission(turb, payload, metadata):
             TableName='turbot',
             KeySchema=[
                 {'AttributeName': 'hunt_id', 'KeyType': 'HASH'},
-                {'AttributeName': 'SK', 'KeyType': 'RANGE'},
+                {'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,
@@ -158,6 +330,18 @@ def new_hunt_submission(turb, payload, metadata):
                         'WriteCapacityUnits': 5
                     }
                 }
+            ],
+            LocalSecondaryIndexes = [
+                {
+                    'IndexName': 'url_index',
+                    'KeySchema': [
+                        {'AttributeName': 'hunt_id', 'KeyType': 'HASH'},
+                        {'AttributeName': 'url', 'KeyType': 'RANGE'},
+                    ],
+                    'Projection': {
+                        'ProjectionType': 'ALL'
+                    }
+                }
             ]
         )
         return submission_error(
@@ -409,6 +593,7 @@ def puzzle_submission(turb, payload, metadata):
     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']
 
@@ -422,6 +607,15 @@ def puzzle_submission(turb, payload, metadata):
         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 = re.sub(r'[^a-zA-Z0-9_]', '', name).lower()
 
@@ -442,7 +636,12 @@ def puzzle_submission(turb, payload, metadata):
     # Add any new rounds to the database
     if new_rounds:
         for round in new_rounds.split(','):
-            rounds += round
+            # 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,
@@ -496,6 +695,10 @@ def set_channel_topic(turb, puzzle):
     if state:
         description += " {}".format(state)
 
+    # Slack only allows 250 characters for a topic
+    if len(description) > 250:
+        description = description[:247] + "..."
+
     turb.slack_client.conversations_setTopic(channel=channel_id,
                                              topic=description)
 
@@ -543,6 +746,8 @@ def solved(turb, body, args):
     # 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
@@ -562,9 +767,9 @@ def solved(turb, body, args):
     # And update the puzzle's description
     set_channel_topic(turb, puzzle)
 
-    # And rename the sheet to prefix with "SOLVED: "
+    # And rename the sheet to suffix with "-SOLVED"
     turbot.sheets.renameSheet(turb, puzzle['sheet_url'],
-                              'SOLVED: ' + puzzle['name'])
+                              puzzle['name'] + "-SOLVED")
 
     # Finally, rename the Slack channel to add the suffix '-solved'
     channel_name = "{}-{}-solved".format(
@@ -577,3 +782,62 @@ def solved(turb, body, args):
     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