async def subscribe_continue_pay(callback: types.CallbackQuery,
state: FSMContext):
"""Продлить подписку после её окончания"""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
course = DataBaseFunc.get_course(user.course_id)
timestamp = get_timestamp(user)
PRICE = types.LabeledPrice(label=course.name,
amount=int(f"{course.cost}00"))
await state.update_data(last_course_id=user.course_id)
mess = await bot.send_invoice(
callback.message.chat.id,
title=course.name,
description=course.description,
provider_token=TOKEN_SHOP_YANDEX,
currency="rub",
is_flexible=False,
prices=[PRICE],
start_parameter=f"course_id_{course.id}",
payload=timestamp,
# reply_markup=UserGeneratorKeyboard.course_back_in_list(user)
# start_parameter = f"lol-lel-cheburek",
# payload = "test-payload-check"
)
await DataBaseFunc.delete_messages(user)
ms = Message(user_id=user.id, message_id=mess.message_id)
DataBaseFunc.add(ms)
async def managing_user_add_time_write_time(message: types.Message,
state: FSMContext):
"""Ввод времени"""
data = await state.get_data()
user = DataBaseFunc.get_user(message.from_user.id)
try:
time = int(message.text)
await state.update_data(time=time)
await message.delete()
user_addtime = DataBaseFunc.get_user(data['user_deletetime_id'])
await bot.edit_message_text(
text=AdminHelper.get_text_managing_users_delete_time_final(
user_addtime, data['course_id'], time),
chat_id=message.chat.id,
message_id=data['message_id'],
reply_markup=AdminGenerateKeyboard.managing_users_add_time_final(
user))
await AdminStateManagingUser.delete_time_final.set()
except:
await message.delete()
await bot.edit_message_text(
chat_id=message.chat.id,
message_id=data['message_id'],
text=get_text(user, 'managing_user_add_time_write_time_not_str'),
reply_markup=AdminGenerateKeyboard.
managing_users_add_time_choose_time(user))
async def managing_admin_main_menu_add_admin_write_login(
message: types.Message, state: FSMContext):
"""Обработчик ввода логина администратора"""
user = DataBaseFunc.get_user(int(message.from_user.id))
user_message = AdminHelper.get_user_from_message(message)
data = await state.get_data()
if (user_message):
await message.delete()
data = await state.get_data()
user_message.is_admin = True
DataBaseFunc.commit()
await bot.edit_message_text(
chat_id=message.chat.id,
message_id=data['message_id'],
text=get_text(
user, 'managing_admins_main_menu_add_admin_success').format(
username=AdminHelper.escape_telegrambot_underscore(
user_message.username)),
reply_markup=AdminGenerateKeyboard.admin_main_menu(user))
await AdminStateMainMenu.admin_menu.set()
else:
await message.delete()
await bot.edit_message_text(
chat_id=message.chat.id,
message_id=data['message_id'],
text=get_text(user,
'managing_admins_main_menu_add_admin_not_found'),
reply_markup=AdminGenerateKeyboard.
managing_admins_main_menu_add_admin(user))
async def subscribe_menu_choose_course(callback: types.CallbackQuery,
state: FSMContext):
"""Отправляет чек для оплаты выбраноого курса"""
user = DataBaseFunc.get_user(callback.from_user.id)
if (TOKEN_SHOP_YANDEX.split(':')[1] == "TEST"):
await callback.message.edit_text(
text=get_text(user, 'subscribe_menu_test_payments'))
course = DataBaseFunc.get_course(int(callback.data[20:]))
timestamp = get_timestamp(user)
PRICE = types.LabeledPrice(label=course.name,
amount=int(f"{course.cost}00"))
await state.update_data(last_course_id=int(callback.data[20:]))
await bot.send_invoice(
callback.message.chat.id,
title=course.name,
description=course.description,
provider_token=TOKEN_SHOP_YANDEX,
currency="rub",
is_flexible=False,
prices=[PRICE],
start_parameter=f"course_id_{course.id}",
payload=timestamp,
# reply_markup=UserGeneratorKeyboard.course_back_in_list(user)
# start_parameter = f"lol-lel-cheburek",
# payload = "test-payload-check"
)
async def process_successful_payment(message: types.Message,
state: FSMContext):
user = DataBaseFunc.get_user(message.from_user.id)
data = await state.get_data()
course = DataBaseFunc.get_course(user.course_id)
DataBaseFunc.add_course_in_user(user, course)
user.subscribe_end = False
DataBaseFunc.commit()
for channel in course.channels:
try:
await bot.unban_chat_member(chat_id=channel.channels.id,
user_id=user.id)
except:
continue
mess = await bot.send_message(
message.chat.id,
str(get_text(user, 'subscribe_menu_good_pay')).format(
amount=course.cost,
currency=message.successful_payment.currency,
coursename=course.name))
mess2 = await bot.send_message(message.chat.id,
get_text(user, 'start'),
reply_markup=await
UserGeneratorKeyboard.start_button(user))
await DataBaseFunc.delete_messages(user)
ms = Message(user_id=user.id, message_id=mess.message_id)
ms2 = Message(user_id=user.id, message_id=mess2.message_id)
DataBaseFunc.add(ms)
DataBaseFunc.add(ms2)
await UserStateMainMenu.main_menu.set()
def send_message_seven(user):
text = "Добрый день. Ваша подписка на онлайн-курс Юланы Селивановой «Здоровая кожа» заканчивается через неделю. Успейте посмотреть все уроки, которые откладывали на потом. Когда подписка закончится ее можно будет возобновить через бота Telegram."
data = {'chat_id': user.chat_id, 'text': text}
answer = create_requets("POST", "sendMessage", data=data)
message_id = json.loads(answer)['result']["message_id"]
message = Message(user_id=user.id, message_id=message_id)
DataBaseFunc.add(message)
async def menu_profile_choose_language(callback_query:types.CallbackQuery):
"""Обработка выбора языка по кнопке смены."""
await callback_query.answer()
user = DataBaseFunc.get_user(callback_query.from_user.id)
lng = callback_query.data[8:]
user.lng = lng
DataBaseFunc.commit()
await start_menu_profile(callback_query)
await UserStateProfile.menu_profile.set()
async def choose_lng(callback_query: types.CallbackQuery):
"""Меняет язык пользователя"""
user = DataBaseFunc.get_user(callback_query.from_user.id)
lng = callback_query.data[8:]
user.lng = lng
DataBaseFunc.commit()
await callback_query.message.edit_text(
get_text(user, 'start'),
reply_markup=await UserGeneratorKeyboard.start_button(user))
await UserStateMainMenu.main_menu.set()
def update_info_user(user):
actualy_subs = [
ph for ph in user.purchased_subscriptions
if ph.data_end > datetime.now()
]
if (len(actualy_subs) == 0):
user.is_have_subscription = False
user.subscribe_end = True
DataBaseFunc.commit()
async def managing_courses_delete_choose(callback: types.CallbackQuery):
"""Удаление конкретно выбранного курса"""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
course = DataBaseFunc.get_course(int(callback.data[23:]))
course.is_delete = True
DataBaseFunc.commit()
await callback.message.edit_text(
get_text(user, 'admin_menu_managing_courses'),
reply_markup=AdminGenerateKeyboard.admin_menu_managing_courses(user))
await AdminStateMainMenu.managing_courses.set()
async def get_link_for_access_course(callback: types.CallbackQuery):
"""Обработчик выбора курса для которого получить ссылки на каналы и чаты"""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
id_course = int(callback.data[23:])
course = DataBaseFunc.get_course(id_course)
text = get_text(user, 'get_access_choose_channels')
keyboard = await UserGeneratorKeyboard.get_channels_from_course(
user, course)
await callback.message.edit_text(text, reply_markup=keyboard)
await UserStateGetAccessCourse.choose_channels.set()
async def managing_courses_edit_description(callback: types.CallbackQuery,
state=FSMContext):
"""Обрабатывает кнопки редактировать описание при выбранном для редакта курсе"""
await callback.answer()
data = await state.get_data()
user = DataBaseFunc.get_user(callback.from_user.id)
text = get_text(user, 'managing_courses_edit_access_delete')
course = DataBaseFunc.get_course(data['id_course'])
text = AdminHelper.get_channel_for_managing_courses_edit_access_delete(
text, course)
await state.update_data(message_id=callback.message.message_id)
await callback.message.edit_text(text)
await AdminStateManaginCourseEdit.edit_access_delete.set()
async def managing_course_edit_choose(callback: types.CallbackQuery,
state: FSMContext):
"""Обрабатывает редакт конкретного курса"""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
course = DataBaseFunc.get_course(int(callback.data[21:]))
await state.update_data(id_course=course.id)
text = AdminHelper.get_text_info_course(user, course)
keyboard = AdminGenerateKeyboard.managing_courses_edit_button(user)
await callback.message.edit_text(text,
parse_mode="markdown",
reply_markup=keyboard)
await AdminStateManaginCourseEdit.choose_edit.set()
async def managing_courses_add_additionaly_complete(
callback: types.CallbackQuery, state: FSMContext):
"""Добавляет новый курс в базу данных"""
user = DataBaseFunc.get_user(callback.from_user.id)
data = await state.get_data()
DataBaseFunc.create_new_course(data)
channels = data["channels"]
channels = []
await state.update_data(channels=channels)
await callback.message.edit_text(
get_text(user, 'admin_menu_managing_courses'),
reply_markup=AdminGenerateKeyboard.admin_menu_managing_courses(user))
await AdminStateMainMenu.managing_courses.set()
def get_user_from_message(message: types.Message):
"""Возвращает пользователя из сообщения администратора"""
if (message.forward_from):
user = DataBaseFunc.get_user(message.forward_from.id)
if (user == None):
user = User(id=message.forward_from.id,
username=message.forward_from.username,
is_register=True,
lng="Russian")
DataBaseFunc.add(user)
return user
else:
return DataBaseFunc.get_user(message.text)
def managing_user_add_course(user : User, user_add_course : User) -> InlineKeyboardMarkup():
""" Генерирует клавиатуру с выбором курсов для добавления пользователю"""
keyboard = InlineKeyboardMarkup(row_width=2)
user_courses = DataBaseFunc.get_user_subscribes(user_add_course)
courses = DataBaseFunc.get_courses()
courses = [course for course in courses if ((course.id in [cs.courses.id for cs in user_courses]) == False)]
buttons = []
for course in courses:
buttons.append(InlineKeyboardButton(course.name, callback_data=f"managing_users_add_course_{course.id}"))
keyboard.add(*buttons)
keyboard.add(InlineKeyboardButton(get_text_but(user, 'managing_users_add_course_back'), callback_data="managing_users_add_course_back"))
return keyboard
async def managing_users_delete_time_final_add(callback: types.CallbackQuery,
state: FSMContext):
"""Удалить время пользователю в конкретный курс."""
await callback.answer()
data = await state.get_data()
user = DataBaseFunc.get_user(callback.from_user.id)
user_deletetime_id = DataBaseFunc.get_user(data['user_deletetime_id'])
course = DataBaseFunc.get_course(data['course_id'])
time = data['time']
await DataBaseFunc.delete_time_in_course(user_deletetime_id, course, time)
await callback.message.edit_text(
get_text(user, 'managing_users_delete_time_final_add'),
reply_markup=AdminGenerateKeyboard.admin_menu_managing_users(user))
await AdminStateManagingUser.main_menu.set()
async def managing_courses_edit_access_msg(message: types.Message,
state: FSMContext):
user = DataBaseFunc.get_user(message.from_user.id)
data = await state.get_data()
DataBaseFunc.add_channel_in_course(message, data)
await message.delete()
course = DataBaseFunc.get_course(data['id_course'])
text = AdminHelper.get_text_info_course(user, course)
keyboard = AdminGenerateKeyboard.managing_courses_edit_button(user)
await bot.edit_message_text(text=text,
chat_id=message.chat.id,
message_id=data['message_id'],
reply_markup=keyboard,
parse_mode="markdown")
await AdminStateManaginCourseEdit.choose_edit.set()
async def admin_whos(callback: types.CallbackQuery):
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton(text="Назад", callback_data="admin_in_admin_menu"))
await callback.message.edit_text(text=AdminHelper.get_whos_admin(user), reply_markup=keyboard)
await AdminStateMainMenu.whos.set()
async def managing_users_main_menu_add_course(callback: types.CallbackQuery,
state: FSMContext):
"""Выбрать какой курс добавить пользователю"""
await callback.answer()
data = await state.get_data()
user = DataBaseFunc.get_user(callback.from_user.id)
add_user = DataBaseFunc.get_user(int(data['user_add_course_id']))
course_id = int(callback.data[26:])
await state.update_data(message_id=callback.message.message_id,
course_id=course_id)
await callback.message.edit_text(
text=AdminHelper.managing_users_get_info_user(user, add_user,
course_id),
reply_markup=AdminGenerateKeyboard.
managing_users_main_menu_add_course_choose_user(user))
await AdminStateManagingUser.add_course_choouse_user_final.set()
async def main_menu_subscribe(callback: types.CallbackQuery):
"""Реализует отправку доступных для покупки курсов."""
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(
get_text(user, "main_menu_subscribe"),
reply_markup=UserGeneratorKeyboard.main_menu_subscribe(user))
await UserStateMainMenu.get_subscribe.set()
async def managin_users_main_menu_delete_course_choose_user(
message: types.Message, state: FSMContext):
"""Обработывает выбор пользователя"""
user = DataBaseFunc.get_user(int(message.from_user.id))
user_message = AdminHelper.get_user_from_message(message)
data = await state.get_data()
if (user_message):
await state.update_data(user_deletetime_id=user_message.id)
await message.delete()
await bot.edit_message_text(
chat_id=message.chat.id,
message_id=data['message_id'],
text=get_text(user, 'managing_users_delete_time_choose_courses'),
reply_markup=AdminGenerateKeyboard.
managing_users_add_time_choose_course(user_message))
await AdminStateManagingUser.delete_time_choose_course.set()
else:
await message.delete()
await bot.edit_message_text(
chat_id=message.chat.id,
message_id=data['message_id'],
text=get_text(user,
'managing_users_add_time_choose_user_not_found'),
reply_markup=AdminGenerateKeyboard.
admin_menu_managing_users_add_time_choose_user_back(user))
async def managing_users_delete_course_final_add(callback: types.CallbackQuery,
state: FSMContext):
"""Удалить курс у пользователя."""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
data = await state.get_data()
delete_user = DataBaseFunc.get_user(data['user_delete_id'])
course = DataBaseFunc.get_course(data['course_id'])
await DataBaseFunc.delete_course_from_user(delete_user, course)
await callback.message.edit_text(
get_text(user, 'managing_users_delete_course_final_add').format(
course=course.name,
username=AdminHelper.escape_telegrambot_underscore(
delete_user.username)),
reply_markup=AdminGenerateKeyboard.admin_main_menu(user))
await AdminStateMainMenu.admin_menu.set()
async def main_menu_back(callback: types.CallbackQuery):
"""Возвращает пользователя в главное меню из меню с выбором тарифа для оплаты."""
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(get_text(user, 'start'),
reply_markup=await
UserGeneratorKeyboard.start_button(user))
await UserStateMainMenu.main_menu.set()
async def managing_courses_add_channels(message: types.Message,
state=FSMContext):
"""Добавление новых каналов в подписку""" # -458757767
user = DataBaseFunc.get_user(message.from_user.id)
data = await state.get_data()
if (not ("channels" in data.keys())):
await state.update_data(channels=[])
data = await state.get_data()
channels = data["channels"]
if (message.forward_from_chat != None):
id_channel = message.forward_from_chat.id
full_name_channel = message.forward_from_chat.full_name
channels.append({"id": id_channel, "name": full_name_channel})
else:
try:
mas_text = message.text.split(':')
channels.append({"id": mas_text[0], "name": mas_text[1]})
except:
pass
await state.update_data(channels=channels)
await bot.delete_message(message.chat.id, message.message_id)
text = AdminHelper.add_channels_in_message(
get_text(user, 'managing_course_add_channels'), channels)
await bot.edit_message_text(text=text,
chat_id=data['chat_id'],
message_id=data['message_id'],
reply_markup=AdminGenerateKeyboard.
managing_courses_add_channels_continue(user))
async def managing_admins_main_menu_list_admins(callback: types.CallbackQuery):
"""Отправляет список администраторов бота"""
await callback.answer()
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(
AdminHelper.get_list_admins(user),
reply_markup=AdminGenerateKeyboard.managing_admin_list_admins(user))
async def managing_admins_main_menu_back(callback: types.CallbackQuery):
"""Возвращает в главное меню админки"""
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(
get_text(user, 'main_admin_menu'),
reply_markup=AdminGenerateKeyboard.admin_main_menu(user))
await AdminStateMainMenu.admin_menu.set()
async def managing_courses_edit(callback: types.CallbackQuery):
"""Обработка кнопки назад"""
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(
get_text(user, 'admin_menu_managing_courses'),
reply_markup=AdminGenerateKeyboard.admin_menu_managing_courses(user))
await AdminStateMainMenu.managing_courses.set()
async def get_access_choose_channels_back(callback: types.CallbackQuery):
"""Возвращает пользователя обратно в выбор курса"""
user = DataBaseFunc.get_user(callback.from_user.id)
await callback.message.edit_text(get_text(user, 'start'),
reply_markup=await
UserGeneratorKeyboard.start_button(user))
await UserStateMainMenu.main_menu.set()
def index():
data = request.json
phone = data['phone']
mail = data['mail']
course_id = data['course_id']
is_added = DataBaseFunc.add_contact(phone, mail, course_id)
return str(is_added)
