def choose_week(message, bot, storage, tz, last_msg=None):
global aud_list
chat_id = message.chat.id
message = message.text
if ('На текущую неделю' == message or 'На следующую неделю' == message):
request_word = aud_list[chat_id][1]
request_aud = storage.get_schedule_aud(request_word)
# Если есть запрос для группы, то формируем расписание для группы, а если нет, то для препода
schedule = request_aud[0]
if not schedule:
schedule_processing.sending_schedule_is_not_available_search(
message=message, chat_id=chat_id, bot=bot)
return
schedule = schedule['schedule']
week = find_week()
# меняем неделю
if message == 'На следующую неделю':
week = 'odd' if week == 'even' else 'even'
week_name = 'четная' if week == 'odd' else 'нечетная'
aud = request_word
schedule_str = full_schedule_in_str_prep(schedule, week=week, aud=aud)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
bot.send_message(chat_id=chat_id,
text=f'Расписание {request_word}\n'
f'Неделя: {week_name}',
reply_markup=keyboards.make_keyboard_start_menu())
# Отправка расписания
schedule_processing.sending_schedule(bot=bot,
chat_id=chat_id,
schedule_str=schedule_str)
bot.clear_step_handler_by_chat_id(chat_id=chat_id)
def get_schedule(bot, message, storage, tz):
chat_id = message.chat.id
data = message.text
user = storage.get_user(chat_id=chat_id)
if 'Расписание 🗓' == data and user.get('group'):
bot.send_message(
chat_id=chat_id,
text='Выберите период\n',
reply_markup=keyboards.make_keyboard_choose_schedule())
statistics.add(action='Расписание', storage=storage, tz=tz)
if ('На текущую неделю' == data
or 'На следующую неделю' == data) and user.get('group'):
# Если курс нуль, тогда это преподаватель
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule_prep(group=group)
if not schedule or schedule['schedule'] == []:
bot.send_message(
chat_id=chat_id,
text='Расписание временно недоступно\nПопробуйте позже⏱')
statistics.add(action=data, storage=storage, tz=tz)
return
schedule = schedule['schedule']
week = find_week()
# меняем неделю
if data == 'На следующую неделю':
week = 'odd' if week == 'even' else 'even'
week_name = 'четная' if week == 'odd' else 'нечетная'
if storage.get_user(chat_id=chat_id)['course'] != 'None':
schedule_str = full_schedule_in_str(schedule, week=week)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
schedule_str = full_schedule_in_str_prep(schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
bot.send_message(chat_id=chat_id,
text=f'Расписание {group}\n'
f'Неделя: {week_name}',
reply_markup=keyboards.make_keyboard_start_menu())
# Отправка расписания
schedule_processing.sending_schedule(bot=bot,
chat_id=chat_id,
schedule_str=schedule_str)
statistics.add(action=data, storage=storage, tz=tz)
elif 'Расписание на сегодня 🍏' == data and user.get('group'):
# Если курс нуль, тогда это преподаватель
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule_prep(group=group)
if not schedule:
bot.send_message(chat_id=chat_id,
text='Расписание временно недоступно🚫😣\n'
'Попробуйте позже⏱',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Расписание на сегодня',
storage=storage,
tz=tz)
return
schedule = schedule['schedule']
week = find_week()
# Если курс нуль, тогда это преподаватель
if storage.get_user(chat_id=chat_id)['course'] != 'None':
schedule_one_day = get_one_day_schedule_in_str(schedule=schedule,
week=week)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
schedule_one_day = get_one_day_schedule_in_str_prep(
schedule=schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(schedule_one_day, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
if not schedule_one_day:
bot.send_message(chat_id=chat_id, text='Сегодня пар нет 😎')
return
bot.send_message(chat_id=chat_id, text=f'{schedule_one_day}')
statistics.add(action='Расписание на сегодня', storage=storage, tz=tz)
elif 'Экзамены' in data and user.get('group'):
# Если курс нуль, тогда это преподаватель
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = groups_exam(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = groups_exam(group=group)
if not schedule:
bot.send_message(chat_id=chat_id,
text='Расписание экзаменов отсутствует😇\n'
'Попробуйте позже⏱',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Экзамены', storage=storage, tz=tz)
return
# schedule = schedule['schedule']
if storage.get_user(chat_id=chat_id)['course'] != 'None':
schedule_exams = schedule_view_exams(schedule=schedule)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
schedule_exams = schedule_view_exams(schedule=schedule)
# Проверяем, что расписание сформировалось
if isinstance(schedule_exams, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
schedule_processing.sending_schedule(bot=bot,
chat_id=chat_id,
schedule_str=schedule_exams)
statistics.add(action='Экзамены', storage=storage, tz=tz)
elif 'Расписание на завтра 🍎' == data and user.get('group'):
# Если курс нуль, тогда это преподаватель
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule_prep(group=group)
if not schedule:
bot.send_message(chat_id=chat_id,
text='Расписание временно недоступно🚫😣\n'
'Попробуйте позже⏱',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Расписание на завтра',
storage=storage,
tz=tz)
return
schedule = schedule['schedule']
week = find_week()
if datetime.today().isoweekday() == 7:
if week == 'odd':
week = 'even'
elif week == 'even':
week = 'odd'
else:
week = 'all'
if storage.get_user(chat_id=chat_id)['course'] != 'None':
schedule_next_day = get_next_day_schedule_in_str(schedule=schedule,
week=week)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
schedule_next_day = get_next_day_schedule_in_str_prep(
schedule=schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(schedule_next_day, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
if not schedule_next_day:
bot.send_message(chat_id=chat_id, text='Завтра пар нет 😎')
return
bot.send_message(chat_id=chat_id, text=f'{schedule_next_day}')
statistics.add(action='Расписание на завтра', storage=storage, tz=tz)
elif 'Ближайшая пара ⏱' in data and user.get('group'):
bot.send_message(chat_id=chat_id,
text='Ближайшая пара',
reply_markup=keyboards.make_keyboard_nearlesson())
statistics.add(action='Ближайшая пара', storage=storage, tz=tz)
return
elif 'Текущая' in data and user.get('group'):
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule_prep(group=group)
if not schedule:
bot.send_message(chat_id=chat_id,
text='Расписание временно недоступно🚫😣\n'
'Попробуйте позже⏱',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Текущая', storage=storage, tz=tz)
return
schedule = schedule['schedule']
week = find_week()
now_lessons = get_now_lesson(schedule=schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(now_lessons, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
# если пар нет
if not now_lessons:
bot.send_message(chat_id=chat_id,
text='Сейчас пары нет, можете отдохнуть)',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Текущая', storage=storage, tz=tz)
return
# Студент
if storage.get_user(chat_id=chat_id)['course'] != 'None':
now_lessons_str = get_now_lesson_in_str_stud(now_lessons)
# Преподаватель
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
now_lessons_str = get_now_lesson_in_str_prep(now_lessons)
# Проверяем, что расписание сформировалось
if isinstance(now_lessons_str, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
bot.send_message(chat_id=chat_id,
text=f'🧠Текущая пара🧠\n'
f'{now_lessons_str}',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Текущая', storage=storage, tz=tz)
elif 'Следующая' in data and user.get('group'):
if storage.get_user(chat_id=chat_id)['course'] != 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule(group=group)
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
group = storage.get_user(chat_id=chat_id)['group']
schedule = storage.get_schedule_prep(group=group)
if not schedule:
bot.send_message(chat_id=chat_id,
text='Расписание временно недоступно🚫😣\n'
'Попробуйте позже⏱',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Следующая', storage=storage, tz=tz)
return
schedule = schedule['schedule']
week = find_week()
near_lessons = get_near_lesson(schedule=schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(near_lessons, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
# если пар нет
if not near_lessons:
bot.send_message(chat_id=chat_id,
text='Сегодня больше пар нет 😎',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Следующая', storage=storage, tz=tz)
return
# Студент
if storage.get_user(chat_id=chat_id)['course'] != 'None':
near_lessons_str = get_now_lesson_in_str_stud(near_lessons)
# Преподаватель
elif storage.get_user(chat_id=chat_id)['course'] == 'None':
near_lessons_str = get_now_lesson_in_str_prep(near_lessons)
# Проверяем, что расписание сформировалось
if isinstance(near_lessons_str, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
bot.send_message(chat_id=chat_id,
text=f'🧠Ближайшая пара🧠\n'
f'{near_lessons_str}',
reply_markup=keyboards.make_keyboard_start_menu())
statistics.add(action='Следующая', storage=storage, tz=tz)
async def search(bot: Bot, ans: Message, storage):
"""Стейт для работы поиска"""
# Чат ID пользователя
chat_id = ans.from_id
# Данные ввода
data = ans.text
# Соответствия по группам
all_found_groups = []
# Соответствия для преподов
all_found_prep = []
# Задаём состояние для первой страницы
page = 1
# Логирование для информации в рил-тайм
logger.info(f'Inline button data: {data}')
# Условие для первичного входа пользователя
if (storage.get_search_list(ans.text) or storage.get_search_list_prep(ans.text)) \
and Condition_request[chat_id] == []:
# Результат запроса по группам
request_group = storage.get_search_list(ans.text)
# Результат запроса по преподам
request_prep = storage.get_search_list_prep(ans.text)
# Циклы нужны для общего поиска. Здесь мы удаляем старые ключи в обоих реквестах и создаём один общий ключ, как для групп, так и для преподов
for i in request_group:
i['search'] = i.pop('name')
for i in request_prep:
i['search'] = i.pop('prep_short_name')
# Записываем слово, которое ищем
request_word = ans.text
# Склеиваем результаты двух запросов для общего поиска
request = request_group + request_prep
# Отправляем в функцию данные для создания клавиатуры
keyboard = keyboards.make_keyboard_search_group(page, request)
# Эти циклы записывают группы и преподов в нижнем регистре для удобной работы с ними
for i in request_group:
all_found_groups.append(i['search'].lower())
for i in request_prep:
all_found_prep.append(i['search'].lower())
# Создаём общий список
all_found_results = all_found_groups + all_found_prep
# Формируем полный багаж для пользователя
list_search = [page, request_word, all_found_results]
# Записываем все данные под ключом пользователя
Condition_request[chat_id] = list_search
# Выводим результат поиска с клавиатурой (кливиатур формируется по поисковому запросу)
await ans.answer("Результат поиска", keyboard=keyboard)
# Здесь уловия для выхода в основное меню
elif ans.text == "Основное меню":
del Condition_request[ans.from_id]
await ans.answer("Основное меню",
keyboard=keyboards.make_keyboard_start_menu())
await bot.state_dispenser.delete(ans.peer_id)
# Здесь уловие для слова "Дальше"
elif ans.text == "Дальше":
page = Condition_request[ans.from_id][0]
Condition_request[ans.from_id][0] += 1
request_word = Condition_request[ans.from_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
for i in request_group:
i['search'] = i.pop('name')
for i in request_prep:
i['search'] = i.pop('prep_short_name')
request = request_group + request_prep
request = request[26 * page:]
keyboard = keyboards.make_keyboard_search_group(page + 1, request)
await ans.answer(f"Страница {page + 1}", keyboard=keyboard)
# По аналогии со словом "<==Назад", только обратный процесс
elif ans.text == "<==Назад":
Condition_request[ans.from_id][0] -= 1
page = Condition_request[ans.from_id][0]
request_word = Condition_request[ans.from_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
for i in request_group:
i['search'] = i.pop('name')
for i in request_prep:
i['search'] = i.pop('prep_short_name')
request = request_group + request_prep
request = request[26 * (page - 1):]
keyboard = keyboards.make_keyboard_search_group(page, request)
await ans.answer(f"Страница {page}", keyboard=keyboard)
# Условие для вывода расписания для группы и преподавателя по неделям
elif ('На текущую неделю' == data or 'На следующую неделю' == data):
group = Condition_request[ans.from_id][1]
request_word = Condition_request[ans.from_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
# Если есть запрос для группы, то формируем расписание для группы, а если нет, то для препода
if request_group:
schedule = storage.get_schedule(group=group)
elif request_prep:
schedule = request_prep[0]
if schedule['schedule'] == []:
await ans.answer(
'Расписание временно недоступно\nПопробуйте позже⏱')
return
schedule = schedule['schedule']
week = find_week()
# меняем неделю
if data == 'На следующую неделю':
week = 'odd' if week == 'even' else 'even'
week_name = 'четная' if week == 'odd' else 'нечетная'
if request_group:
schedule_str = full_schedule_in_str(schedule, week=week)
elif request_prep:
schedule_str = full_schedule_in_str_prep(schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
await schedule_processing.sending_schedule_is_not_available(ans=ans
)
await bot.state_dispenser.delete(ans.peer_id)
return
await ans.answer(f'Расписание {group}\n'
f'Неделя: {week_name}',
keyboard=keyboards.make_keyboard_start_menu())
# Отправка расписания
await schedule_processing.sending_schedule(ans=ans,
schedule_str=schedule_str)
await bot.state_dispenser.delete(ans.peer_id)
elif 'Экзамены' == data:
group = Condition_request[ans.from_id][1]
request_word = Condition_request[ans.from_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
# Объявляем переменную с расписанием экзаменов группы или препода
if request_group:
schedule_str = groups_exam(group)
elif request_prep:
schedule_str = groups_exam(group)
# При отсутствии расписания выводится соответствующее предупреждение
if schedule_str == 0:
await ans.answer(
'Расписание экзаменов отсутствует😇\nПопробуйте позже⏱')
return
# Задаем расписанию экзаменов вид для подачи пользователю
schedule_exams = schedule_view_exams(schedule=schedule_str)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
await schedule_processing.sending_schedule_is_not_available(ans=ans
)
await bot.state_dispenser.delete(ans.peer_id)
return
# Отправка расписания
await schedule_processing.sending_schedule(ans=ans,
schedule_str=schedule_exams)
await bot.state_dispenser.delete(ans.peer_id)
# Условия для завершения поиска, тобишь окончательный выбор пользователя
elif (storage.get_search_list(ans.text) or storage.get_search_list_prep(ans.text)) and ans.text.lower() in \
(i for i in Condition_request[ans.from_id][2]):
choose = ans.text
Condition_request[ans.from_id][1] = choose
request_word = Condition_request[ans.from_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
for i in request_group:
i['search'] = i.pop('name')
for i in request_prep:
i['search'] = i.pop('prep_short_name')
if request_group:
await ans.answer(
f"Выберите неделю для группы {choose}",
keyboard=keyboards.make_keyboard_choose_schedule())
elif request_prep:
await ans.answer(
f"Выберите неделю для преподавателя {request_prep[0]['prep']}",
keyboard=keyboards.
make_keyboard_choose_schedule_for_aud_search())
else:
return
# Общее исключения для разных случаем, которые могу сломать бота. (Практически копия первого IF)
else:
if Condition_request[ans.from_id] and storage.get_search_list(
ans.text) or storage.get_search_list_prep(ans.text):
request_group = storage.get_search_list(ans.text)
request_prep = storage.get_search_list_prep(ans.text)
for i in request_group:
i['search'] = i.pop('name')
for i in request_prep:
i['search'] = i.pop('prep_short_name')
request_word = ans.text
request = request_group + request_prep
keyboard = keyboards.make_keyboard_search_group(page, request)
for i in request_group:
all_found_groups.append(i['search'].lower())
for i in request_prep:
all_found_prep.append(i['search'].lower())
all_found_results = all_found_groups + all_found_prep
list_search = [page, request_word, all_found_results]
Condition_request[chat_id] = list_search
await ans.answer("Результат поиска", keyboard=keyboard)
else:
if len(Condition_request[chat_id]) == 3:
Condition_request[chat_id][1] = ''
await ans.answer('Поиск не дал результатов 😕')
return
else:
await ans.answer('Поиск не дал результатов 😕')
return
def search(message, bot, storage, tz, last_msg=None):
"""Регистрация преподавателя"""
global Condition_request
data = message
chat_id = message.chat.id
message = message.text
all_found_groups = []
all_found_prep = []
page = 0
if data.content_type == 'sticker':
message = ''
if last_msg:
try:
bot.delete_message(last_msg.chat.id, last_msg.message_id)
except Exception as e:
pass
if storage.get_search_list(message) or storage.get_search_list_prep(
message):
# Результат запроса по группам
request_group = storage.get_search_list(message)
# Результат запроса по преподам
request_prep = storage.get_search_list_prep(message)
# Циклы нужны для общего поиска. Здесь мы удаляем старые ключи в обоих реквестах и создаём один общий ключ,
# как для групп, так и для преподов
for i in request_group:
i['found_prep'] = i.pop('name')
for i in request_prep:
i['found_prep'] = i.pop('prep_short_name')
# Записываем слово, которое ищем
request_word = message
# Склеиваем результаты двух запросов для общего поиска
request = request_group + request_prep
last_request = request[-1]
# Отправляем в функцию данные для создания клавиатуры
# Эти циклы записывают группы и преподов в нижнем регистре для удобной работы с ними
for i in request_group:
all_found_groups.append(i['found_prep'].lower())
for i in request_prep:
all_found_prep.append(i['found_prep'].lower())
# Создаём общий список
all_found_results = all_found_groups + all_found_prep
# Формируем полный багаж для пользователя
list_search = [page, request_word, all_found_results]
# Записываем все данные под ключом пользователя
Condition_request[chat_id] = list_search
# Выводим результат поиска с клавиатурой (кливиатур формируется по поисковому запросу)
if len(request) > 10:
requests = request[:10 * (page + 1)]
more_than_10 = True
msg = bot.send_message(
chat_id=chat_id,
text='Результат поиска',
reply_markup=keyboards.make_keyboard_search_group(
last_request=last_request,
page=page,
more_than_10=more_than_10,
requests=requests))
bot.register_next_step_handler(msg,
search,
bot=bot,
storage=storage,
tz=tz,
last_msg=msg)
else:
msg = bot.send_message(
chat_id=chat_id,
text='Результат поиска',
reply_markup=keyboards.make_keyboard_search_group(
last_request=last_request,
page=page,
more_than_10=False,
requests=request))
bot.register_next_step_handler(msg,
search,
bot=bot,
storage=storage,
tz=tz,
last_msg=msg)
elif ('На текущую неделю' == message or 'На следующую неделю' == message):
group = Condition_request[chat_id][1]
request_word = Condition_request[chat_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
# Если есть запрос для группы, то формируем расписание для группы, а если нет, то для препода
if request_group:
schedule = storage.get_schedule(group=group)
elif request_prep:
schedule = request_prep[0]
if not schedule:
bot.send_message(
chat_id=chat_id,
text='Расписание временно недоступно\nПопробуйте позже⏱')
return
schedule = schedule['schedule']
week = find_week()
# меняем неделю
if message == 'На следующую неделю':
week = 'odd' if week == 'even' else 'even'
week_name = 'четная' if week == 'odd' else 'нечетная'
if request_group:
schedule_str = full_schedule_in_str(schedule, week=week)
elif request_prep:
schedule_str = full_schedule_in_str_prep(schedule, week=week)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
bot.send_message(chat_id=chat_id,
text=f'Расписание {group}\n'
f'Неделя: {week_name}',
reply_markup=keyboards.make_keyboard_start_menu())
# Отправка расписания
schedule_processing.sending_schedule(bot=bot,
chat_id=chat_id,
schedule_str=schedule_str)
bot.clear_step_handler_by_chat_id(chat_id=chat_id)
elif 'Экзамены' == message:
group = Condition_request[chat_id][1]
request_word = Condition_request[chat_id][1]
request_group = storage.get_search_list(request_word)
request_prep = storage.get_search_list_prep(request_word)
# Объявляем переменную с расписанием экзаменов группы или препода
if request_group:
schedule_str = groups_exam(group)
elif request_prep:
schedule_str = groups_exam(group)
# При отсутствии расписания выводится соответствующее предупреждение
if not schedule_str:
bot.send_message(
chat_id=chat_id,
text='Расписание экзаменов отсутствует😇\nПопробуйте позже⏱')
return
# Задаем расписанию экзаменов вид для подачи пользователю
schedule_exams = schedule_view_exams(schedule=schedule_str)
# Проверяем, что расписание сформировалось
if isinstance(schedule_exams, APIError):
schedule_processing.sending_schedule_is_not_available(
bot=bot, chat_id=chat_id)
return
# Отправка расписания
schedule_processing.sending_schedule(bot=bot,
chat_id=chat_id,
schedule_str=schedule_exams)
bot.clear_step_handler_by_chat_id(chat_id=chat_id)
elif 'Основное меню' == message:
bot.send_message(chat_id=chat_id,
text='Основное меню',
reply_markup=keyboards.make_keyboard_start_menu())
bot.clear_step_handler_by_chat_id(chat_id=chat_id)
return
else:
msg = bot.send_message(
chat_id=chat_id,
text='Проверьте правильность ввода 😞',
reply_markup=keyboards.make_keyboard_main_menu())
bot.register_next_step_handler(msg,
search,
bot=bot,
storage=storage,
tz=tz,
last_msg=msg)
return
async def search(bot: Bot, ans: Message, storage):
"""Стейт поиска по аудиториям"""
global aud_list
# Чат ID пользователя
chat_id = ans.from_id
# Данные ввода
data = ans.text
# Соответствия по группам
all_found_aud = []
# Соответствия для преподов
# Задаём состояние для первой страницы
page = 1
prep_list = []
all_results = []
if not storage.get_schedule_aud(data) and len(ans.text.replace(' ',
'')) < 15:
# Отправляем запросы в базу посимвольно
for item in data:
# Получаем все результаты запроса на каждый символ
request_item_all = storage.get_schedule_aud(item)
# Проходим по каждому результату запроса одного символа
for i in range(len(request_item_all)):
# Обращаемся к результатам у которых есть ключ "aud"
request_item = request_item_all[i]['aud']
# Записывем все совпадения (Значения ключа "aud")
prep_list.append(request_item)
request_item = []
request_item_all = []
# Выделение наиболее повторяющихся элементов(а). Фактически результат запроса пользователя.
qty_most_common = 0
prep_list_set = set(prep_list)
for item in prep_list_set:
qty = prep_list.count(item)
if qty > qty_most_common:
qty_most_common = qty
# Переменная с результатом сортировки
if ans.text.replace(' ', '').lower() in item.replace('-',
'').lower():
all_results.append(item.lower())
# Условие для первичного входа пользователя
if storage.get_schedule_aud(
data) and aud_list[chat_id] == [] and not all_results:
# Результат запроса по аудам
request_aud = storage.get_schedule_aud(data)
# Циклы нужны для общего поиска. Здесь мы удаляем старые ключи в обоих реквестах и создаём один общий ключ, как для групп, так и для преподов
for i in request_aud:
i['search'] = i.pop('aud')
# Записываем слово, которое ищем
request_word = data
# Отправляем в функцию данные для создания клавиатуры
keyboard = keyboards.make_keyboard_search_group(page, request_aud)
# Эти циклы записывают группы и преподов в нижнем регистре для удобной работы с ними
for i in request_aud:
all_found_aud.append(i['search'].lower())
# Формируем полный багаж для пользователя
list_search = [page, request_word, all_found_aud]
# Записываем все данные под ключом пользователя
aud_list[chat_id] = list_search
# Выводим результат поиска с клавиатурой (кливиатур формируется по поисковому запросу)
await ans.answer("Результат поиска", keyboard=keyboard)
return
if all_results and aud_list[chat_id] == []:
all_found_aud = all_results
request_word = data
keyboard = keyboards.make_keyboard_search_group(page, all_found_aud)
list_search = [page, request_word, all_found_aud]
aud_list[chat_id] = list_search
await ans.answer("Результат поиска", keyboard=keyboard)
# Здесь уловия для выхода в основное меню
elif data == "Основное меню":
del aud_list[ans.from_id]
await ans.answer("Основное меню",
keyboard=keyboards.make_keyboard_start_menu())
await bot.state_dispenser.delete(ans.peer_id)
# Здесь уловие для слова "Дальше"
elif data == "Дальше":
page = aud_list[ans.from_id][0]
aud_list[ans.from_id][0] += 1
request_word = aud_list[ans.from_id][1]
request_aud = storage.get_schedule_aud(request_word)
for i in request_aud:
i['search'] = i.pop('aud')
request_aud = request_aud[26 * page:]
keyboard = keyboards.make_keyboard_search_group(page + 1, request_aud)
await ans.answer(f"Страница {page + 1}", keyboard=keyboard)
# По аналогии со словом "<==Назад", только обратный процесс
elif data == "<==Назад":
aud_list[ans.from_id][0] -= 1
page = aud_list[ans.from_id][0]
request_word = aud_list[ans.from_id][1]
request_aud = storage.get_schedule_aud(request_word)
for i in request_aud:
i['search'] = i.pop('aud')
request_aud = request_aud[26 * (page - 1):]
keyboard = keyboards.make_keyboard_search_group(page, request_aud)
await ans.answer(f"Страница {page}", keyboard=keyboard)
# Условие для вывода расписания для группы и преподавателя по неделям
elif ('На текущую неделю' == data or 'На следующую неделю' == data):
group = aud_list[ans.from_id][1]
request_word = aud_list[ans.from_id][1]
request_aud = storage.get_schedule_aud(request_word)
# Если есть запрос для группы, то формируем расписание для группы, а если нет, то для препода
schedule = request_aud[0]
if schedule['schedule'] == []:
await schedule_processing.sending_schedule_is_not_available(ans=ans
)
return
schedule = schedule['schedule']
week = find_week()
# меняем неделю
if data == 'На следующую неделю':
week = 'odd' if week == 'even' else 'even'
week_name = 'четная' if week == 'odd' else 'нечетная'
aud = request_word
schedule_str = full_schedule_in_str_prep(schedule, week=week, aud=aud)
# Проверяем, что расписание сформировалось
if isinstance(schedule_str, APIError):
await schedule_processing.sending_schedule_is_not_available(ans=ans
)
await bot.state_dispenser.delete(ans.peer_id)
return
await ans.answer(f'Расписание {group}\n'
f'Неделя: {week_name}',
keyboard=keyboards.make_keyboard_start_menu())
# Отправка расписания
await schedule_processing.sending_schedule(ans=ans,
schedule_str=schedule_str)
await bot.state_dispenser.delete(ans.peer_id)
# Условия для завершения поиска, тобишь окончательный выбор пользователя
elif storage.get_schedule_aud(data) and data.lower() in (
i for i in aud_list[ans.from_id][2]):
choose = data
aud_list[ans.from_id][1] = choose
request_word = aud_list[ans.from_id][1]
request_aud = storage.get_schedule_aud(request_word)
for i in request_aud:
i['search'] = i.pop('aud')
await ans.answer(
f"Выберите неделю для аудитории {choose}",
keyboard=keyboards.make_keyboard_choose_schedule_for_aud_search())
return
# Для того, чтобы во время найденного запроса можно было повторить поиск
else:
if aud_list[ans.from_id] and storage.get_schedule_aud(data):
# Результат запроса по аудам
request_aud = storage.get_schedule_aud(data)
# Циклы нужны для общего поиска. Здесь мы удаляем старые ключи в обоих реквестах и создаём один общий ключ, как для групп, так и для преподов
for i in request_aud:
i['search'] = i.pop('aud')
# Записываем слово, которое ищем
request_word = data
# Отправляем в функцию данные для создания клавиатуры
keyboard = keyboards.make_keyboard_search_group(page, request_aud)
# Эти циклы записывают группы и преподов в нижнем регистре для удобной работы с ними
for i in request_aud:
all_found_aud.append(i['search'].lower())
# Формируем полный багаж для пользователя
list_search = [page, request_word, all_found_aud]
# Записываем все данные под ключом пользователя
aud_list[chat_id] = list_search
# Выводим результат поиска с клавиатурой (кливиатур формируется по поисковому запросу)
await ans.answer("Результат поиска", keyboard=keyboard)
else:
try:
if len(aud_list[chat_id]) == 3:
aud_list[chat_id] = []
finally:
if all_results:
keyboard = keyboards.make_keyboard_search_group(
page, all_results)
await ans.answer("Результат поиска", keyboard=keyboard)
else:
await ans.answer(
'Поиск не дал результатов 😕',
keyboard=keyboards.make_keyboard_main_menu())
return