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)