def statistics_handler(call_back):
user = g.current_tbot_user
rates = user.get_rates()
if not sum(rates.values()):
answer = "Пока что нет оценок."
else:
avg_rate = sum([r * rates[r] for r in rates]) / sum(rates.values())
stars = emoji["star"] * int(round(avg_rate))
answer = "Средняя оценка: {0}\n{1} ({2})".format(
round(avg_rate, 1), stars, sum(rates.values())
)
if user.tg_id in ids.values():
admin_statistics = user.get_admin_statistics()
admin_answer = (
"Количество пользователей: {0}\n"
"Количество групп: {1}\n"
"Количество преподавателей: {2}\n"
"Количество пользователей с активной рассылкой: {3}"
).format(*admin_statistics)
bot.send_message(
chat_id=user.tg_id,
text=admin_answer
)
try:
bot.edit_message_text(text=answer,
chat_id=call_back.message.chat.id,
message_id=call_back.message.message_id,
parse_mode="HTML")
except ApiException:
pass
def settings_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = "Настройки"
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=settings_keyboard())
def home_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = "Главное меню"
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=main_keyboard())
def rate_handler(message):
user = g.current_tbot_user
bot.send_message(chat_id=user.tg_id,
text="Оцените качество сервиса:",
parse_mode="HTML",
reply_markup=rate_keyboard(user.rate or 0))
def fast_trail_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
if message.text.title() == "В Универ":
from_code = user.home_station_code
to_code = user.univer_station_code
else:
from_code = user.univer_station_code
to_code = user.home_station_code
answer, is_tomorrow, is_error = nf.create_suburbans_answer(
from_code=from_code, to_code=to_code, for_date=date.today())
if not is_error:
if is_tomorrow:
bot.send_message(chat_id=user.tg_id,
text=emoji["warning"] +
" На сегодня нет электричек")
inline_keyboard = update_keyboard(for_tomorrow=is_tomorrow)
else:
inline_keyboard = InlineKeyboardMarkup()
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=inline_keyboard,
parse_mode='HTML',
disable_web_page_preview=True)
def start_handler(message):
if current_app.config["BOT_NAME"] != "Spbu4UBot" \
and message.chat.id not in ids.values():
bot.reply_to(message, "Это тестовый бот. Используйте @Spbu4UBot")
elif re.match(r"^/start[= ]([ge])(\d+)$", message.text):
r_groups = re.match(r"^/start[= ]([ge])(\d+)$", message.text).groups()
bot_msg = bot.send_message(chat_id=message.chat.id,
text="Автрегистрация..")
try_auto_reg(o_id=int(r_groups[1]),
is_edu=r_groups[0] == "e",
tg_id=message.chat.id,
bot_msg_id=bot_msg.message_id)
else:
bot.send_message(
chat_id=message.chat.id,
text="Приветствую!" if message.text == "/start" else "Перезайти",
reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True,
one_time_keyboard=False).row(alt_reg_text).row(
"Завершить", "Поддержка"))
bot.send_message(
chat_id=message.chat.id,
text="Для начала выбери в качестве кого ты хочешь зайти:",
reply_markup=select_status_keyboard(),
parse_mode="HTML")
def problem_text_handler(message):
bot.send_chat_action(message.chat.id, "typing")
bot.send_message(chat_id=message.chat.id,
text=support_answer,
disable_web_page_preview=True,
parse_mode="HTML")
def try_auto_reg(o_id, is_edu, tg_id, bot_msg_id):
"""
Registers user if it possible or sends error message
:param o_id: an object id (educator or group)
:type o_id: int
:param is_edu: if the user is an educator
:type is_edu: bool
:param tg_id: the user's telegram chat id
:type tg_id: int
:param bot_msg_id: the bot's sent message id
:type bot_msg_id: int
:return:
"""
try:
user = User.reg_user(o_id=o_id, is_edu=is_edu, tg_id=tg_id)
except spbu.ApiException:
bot.edit_message_text(text="Ошибка в ID!",
chat_id=tg_id,
message_id=bot_msg_id)
except Exception:
bot.edit_message_text(text="Неизвестная ошибка!",
chat_id=tg_id,
message_id=bot_msg_id)
else:
bot.edit_message_text(text="Готово!",
chat_id=user.tg_id,
message_id=bot_msg_id)
bot.send_message(text=main_menu_first_answer,
parse_mode="HTML",
chat_id=user.tg_id,
reply_markup=main_keyboard())
def schedule_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = "Меню расписания"
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=schedule_keyboard())
def select_day_choose_educator_handler(call_back):
iso_day_date = list((datetime.today() + server_timedelta).isocalendar())
if iso_day_date[2] == 7:
iso_day_date[1] += 1
iso_day_date[2] = week_day_number[week_day_titles[call_back.data]]
day_date = func.date_from_iso(iso_day_date)
answer_data = func.get_lessons_with_educators(call_back.message.chat.id,
day_date)
day_string = answer_data["date"]
bot.edit_message_text(chat_id=call_back.message.chat.id,
text="{0} {1}".format(emoji["calendar"], day_string),
message_id=call_back.message.message_id)
answer = "Вот список подходящих занятий:\n\n"
answer += answer_data["answer"]
inline_keyboard = InlineKeyboardMarkup()
if not answer_data["is_empty"]:
for event in answer_data["answer"].split("\n\n"):
button_text = "{0}".format(
event.split("\n")[0].strip(" {0}".format(
emoji["cross_mark"]))[3:-4])
inline_keyboard.row(*[
InlineKeyboardButton(
text=name, callback_data=name[:max_inline_button_text_len])
for name in [button_text]
])
inline_keyboard.row(
InlineKeyboardButton(text="Отмена", callback_data="Отмена"))
answer += "\n\nВыбери необходиое занятие:"
bot.send_message(text=answer,
chat_id=call_back.message.chat.id,
parse_mode="HTML",
reply_markup=inline_keyboard)
def input_educator_name_handler(call_back):
bot.edit_message_text(text=call_back.data,
chat_id=call_back.message.chat.id,
message_id=call_back.message.message_id)
bot.send_message(chat_id=call_back.message.chat.id,
text=ask_to_input_educator_register,
reply_markup=ForceReply(),
parse_mode="HTML")
def hide_lesson_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
bot.send_message(chat_id=user.tg_id,
text=hide_answer,
reply_markup=week_day_keyboard(for_editor=True))
def help_handler(message):
bot.send_chat_action(message.chat.id, "typing")
bot.send_message(chat_id=message.chat.id,
text=briefly_info_answer,
parse_mode="HTML",
reply_markup=special_thanks_keyboard(),
disable_web_page_preview=True)
def week_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
bot.send_message(chat_id=user.tg_id,
text="Выбери день:",
reply_markup=week_day_keyboard())
def alt_reg_handler(message):
bot.send_chat_action(message.chat.id, "typing")
bot.send_message(chat_id=message.chat.id,
text=alt_reg_answer,
disable_web_page_preview=True,
parse_mode="HTML",
reply_markup=link_button(text="Открыть сайт"))
def schedule_editor_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = "Редактор расписания"
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=schedule_editor_keyboard(),
parse_mode='HTML')
def educator_schedule_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
bot.send_message(chat_id=user.tg_id,
text=ask_to_input_educator,
reply_markup=ForceReply(),
parse_mode="HTML")
def watcher():
for q in (Educator, Group):
for obj in q.query.filter(q.id != 0).all():
if obj.update_hash(requests.get(obj.get_tt_link(is_api=True)).content):
for user in obj.current_members.filter_by(is_subscribed=True):
bot.send_message(
chat_id=user.tg_id,
text=schedule_changed_answer,
reply_markup=current_week_keyboard()
)
db.session.commit()
def place_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
bot.send_message(
chat_id=user.tg_id,
text=place_editor_answer.format(
"Полностью" if user.is_full_place else "Только аудитория"),
parse_mode="HTML",
reply_markup=place_keyboard(user.is_full_place))
def sending_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
bot.send_message(
chat_id=user.tg_id,
text=sending_info_answer,
parse_mode="HTML",
reply_markup=sending_keyboard(user.is_subscribed)
)
def suburban_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = "Меню расписания электричек\n\n" \
"Данные предоставлены сервисом " \
"<a href = 'http://rasp.yandex.ru/'>Яндекс.Расписания</a>"
bot.send_message(chat_id=user.tg_id,
text=answer,
reply_markup=suburban_keyboard(),
parse_mode='HTML',
disable_web_page_preview=True)
def exit_handler(message):
bot.send_chat_action(message.chat.id, "typing")
user = User.query.filter_by(tg_id=message.chat.id).first()
if user:
user.clear_all()
db.session.delete(user)
db.session.commit()
bot.send_message(chat_id=message.chat.id,
text="До встречи!",
reply_markup=ReplyKeyboardRemove())
def feedback_handler(call_back):
user = g.current_tbot_user
bot.edit_message_text(
chat_id=user.tg_id,
text="Обратная связь",
message_id=call_back.message.message_id
)
bot.send_message(
chat_id=user.tg_id,
text=ask_to_feedback,
reply_markup=ForceReply()
)
def select_block_choose_lesson_handler(call_back):
user = g.current_tbot_user
bot.edit_message_text(chat_id=call_back.message.chat.id,
text="{0} {1}".format(emoji["calendar"],
call_back.data),
message_id=call_back.message.message_id)
block = user.get_selectable_blocks()[call_back.data]
bot.send_message(chat_id=user.tg_id,
text=user.parse_selectable_block(block),
reply_markup=block_lessons_keyboard(block),
parse_mode="HTML")
def templates_handler(message):
user = g.current_tbot_user
bot.send_chat_action(user.tg_id, "typing")
answer = templates_answer.format(
user.get_current_status_title()
)
bot.send_message(
chat_id=user.tg_id,
text=answer,
reply_markup=status_templates_keyboard(),
parse_mode="HTML"
)
def select_educator(message):
bot.send_chat_action(message.chat.id, "typing")
name = message.text.strip(". ")
if not nf.is_correct_educator_name(name):
error_answer = "Недопустимые символы!"
is_error = True
else:
data = spbu.search_educator(name)
if not data["Educators"] or len(data["Educators"]) > 10:
if data["Educators"]:
error_answer = "Слишком много преподавателей!"
else:
error_answer = "Никого не найдено!"
is_error = True
else:
is_error = False
error_answer = ""
bot.send_message(
chat_id=message.chat.id,
text="Готово!",
reply_markup=ReplyKeyboardMarkup(resize_keyboard=True,
one_time_keyboard=False).row(
"Завершить", "Поддержка"))
bot.send_message(chat_id=message.chat.id,
text="Выбери преподавателя:",
reply_markup=found_educators_keyboard(data))
if is_error:
bot.send_message(chat_id=message.chat.id, text=error_answer)
bot.send_message(chat_id=message.chat.id,
text=ask_to_input_educator_register,
reply_markup=ForceReply())
def users_callback_handler(message):
user = g.current_tbot_user
bot.send_chat_action(message.chat.id, "typing")
bot.forward_message(
chat_id=ids["my"],
from_chat_id=user.tg_id,
message_id=message.message_id
)
bot.send_message(
chat_id=user.tg_id,
text="Записал",
reply_markup=main_keyboard(),
reply_to_message_id=message.message_id
)
def run_bot(update):
tic = time()
was_error = False
answer = "No error"
try:
bot.process_new_updates([update])
except ApiException as ApiExcept:
was_error = True
json_err = loads(ApiExcept.result.text)
if json_err["description"] == "Forbidden: tg_bot was blocked by " \
"the user":
if update.message:
chat_id = update.message.chat.id
else:
chat_id = update.callback_query.message.chat.id
user = User.query.filter_by(tg_id=chat_id).first()
user.clear_all()
db.session.delete(user)
db.session.commit()
logging.info("USER LEFT {0}".format(
update.message.chat.id))
else:
logging.info("ERROR: {0}".format(
json_err["description"]))
except Exception as err:
answer = other_error_answer
was_error = True
bot.send_message(
chat_id=ids["my"],
text=str(err)
)
finally:
if was_error:
if update.message:
chat_id = update.message.chat.id
else:
chat_id = update.callback_query.message.chat.id
bot.send_message(
chat_id=chat_id,
text=answer,
disable_web_page_preview=True,
parse_mode="HTML"
)
nf.write_log(update, time() - tic, was_error)
def exit_handler(message):
bot_msg = bot.send_message(chat_id=message.chat.id,
text="Автрегистрация..")
res = re.search(reg_tt_e_link, message.text)
if res:
is_edu = True
else:
res = re.search(reg_tt_g_link, message.text)
is_edu = False
try_auto_reg(o_id=int(res.groups()[1]),
is_edu=is_edu,
tg_id=message.chat.id,
bot_msg_id=bot_msg.message_id)
def wrapper(message):
was_error, answer = False, "None"
try:
func(message)
except ConnectTimeout:
was_error, answer = True, connect_timeout_answer
except ReadTimeout:
was_error, answer = True, read_timeout_answer
except spbu.ApiException:
was_error, answer = True, spbu_api_exception_answer
finally:
if was_error:
if g.current_tbot_user:
link = g.current_tbot_user.get_current_tt_link()
else:
link = None
bot.send_message(
chat_id=message.chat.id,
text=answer,
reply_markup=link_button(link=link),
parse_mode="HTML"
)
