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_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
actions['multi_static_select'] = {"*": multi_static_select}
def edit(turb, body, args):
+
"""Implementation of the `/edit` command
- To edit the puzzle for the current channel.
+ 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.
- This is simply a shortcut for `/puzzle edit`.
+ In any case, the operation is identical to `/hunt edit` or
+ `/puzzle edit`.
"""
- return edit_puzzle_command(turb, body)
+ # 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
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"""
action_id = payload['actions'][0]['action_id']
- response_url = payload['response_url']
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:
- requests.post(response_url,
- json = {"text": "Error: Puzzle not found!"},
- headers = {"Content-type": "application/json"})
return bot_reply("Error: Puzzle not found.")
return edit_puzzle(turb, puzzle, trigger_id)
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']
+ 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({}),
],
}
- 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
{'AttributeName': 'SK', 'AttributeType': 'S'},
{'AttributeName': 'channel_id', 'AttributeType': 'S'},
{'AttributeName': 'is_hunt', 'AttributeType': 'S'},
- {'AttributeName': 'url', 'AttributeType': 'S'}
+ {'AttributeName': 'url', 'AttributeType': 'S'},
+ {'AttributeName': 'puzzle_id', 'AttributeType': 'S'}
],
ProvisionedThroughput={
'ReadCapacityUnits': 5,
'Projection': {
'ProjectionType': 'ALL'
}
+ },
+ {
+ 'IndexName': 'puzzle_id_index',
+ 'KeySchema': [
+ {'AttributeName': 'hunt_id', 'KeyType': 'HASH'},
+ {'AttributeName': 'puzzle_id', 'KeyType': 'RANGE'},
+ ],
+ 'Projection': {
+ 'ProjectionType': 'ALL'
+ }
}
]
)
# 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
def new(turb, body, args):
"""Implementation of the `/new` command
- To create a new puzzle.
+ 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 is simply a shortcut for `/puzzle new`.
+ 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
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)
+ round_options,
+ initial_options=initial_rounds)
]
else:
round_options_block = []
hunt_id = meta['hunt_id']
state = payload['view']['state']['values']
- name = state['name']['name']['value']
+
+ # 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'
+ puzzle['type'] = 'meta'
else:
- puzzle_type = 'plain'
+ puzzle['type'] = 'plain'
if 'rounds' in state:
rounds = [option['value'] for option in
state['rounds']['rounds']['selected_options']]
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 URL.
+ # 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:
"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(','):
}
)
- # Construct a puzzle dict
- puzzle = {
- "hunt_id": hunt_id,
- "puzzle_id": puzzle_id,
- "channel_id": channel_id,
- "solution": [],
- "status": 'unsolved',
- "name": name,
- "type": puzzle_type
- }
- if url:
- puzzle['url'] = url
if rounds:
puzzle['rounds'] = rounds
+ puzzle['solution'] = []
+ puzzle['status'] = 'unsolved'
+
+ # Create a channel for the puzzle
+ channel_name = puzzle_channel_name(puzzle)
+
+ try:
+ response = turb.slack_client.conversations_create(
+ name=channel_name)
+ except SlackApiError as e:
+ return submission_error(
+ "name",
+ "Error creating Slack channel {}: {}"
+ .format(channel_name, e.response['error']))
+
+ puzzle['channel_id'] = response['channel']['id']
+
# Finally, compute the appropriate sort key
puzzle["SK"] = puzzle_sort_key(puzzle)
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
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)
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'
# 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'])
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
blocks = hunt_blocks(turb, hunt, puzzle_status=status, search_terms=terms)
- requests.post(response_url,
- json = { 'blocks': blocks },
- headers = {'Content-type': 'application/json'}
- )
+ for block in blocks:
+ requests.post(response_url,
+ json = { 'blocks': block },
+ headers = {'Content-type': 'application/json'}
+ )
return lambda_ok
limit_to_rounds=puzzle.get('rounds', [])
)
- requests.post(response_url,
- json = { 'blocks': blocks },
- headers = {'Content-type': 'application/json'}
- )
+ 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
projects / turbot / blobdiff