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 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 check_ping_needed(user_id, event, today=True): """Checks if an event needs to be pinged. Args: user_id (int): ID of the user. event (Event): Contains the event that should be checked. today (bool, optional): Indicates whether today or tomorrow is checked. Returns: bool: True if a ping has to be sent. False if not. """ current_time = datetime.now() ping_times = event.ping_times event_month = current_time.month event_day = current_time.day if not today: event_date = current_time + timedelta(days=1) event_day = event_date.day event_month = event_date.month event_time = datetime(year=current_time.year, month=event_month, day=event_day, hour=event.event_time_hours, minute=event.event_time_minutes) needs_ping = False for ping_time in ping_times: # If multiple ping times are already reached ping one time and disable all "used" times. if ping_times[ping_time]: delta = timedelta(hours=int(ping_time.split(':')[0]), minutes=int(ping_time.split(':')[1])) if event_time - delta < current_time: event.ping_times[ping_time] = False needs_ping = True # Save ping times for regularly events if event.event_type == EventType.REGULARLY: event.ping_times_to_refresh[ping_time] = True event_deleted = False # Cleanup event if it is passed if event_time < current_time and not event.start_ping_done: needs_ping = True if event.event_type == EventType.SINGLE: DatabaseController.delete_event_of_user(user_id, event.uuid) event_deleted = True event.start_ping_done = True if needs_ping and not event_deleted: # Save the changes on the event DatabaseController.save_event_data_user(user_id, event) return needs_ping, event_deleted
def _check_event_ping(self, user_id, events, today=True): """Check which events are not already passed and pings the user. Args: user_id (int): ID of the user. events (list of 'Event'): Contains all events of the user for a single day. today (bool, optional): Indicates whether the events of today or tomorrow are checked. Checking today by default. """ bot = BotControl.get_bot() ping_list = [] logger.info("Checking %s | %s", user_id, events) for event in events: ping_needed, event_delete = self.check_ping_needed(user_id, event, today) if ping_needed: event.deleted = event_delete ping_list.append(event) # Only ping if there are events to notify about if ping_list: for event in ping_list: message = self.build_ping_message(user_id, event) if event.deleted: bot.send_message(user_id, text=message, parse_mode=ParseMode.MARKDOWN_V2) else: language = DatabaseController.load_selected_language(user_id) postfix = "_{}".format(event.uuid) bot.send_message(user_id, text=message, parse_mode=ParseMode.MARKDOWN_V2, reply_markup=Event.event_keyboard_alteration(language, "event", postfix))
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 _refresh_start_pings(user_ids, day): """Refreshes the "start ping done" booleans inside the user data for regularly events on the given day. Args: user_ids (dict): Contains all users and their events. day (int): Day which should be refreshed. """ for user_id in user_ids: events = [event for event in DatabaseController.load_user_events(user_id) if event.day == day] for event in events: event.start_ping_done = False # Restore ping times for regularly events for event_ping in event.ping_times_to_refresh: event.ping_times[event_ping] = True event.ping_times_to_refresh = {} DatabaseController.save_event_data_user(user_id, event)
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 __init__(self, user_id, telegram_user=None): """Constructor. Args: user_id (int): ID of the user. telegram_user (telegram.User, optional): Telegram user object. """ self.telegram_user = telegram_user self.user_id = user_id self.user_config = DatabaseController.load_user_config(self.user_id) self.language = self.user_config["language"]
def check_events(self): """Checks the events of all user regularly and pings them.""" while True: user_ids = DatabaseController.load_all_user_ids() today = datetime.today().weekday() self._ping_users(user_ids, today) time.sleep(self.interval) # Check if a new day has begun current_day = datetime.today().weekday() if today != current_day: # Use fresh userdata user_ids = DatabaseController.load_all_user_ids() self._daily_ping_users(user_ids, current_day) # Refresh pings of all events of yesterday user_ids = DatabaseController.load_all_user_ids() self._refresh_start_pings(user_ids, (datetime.today() - timedelta(days=1)).weekday())
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 _ping_users(self, user_ids, day): """Pings all users inside userdata with the events of the given day Args: user_ids (list of 'str'): Contains all users. day (int): Represents the day which should be pinged for. """ tomorrow = day + 1 if day < 6 else 0 for user_id in user_ids: user_events = DatabaseController.load_user_events(user_id) events_of_today = [event for event in user_events if event.day.value == day] events_of_tomorrow = [event for event in user_events if event.day.value == tomorrow] self._check_event_ping(user_id, events_of_today) self._check_event_ping(user_id, events_of_tomorrow, today=False)
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 retrieve_all_events(self): """Retrieve all events of the user. Returns: dict: Contains all events of the user. """ event_list = [] for event in DatabaseController.load_user_events(self.user_id): name = event["name"] day = DayEnum(event["day"]) content = event["content"] event_type = EventType(event["event_type"]) ping_time = event["event_time"] event_list.append(Event(name, day, content, event_type, ping_time)) return event_list
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 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 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_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)
from control.bot_control import BotControl from control.configurator import Configurator from control.database_controller import DatabaseController from control.event_checker import EventChecker from control.event_handler import EventHandler from models.user import User from state_machines.user_event_alteration_machine import UserEventAlterationMachine from state_machines.user_event_creation_machine import UserEventCreationMachine from utils.localization_manager import receive_translation logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) logger = logging.getLogger(__name__) db_controller = DatabaseController() # Define a few command handlers. These usually take the two arguments update and # context. Error handlers also receive the raised TelegramError object in error. 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 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 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 setUpClass(cls): """Set up test.""" cls.dbc = DatabaseController(config_file=TEST_CONFIG, userdata_path=TEST_USER_DATA)