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)