X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=turbot%2Finteraction.py;h=392574d89f1d8c9405dd18fee541a8815aea720f;hb=9a0a686586122ccb3c44c1cf61ee2addfe58cf08;hp=8bff8bc3cbc656571ca0a953a5002d9f7659ec3d;hpb=29c36d3057c5602c5a4b6fb0e48f454db01ddd9d;p=turbot

diff --git a/turbot/interaction.py b/turbot/interaction.py
index 8bff8bc..392574d 100644
--- a/turbot/interaction.py
+++ b/turbot/interaction.py
@@ -13,7 +13,8 @@ from turbot.puzzle import (
     puzzle_update_channel_and_sheet,
     puzzle_id_from_name,
     puzzle_blocks,
-    puzzle_sort_key
+    puzzle_sort_key,
+    puzzle_copy
 )
 from turbot.round import round_quoted_puzzles_titles_answers
 import turbot.rot
@@ -81,6 +82,50 @@ def multi_static_select(turb, payload):
 
 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
 
@@ -97,8 +142,6 @@ def edit_puzzle_command(turb, body):
 
     return edit_puzzle(turb, puzzle, trigger_id)
 
-    return lambda_ok
-
 def edit_puzzle_button(turb, payload):
     """Handler for the action of user pressing an edit_puzzle button"""
 
@@ -324,9 +367,155 @@ def edit_puzzle_submission(turb, payload, metadata):
 
     return lambda_ok
 
-def new_hunt(turb, payload):
+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']
+    response_url = payload['response_url']
+    trigger_id = payload['trigger_id']
+
+    hunt = find_hunt_for_hunt_id(hunt_id)
+
+    if not hunt:
+        requests.post(response_url,
+                      json = {"text": "Error: Hunt not found!"},
+                      headers = {"Content-type": "application/json"})
+        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({}),
@@ -342,7 +531,7 @@ 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
@@ -671,7 +860,7 @@ def puzzle(turb, body, args):
 
     # For a meta puzzle, also display the titles and solutions for all
     # puzzles in the same round.
-    if puzzle['type'] == 'meta':
+    if puzzle.get('type', 'plain') == 'meta':
         puzzles = hunt_puzzles_for_hunt_id(turb, puzzle['hunt_id'])
 
         # Drop this puzzle itself from the report
@@ -696,6 +885,27 @@ def puzzle(turb, body, args):
 
 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
 
@@ -855,8 +1065,8 @@ def state(turb, body, args):
         return bot_reply(
             "Sorry, the /state command only works in a puzzle channel")
 
-    # Make a copy of the puzzle object
-    puzzle = old_puzzle.copy()
+    # Make a deep copy of the puzzle object
+    puzzle = puzzle_copy(old_puzzle)
 
     # Update the puzzle in the database
     puzzle['state'] = args
@@ -868,13 +1078,79 @@ def state(turb, body, args):
 
 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_name = body['user_name'][0]
+    user_id = body['user_id'][0]
 
     old_puzzle = puzzle_for_channel(turb, channel_id)
 
@@ -885,8 +1161,8 @@ def solved(turb, body, args):
         return bot_reply(
             "Error, no solution provided. Usage: `/solved SOLUTION HERE`")
 
-    # Make a copy of the puzzle object
-    puzzle = old_puzzle.copy()
+    # 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'
@@ -898,7 +1174,7 @@ def solved(turb, body, args):
     # Report the solution to the puzzle's channel
     slack_send_message(
         turb.slack_client, channel_id,
-        "Puzzle mark solved by {}: `{}`".format(user_name, args))
+        "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'])
@@ -931,14 +1207,22 @@ def hunt(turb, body, args):
     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.
+    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