def event_keyboard_alteration(user_language,
callback_prefix="event_alteration",
callback_postfix=""):
"""Generates the keyboard for event alteration.
Args:
user_language (str): Language that should be used.
callback_prefix (str): Prefix used for callback data.
callback_postfix (str): Postfix used for callback data.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
keyboard = [[
InlineKeyboardButton(receive_translation("event_alteration_change",
user_language),
callback_data="{}_change{}".format(
callback_prefix, callback_postfix)),
InlineKeyboardButton(receive_translation("event_alteration_delete",
user_language),
callback_data="{}_delete{}".format(
callback_prefix, callback_postfix))
]]
if callback_postfix:
keyboard[0].append(
InlineKeyboardButton(receive_translation(
"event_alteration_silence", user_language),
callback_data="{}_silence{}".format(
callback_prefix, callback_postfix)))
return InlineKeyboardMarkup(keyboard)
def event_alteration_start(update, context):
"""Starts the event alteration process."""
query = update.callback_query
query.answer()
altering_type = query.data.split("_")[-1:][0]
user_id = query.from_user['id']
events = DatabaseController.load_user_events(user_id)
user_language = DatabaseController.load_selected_language(user_id)
message = None
if altering_type == 'change':
message = receive_translation("event_alteration_change_header",
user_language)
elif altering_type == 'delete':
message = receive_translation("event_alteration_delete_header",
user_language)
if UserEventAlterationMachine.receive_state_of_user(
user_id
) == 0 or UserEventAlterationMachine.receive_state_of_user(
user_id) == -1:
bot = BotControl.get_bot()
bot.send_message(
user_id,
text=message,
parse_mode=ParseMode.MARKDOWN_V2,
reply_markup=Event.event_keyboard_alteration_action(
events, user_language, mode=altering_type))
def list_all_events_of_user(update, context):
"""Lists all events of the user."""
user = User.resolve_user(update)
message = "*{}:*\n\n".format(
receive_translation("event_list_header", user.language))
event_data = DatabaseController.load_user_events(user.user_id)
has_content = False
for day in DayEnum:
events = [event for event in event_data if event.day == day]
if not events:
continue
has_content = True
message += "*{}:*\n".format(
day.receive_day_translation(user.language))
for event in events:
message += event.pretty_print_formatting(user.language)
message += "\n"
if not has_content:
message += "{}".format(
receive_translation("no_events", user.language))
bot = BotControl.get_bot()
bot.send_message(user.user_id,
text=message,
parse_mode=ParseMode.MARKDOWN_V2,
reply_markup=Event.event_keyboard_alteration(
user.language))
def config_daily_ping_keyboard(user_language):
"""Generates the daily ping configuration keyboard.
Args:
user_language (str): Language that is used to communicate with the user.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
keyboard = [[
InlineKeyboardButton(receive_translation("yes", user_language),
callback_data="config_select_daily_ping_yes"),
InlineKeyboardButton(receive_translation("no", user_language),
callback_data="config_select_daily_ping_no")
]]
return InlineKeyboardMarkup(keyboard)
def config_options_keyboard(user_language):
"""Generates the keyboard for all available configuration options.
Args:
user_language (str): Language that is used to communicate with the user.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
keyboard = [[
InlineKeyboardButton(receive_translation(CONFIG_LANGUAGE,
user_language),
callback_data=CONFIG_LANGUAGE),
InlineKeyboardButton(receive_translation(CONFIG_DAILY_PING,
user_language),
callback_data=CONFIG_DAILY_PING)
]]
return InlineKeyboardMarkup(keyboard)
def event_keyboard_confirmation(user_language, callback_prefix):
"""Generates the event alteration delete confirmation keyboard.
Args:
user_language (str): Language that should be used.
callback_prefix (str): Prefix that is used to generate the callback data string.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
keyboard = [[
InlineKeyboardButton(
receive_translation("yes", user_language),
callback_data="{}_yes".format(callback_prefix)),
InlineKeyboardButton(receive_translation("no", user_language),
callback_data="{}_no".format(callback_prefix))
]]
return InlineKeyboardMarkup(keyboard)
def build_ping_message(user_id, event):
"""Generates the ping message for the user.
Args:
user_id (int): ID of the user - needed for localization.
event (Event): Contains all events of a user for a given day that are not passed yet.
Returns:
str: Formatted message.
"""
user_language = DatabaseController.load_selected_language(user_id)
message = "*{}*\n\n".format(receive_translation("event_reminder", user_language))
message += "*{}:* {}\n".format(receive_translation("event", user_language), event.name)
message += "*{}:* {}\n".format(receive_translation("event_content", user_language), event.content)
message += "*{}:* {}\n".format(receive_translation("event_start", user_language), event.event_time)
message += "\n"
return message
def start_configuration_dialog(update, context):
"""Starts the configuration dialog."""
user_id = update.message.from_user.id
user_language = DatabaseController.load_selected_language(user_id)
Configurator.config_options_keyboard(user_language)
update.message.reply_text(
receive_translation("config_dialog_started", user_language),
reply_markup=Configurator.config_options_keyboard(user_language))
def receive_type_translation(self, user_language):
"""Receive the translation of the selected EventType.
Args:
user_language (str): Language that should be used.
Returns:
str: Translation for the event type.
"""
return receive_translation("event_type_{}".format(self.name.lower()),
user_language)
def receive_day_translation(self, user_language):
"""Receive the translation of the selected day.
Args:
user_language (str): Language that should be used.
Returns:
str: Translation for the day.
"""
return receive_translation("day_{}".format(self.name.lower()),
user_language)
def add_new_event_title(update, context):
"""Handles the title of the new event."""
user = User.resolve_user(update)
user_language = DatabaseController.load_selected_language(user.user_id)
if UserEventCreationMachine.receive_state_of_user(user.user_id) != 1:
return
title = replace_reserved_characters(update.message.text)
EventHandler.events_in_creation[user.user_id]["title"] = title
update.message.reply_text(
receive_translation("event_creation_content", user_language))
def handle_configuration_daily_ping_change(update, context):
"""Handles the change of daily ping."""
query = update.callback_query
query.answer()
user_id = query.from_user['id']
user_language = DatabaseController.load_selected_language(user_id)
selected_daily_ping = query.data.split("_")[-1:][0]
if selected_daily_ping == "yes":
config_value = True
answer = receive_translation("config_daily_ping_enable",
user_language)
else:
config_value = False
answer = receive_translation("config_daily_ping_disable",
user_language)
DatabaseController.save_daily_ping(user_id, config_value)
query.edit_message_text(answer)
def add_new_event_content(update, context):
"""Handles the addition of content of a new event."""
user = User.resolve_user(update)
user_language = DatabaseController.load_selected_language(user.user_id)
if UserEventCreationMachine.receive_state_of_user(user.user_id) != 1:
return
content = replace_reserved_characters(update.message.text)
EventHandler.events_in_creation[user.user_id]["content"] = content
update.message.reply_text(
receive_translation("event_creation_type", user_language),
reply_markup=Event.event_keyboard_type(user_language))
def add_new_event(update, context):
"""Reply to the /new_event command. Created the event in creation entry for the requesting user and starts the
event creation cycle.
"""
user = User.resolve_user(update)
UserEventCreationMachine.set_state_of_user(user.user_id, 1)
EventHandler.events_in_creation[user.user_id] = {}
update.message.reply_text(
receive_translation(
"event_creation_start",
user.language).format(USERNAME=user.telegram_user.first_name))
def parse_input(update, context):
"""Echo the user message."""
user = User.resolve_user(update)
if UserEventCreationMachine.receive_state_of_user(user.user_id) == 1:
if user.user_id in EventHandler.events_in_creation.keys() and not EventHandler.events_in_creation[user.user_id]:
EventHandler.add_new_event_title(update, context)
elif EventHandler.events_in_creation[user.user_id]["title"]:
EventHandler.add_new_event_content(update, context)
elif UserEventAlterationMachine.receive_state_of_user(user.user_id) > 10:
EventHandler.event_alteration_handle_reply(update, context)
else:
update.message.reply_text(receive_translation("confused_echo", user.language))
def handle_configuration_dialog(update, context):
"""Handles the configuration dialog."""
query = update.callback_query
query.answer()
user_id = query.from_user['id']
user_language = DatabaseController.load_selected_language(user_id)
bot = BotControl.get_bot()
if query.data == CONFIG_LANGUAGE:
query.edit_message_text(
text=receive_translation("config_language_which",
user_language),
reply_markup=Configurator.config_language_keyboard())
elif query.data == CONFIG_DAILY_PING:
query.edit_message_text(
text=receive_translation("config_daily_ping_decide",
user_language),
reply_markup=Configurator.config_daily_ping_keyboard(
user_language))
def handle_configuration_language_change(update, context):
"""Handles the change of language."""
query = update.callback_query
query.answer()
user_id = query.from_user['id']
selected_language = query.data.split("_")[-1:][0]
DatabaseController.save_user_language(user_id, selected_language)
query.edit_message_text(
receive_translation("config_language_changed", selected_language))
def event_alteration_handle_reply(update, context):
"""Handles the replies of the event alteration."""
user_id = update.message.from_user.id
user_language = DatabaseController.load_selected_language(user_id)
state = UserEventAlterationMachine.receive_state_of_user(user_id)
bot = BotControl.get_bot()
logging.info(EventHandler.events_in_alteration[user_id]['old'])
event_suffix = "{}".format(
EventHandler.events_in_alteration[user_id]['old']['id'])
# State: Alter name
if state == 11:
title = replace_reserved_characters(update.message.text)
EventHandler.events_in_alteration[user_id]['new']['title'] = title
UserEventAlterationMachine.set_state_of_user(user_id, 99)
bot.send_message(
user_id,
text=receive_translation("event_alteration_change_decision",
user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_suffix)))
# State: Alter content
elif state == 12:
content = replace_reserved_characters(update.message.text)
EventHandler.events_in_alteration[user_id]['new'][
'content'] = content
UserEventAlterationMachine.set_state_of_user(user_id, 99)
bot.send_message(
user_id,
text=receive_translation("event_alteration_change_decision",
user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_suffix)))
def event_keyboard_alteration_change_start(user_language, callback_prefix):
"""Generates the event alternation change keyboard.
Args:
user_language (str): Language that should be used.
callback_prefix (str): Prefix that is used to generate the callback data string.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
keyboard = [
[
InlineKeyboardButton(
receive_translation("event_name", user_language),
callback_data="{}_name".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("event_content", user_language),
callback_data="{}_content".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("event_type", user_language),
callback_data="{}_type".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("event_day", user_language),
callback_data="{}_day".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("event_start", user_language),
callback_data="{}_start".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("event_pingtime", user_language),
callback_data="{}_pingtimes".format(callback_prefix))
],
[
InlineKeyboardButton(
receive_translation("done", user_language),
callback_data="{}_done".format(callback_prefix))
]
]
return InlineKeyboardMarkup(keyboard)
def _daily_ping_users(self, user_ids, day):
"""Pings all users inside the user id list with all of their events of the given day.
Args:
user_ids (list of 'str'): Contains all users.
day (int): Represents the day which should be pinged for.
"""
bot = BotControl.get_bot()
for user_id in user_ids:
user_events = DatabaseController.load_user_events(user_id)
language = DatabaseController.load_selected_language(user_id)
events_of_today = [event for event in user_events if event.day.value == day and event.in_daily_ping]
message = ""
if events_of_today:
message += "*{}*\n\n".format(receive_translation("event_daily_ping_header", language))
for event in events_of_today:
message_event = self.build_ping_message(user_id, event)
postfix = "_{}".format(event.uuid)
bot.send_message(user_id, text=message + message_event, parse_mode=ParseMode.MARKDOWN_V2,
reply_markup=Event.event_keyboard_alteration(language, "event", postfix))
# Clear so that the header is only printed once
message = ""
def event_keyboard_ping_times(user_language, callback_prefix, states=None):
"""Generates the event ping times keyboard.
Args:
user_language (str): Language that should be used.
callback_prefix (str): Prefix that is used to generate the callback data string.
states (dict, optional): States of the ping times.
Returns:
InlineKeyboardMarkup: Generated keyboard.
"""
if not states:
states = {
"00:30": False,
"01:00": False,
"02:00": False,
"04:00": False,
"06:00": False,
"12:00": False,
"24:00": False
}
keyboard = []
for state in states:
checkbox = UNCHECKED_CHECKBOX
if states[state]:
checkbox = CHECKED_CHECKBOX
keyboard.append([
InlineKeyboardButton(text="{} {}".format(checkbox, state),
callback_data="{}_ping_times_{}".format(
callback_prefix, state))
])
keyboard.append([
InlineKeyboardButton(
text=receive_translation("done", user_language),
callback_data="{}_ping_times_done".format(callback_prefix))
])
return InlineKeyboardMarkup(keyboard)
def pretty_print_formatting(self, user_language):
"""Collects all data about an event and returns a pretty printed version.
Args:
user_language (str): Code of the language of the user.
Returns:
str: Pretty formatted event information.
"""
message = "*{}:* {}\n".format(
receive_translation("event_name", user_language), self.name)
message += "*{}:* {}\n".format(
receive_translation("event_content", user_language), self.content)
message += "*{}:* {}\n".format(
receive_translation("event_type", user_language),
self.event_type.receive_type_translation(user_language))
message += "*{}:* {}\n".format(
receive_translation("event_start", user_language), self.event_time)
ping_times_enabled = ""
current_time = datetime.now()
start_time = datetime(current_time.year, current_time.month,
current_time.day, self.event_time_hours,
self.event_time_minutes)
for ping_time in self.ping_times:
if self.ping_times[
ping_time] or ping_time in self.ping_times_to_refresh.keys(
):
ping_time_delta = timedelta(hours=int(ping_time.split(":")[0]),
minutes=int(
ping_time.split(":")[1]))
ping_time_real = start_time - ping_time_delta
ping_times_enabled += "{}:{} \\- \\({} {}\\)\n".format(
"0{}".format(ping_time_real.hour)[-2:],
"0{}".format(ping_time_real.minute)[-2:], ping_time,
receive_translation("event_before", user_language))
if ping_times_enabled:
message += "*{}:*\n{}".format(
receive_translation("event_pingtime", user_language),
ping_times_enabled)
return message
def add_new_event_query_handler(update, context):
"""Creates a new event with help of the event creation state machine and keyboards."""
query = update.callback_query
query.answer()
if query.message.chat['type'] == "group":
user_id = query.message.chat['id']
else:
user_id = query.from_user['id']
user_language = DatabaseController.load_selected_language(user_id)
bot = BotControl.get_bot()
# State: Requesting event type
if UserEventCreationMachine.receive_state_of_user(user_id) == 1:
EventHandler.events_in_creation[user_id]["event_type"] = int(
query.data)
if query.data == "{}".format(EventType.SINGLE.value):
message = receive_translation("event_creation_type_single",
user_language)
elif query.data == "{}".format(EventType.REGULARLY.value):
message = receive_translation("event_creation_type_regularly",
user_language)
else:
message = receive_translation("undefined_error_response",
user_language)
query.edit_message_text(text=message)
UserEventCreationMachine.set_state_of_user(user_id, 2)
# State: Requesting day of the event
if UserEventCreationMachine.receive_state_of_user(user_id) == 2:
logging.info(query.data)
if query.data[0] == 'd':
EventHandler.events_in_creation[user_id]["day"] = query.data[
1:]
UserEventCreationMachine.set_state_of_user(user_id, 3)
bot.delete_message(user_id, query.message.message_id)
else:
bot.send_message(
user_id,
text=receive_translation("event_creation_day",
user_language),
reply_markup=Event.event_keyboard_day(user_language))
# State: Requesting start hours of the event
if UserEventCreationMachine.receive_state_of_user(user_id) == 3:
logging.info(query.data)
if query.data[0] == 'h':
EventHandler.events_in_creation[user_id]["hours"] = query.data[
1:]
UserEventCreationMachine.set_state_of_user(user_id, 4)
bot.delete_message(user_id, query.message.message_id)
else:
bot.send_message(user_id,
text=receive_translation(
"event_creation_hours", user_language),
reply_markup=Event.event_keyboard_hours())
# State: Requesting start minutes of the event
if UserEventCreationMachine.receive_state_of_user(user_id) == 4:
logging.info(query.data)
if query.data[0] == 'm':
EventHandler.events_in_creation[user_id]["event_time"] = \
"{}:{}".format(EventHandler.events_in_creation[user_id]["hours"], query.data[1:])
UserEventCreationMachine.set_state_of_user(user_id, 10)
query.edit_message_text(text=receive_translation(
"event_creation_finished", user_language))
else:
bot.send_message(user_id,
text=receive_translation(
"event_creation_minutes", user_language),
reply_markup=Event.event_keyboard_minutes())
# State: Start requesting ping times for the event - reset status.
if UserEventCreationMachine.receive_state_of_user(user_id) == 10:
ping_states = DEFAULT_PING_STATES.copy()
EventHandler.events_in_creation[user_id][
"ping_times"] = ping_states
query.edit_message_text(
text=receive_translation("event_creation_ping_times_header",
user_language),
reply_markup=Event.event_keyboard_ping_times(
user_language, "event_creation", ping_states))
UserEventCreationMachine.set_state_of_user(user_id, 11)
elif UserEventCreationMachine.receive_state_of_user(user_id) == 11:
if "ping_times" in query.data:
suffix = query.data.split('_')[-1]
if suffix == "done":
UserEventCreationMachine.set_state_of_user(user_id, -1)
bot.delete_message(user_id, query.message.message_id)
else:
EventHandler.events_in_creation[user_id]["ping_times"][suffix] = \
not EventHandler.events_in_creation[user_id]["ping_times"][suffix]
query.edit_message_text(
text=receive_translation(
"event_creation_ping_times_header", user_language),
reply_markup=Event.event_keyboard_ping_times(
user_language, "event_creation",
EventHandler.events_in_creation[user_id]
["ping_times"]))
# State: All data collected - creating event
if UserEventCreationMachine.receive_state_of_user(user_id) == -1:
event_in_creation = EventHandler.events_in_creation[user_id]
event = Event(event_in_creation["title"],
DayEnum(int(event_in_creation["day"])),
event_in_creation["content"],
EventType(event_in_creation["event_type"]),
event_in_creation["event_time"],
event_in_creation["ping_times"])
DatabaseController.save_event_data_user(user_id, event)
UserEventCreationMachine.set_state_of_user(user_id, 0)
EventHandler.events_in_creation.pop(user_id)
# Needed because when an event is created on the current day but has already passed there
# would be pings for it.
event_hour, event_minute = event.event_time.split(":")
current_time = datetime.now()
if int(event_in_creation["day"]) == current_time.weekday() and int(event_hour) < current_time.hour or \
(int(event_hour) == current_time.hour and int(event_minute) < current_time.minute):
event.start_ping_done = True
event.ping_times_to_refresh = {}
for ping_time in event.ping_times:
if event.ping_times[ping_time]:
event.ping_times_to_refresh[ping_time] = True
event.ping_times = DEFAULT_PING_STATES.copy()
DatabaseController.save_event_data_user(user_id, event)
message = receive_translation("event_creation_summary_header",
user_language)
message += event.pretty_print_formatting(user_language)
bot.send_message(user_id,
text=message,
parse_mode=ParseMode.MARKDOWN_V2)
def help_command(update, context):
"""Send a message when the command /help is issued."""
user = User.resolve_user(update)
update.message.reply_markdown_v2(receive_translation("help", user.language))
def start(update, context):
"""Send a message when the command /start is issued."""
user = User.resolve_user(update)
update.message.reply_text(
receive_translation("greeting", user.language).format(USERNAME=user.telegram_user.first_name))
def event_alteration_perform(update, context):
"""Performs the event alteration."""
query = update.callback_query
query.answer()
user_id = query.from_user['id']
user_language = DatabaseController.load_selected_language(user_id)
logging.info("data: %s | state: %s", query.data,
UserEventAlterationMachine.receive_state_of_user(user_id))
event_id = query.data.split('_')[2]
# Handle silencing of events
if query.data.startswith("event_silence"):
event = [
event for event in DatabaseController.load_user_events(user_id)
if event.uuid == event_id
][0]
# For regularly events the ping times have to be marked as to be refreshed
if event.event_type == EventType.REGULARLY:
for ping_time in event.ping_times:
if event.ping_times[ping_time]:
event.ping_times_to_refresh[ping_time] = True
event.ping_times = DEFAULT_PING_STATES.copy()
DatabaseController.save_event_data_user(user_id, event)
query.edit_message_text(
text=receive_translation("event_silenced", user_language))
UserEventAlterationMachine.set_state_of_user(user_id, 0)
# Handle change of events
elif query.data.startswith("event_change"):
# State: Choice - Check which button the user clicked after change was started.
if UserEventAlterationMachine.receive_state_of_user(user_id) == 99:
choice = query.data.split('_')[-1]
if choice == "name":
UserEventAlterationMachine.set_state_of_user(user_id, 1)
elif choice == "content":
UserEventAlterationMachine.set_state_of_user(user_id, 2)
elif choice == "type":
UserEventAlterationMachine.set_state_of_user(user_id, 3)
elif choice == "start":
UserEventAlterationMachine.set_state_of_user(user_id, 4)
elif choice == "pingtimes":
UserEventAlterationMachine.set_state_of_user(user_id, 5)
elif choice == "day":
UserEventAlterationMachine.set_state_of_user(user_id, 6)
elif choice == "done":
UserEventAlterationMachine.set_state_of_user(user_id, -1)
# State: Initial - return options to the user.
if UserEventAlterationMachine.receive_state_of_user(user_id) == 0:
EventHandler.events_in_alteration[user_id] = {}
EventHandler.events_in_alteration[user_id]['old'] = \
DatabaseController.read_event_of_user(user_id, event_id)
EventHandler.events_in_alteration[user_id]['old'][
'id'] = event_id
EventHandler.events_in_alteration[user_id]['new'] = \
EventHandler.events_in_alteration[user_id]['old'].copy()
query.edit_message_text(
text=receive_translation(
"event_alteration_change_decision", user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, query.data))
UserEventAlterationMachine.set_state_of_user(user_id, 99)
# State: Name - Change name of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 1:
query.edit_message_text(text=receive_translation(
"event_alteration_change_name", user_language))
UserEventAlterationMachine.set_state_of_user(user_id, 11)
# State: Content - Change content of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 2:
query.edit_message_text(text=receive_translation(
"event_alteration_change_content", user_language))
UserEventAlterationMachine.set_state_of_user(user_id, 12)
# State: Type - Change type of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 3:
query.edit_message_text(
text=receive_translation("event_alteration_change_type",
user_language),
reply_markup=Event.event_keyboard_type(
user_language,
callback_prefix="event_change_{}_type_".format(
event_id)))
UserEventAlterationMachine.set_state_of_user(user_id, 13)
# State: Start time - Change start time of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 4:
query.edit_message_text(
text=receive_translation("event_alteration_change_hours",
user_language),
reply_markup=Event.event_keyboard_hours(
callback_prefix="event_change_{}_hours_".format(
event_id)))
UserEventAlterationMachine.set_state_of_user(user_id, 41)
# State: Ping times - Change ping times of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 5:
query.edit_message_text(
text=receive_translation(
"event_creation_ping_times_header", user_language),
reply_markup=Event.event_keyboard_ping_times(
user_language,
callback_prefix="event_change_{}".format(event_id),
states=EventHandler.events_in_alteration[user_id]
["old"]["ping_times"]))
UserEventAlterationMachine.set_state_of_user(user_id, 51)
# State: Day - Change day of event.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 6:
query.edit_message_text(
text=receive_translation("event_creation_day",
user_language),
reply_markup=Event.event_keyboard_day(
user_language,
callback_prefix="event_change_{}_".format(event_id)))
UserEventAlterationMachine.set_state_of_user(user_id, 16)
# State: Alter event type
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 13:
EventHandler.events_in_alteration[user_id]['new'][
'event_type'] = int(query.data.split('_')[-1][0])
UserEventAlterationMachine.set_state_of_user(user_id, 99)
query.edit_message_text(
text=receive_translation(
"event_alteration_change_decision", user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_id)))
# State: Alter event day
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 16:
EventHandler.events_in_alteration[user_id]['new']['day'] = int(
query.data.split('_')[-1][1])
UserEventAlterationMachine.set_state_of_user(user_id, 99)
query.edit_message_text(
text=receive_translation(
"event_alteration_change_decision", user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_id)))
# State: Alter event hours
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 41:
EventHandler.events_in_alteration[user_id]['new']['event_time'] = \
"{}:{}".format(query.data.split('_')[-1][1:],
EventHandler.events_in_alteration[user_id]['new']['event_time'].split(':')[1])
UserEventAlterationMachine.set_state_of_user(user_id, 42)
query.edit_message_text(
text=receive_translation("event_alteration_change_minutes",
user_language),
reply_markup=Event.event_keyboard_minutes(
callback_prefix="event_change_{}_minutes_".format(
event_id)))
# State: Alter event minutes
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 42:
EventHandler.events_in_alteration[user_id]['new']['event_time'] = \
"{}:{}".format(EventHandler.events_in_alteration[user_id]['new']['event_time'].split(':')[0],
query.data.split('_')[-1][1:])
UserEventAlterationMachine.set_state_of_user(user_id, 99)
query.edit_message_text(
text=receive_translation(
"event_alteration_change_decision", user_language),
reply_markup=Event.event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_id)))
# State: Alter ping times - trigger chance on ping time
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 51:
toggle_data = query.data.split('_')[-1]
if toggle_data == 'done':
UserEventAlterationMachine.set_state_of_user(user_id, 99)
query.edit_message_text(
text=receive_translation(
"event_alteration_change_decision", user_language),
reply_markup=Event.
event_keyboard_alteration_change_start(
user_language, "event_change_{}".format(event_id)))
else:
EventHandler.events_in_alteration[user_id]["new"]["ping_times"][toggle_data] = \
not EventHandler.events_in_alteration[user_id]["new"]["ping_times"][toggle_data]
query.edit_message_text(
text=receive_translation(
"event_creation_ping_times_header", user_language),
reply_markup=Event.event_keyboard_ping_times(
user_language,
callback_prefix="event_change_{}".format(event_id),
states=EventHandler.events_in_alteration[user_id]
["new"]["ping_times"]))
# State: Done - Save changes and delete temporary object.
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == -1:
event_dict = EventHandler.events_in_alteration[user_id]["new"]
event = Event(event_dict['title'],
DayEnum(int(event_dict['day'])),
event_dict['content'],
EventType(int(event_dict['event_type'])),
event_dict['event_time'],
event_dict['ping_times'],
start_ping_done=event_dict['start_ping_done'])
event.uuid = event_id
DatabaseController.save_event_data_user(user_id, event)
query.edit_message_text(text=receive_translation(
"event_alteration_change_done", user_language))
EventHandler.events_in_alteration.pop(user_id)
UserEventAlterationMachine.set_state_of_user(user_id, 0)
elif query.data.startswith("event_delete"):
# State: Initial - request confirmation from user
if UserEventAlterationMachine.receive_state_of_user(user_id) == 0:
message = receive_translation(
"event_alteration_delete_request_confirmation",
user_language)
message += "\n"
event_data = DatabaseController.read_event_of_user(
user_id, event_id)
event = Event(event_data['title'], DayEnum(event_data['day']),
event_data['content'],
EventType(event_data['event_type']),
event_data['event_time'])
message += event.pretty_print_formatting(user_language)
query.edit_message_text(
text=message,
reply_markup=Event.event_keyboard_confirmation(
user_language, "event_delete_{}".format(event_id)),
parse_mode=ParseMode.MARKDOWN_V2)
UserEventAlterationMachine.set_state_of_user(user_id, 101)
elif UserEventAlterationMachine.receive_state_of_user(
user_id) == 101:
if query.data.split('_')[-1] == 'yes':
DatabaseController.delete_event_of_user(user_id, event_id)
query.edit_message_text(text=receive_translation(
"event_alteration_delete_confirmed", user_language))
elif query.data.split('_')[-1] == 'no':
query.edit_message_text(text=receive_translation(
"event_alteration_delete_aborted", user_language))
UserEventAlterationMachine.set_state_of_user(user_id, 0)
