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()
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 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()
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 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()
async def register_phone_write(message: types.Message, state: FSMContext):
"""Ввод номера телефона."""
await message.delete()
user = DataBaseFunc.get_user(message.from_user.id)
data = await state.get_data()
message_id = data['callback_message_id']
phone = "".join(ch for ch in message.text if ch.isdigit())
if (phone[0] == '8'):
phone = '7' + phone[1:]
errors = get_text(user, 'write_phone_errors')
keyboard = UserGeneratorKeyboard.register_button(user)
# keyboard = types.InlineKeyboardMarkup()
# keyboard.add(types.InlineKeyboardButton(get_text_but(user, 'register_write_back'), callback_data="register_write_back"))
if len(phone) == 0:
await bot.edit_message_text(text=errors['empty'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
check_user = DataBaseFunc.get_user_for_phone(phone)
if (check_user != None):
await bot.edit_message_text(text=errors['is_register'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
contact = DataBaseFunc.get_contact(phone=phone)
if (contact == None):
await bot.edit_message_text(text=errors['not_found'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
user.phone = phone
user.mail = contact.mail
user.is_register = True
user.course_id = contact.course_id
contact.is_register = True
DataBaseFunc.commit()
DataBaseFunc.add_course_in_user(user,
DataBaseFunc.get_course(user.course_id))
await bot.edit_message_text(text=get_text(user, 'start'),
chat_id=message.chat.id,
message_id=message_id,
reply_markup=await
UserGeneratorKeyboard.start_button(user))
await UserStateMainMenu.main_menu.set()
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 register_mail_write(message: types.Message, state: FSMContext):
"""Ввод номера телефона."""
await message.delete()
user = DataBaseFunc.get_user(message.from_user.id)
data = await state.get_data()
message_id = data['callback_message_id']
mail = message.text
mail = mail.lower()
errors = get_text(user, 'write_mail_errors')
keyboard = UserGeneratorKeyboard.register_button(user)
# keyboard = types.InlineKeyboardMarkup()
# keyboard.add(types.InlineKeyboardButton(get_text_but(user, 'register_write_back'), callback_data="register_write_back"))
if ("@" in mail) == False:
await bot.edit_message_text(text=errors['empty'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
check_user = DataBaseFunc.get_user_for_mail(mail)
if (check_user != None):
await bot.edit_message_text(text=errors['is_register'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
contact = DataBaseFunc.get_contact(mail=mail)
if (contact == None):
await bot.edit_message_text(text=errors['not_found'],
chat_id=message.chat.id,
message_id=message_id,
reply_markup=keyboard)
await UserStateRegister.main_menu.set()
return
user.mail = mail
user.phone = contact.phone
user.is_register = True
contact.is_register = True
user.course_id = contact.course_id
DataBaseFunc.commit()
DataBaseFunc.add_course_in_user(user,
DataBaseFunc.get_course(user.course_id))
await bot.edit_message_text(text=get_text(user, 'start'),
chat_id=message.chat.id,
message_id=message_id,
reply_markup=await
UserGeneratorKeyboard.start_button(user))
await UserStateMainMenu.main_menu.set()
async def managing_users_main_menu_add_course_choose_user_add(
callback: types.CallbackQuery, state: FSMContext):
"""Обработка кнопки добавить подписку пользователю"""
await callback.answer()
data = await state.get_data()
user = DataBaseFunc.get_user(callback.from_user.id)
user_add = DataBaseFunc.get_user(data['user_add_course_id'])
course = DataBaseFunc.get_course(data['course_id'])
DataBaseFunc.add_course_in_user(user_add, course)
user.subscribe_end = False
user.is_register = True
DataBaseFunc.commit()
await callback.message.edit_text(
get_text(user, 'managing_users_main_menu_add_course_choose_user_add'),
reply_markup=AdminGenerateKeyboard.admin_main_menu(user))
await AdminStateMainMenu.admin_menu.set()
async def start_message(message: types.Message):
"""Обработчик команды /start."""
user = DataBaseFunc.get_user(message.from_user.id)
if user != None:
if (user.chat_id != message.chat.id):
user.chat_id = message.chat.id
DataBaseFunc.commit()
await message.delete()
if user == None:
user = User(id=message.from_user.id,
username=message.from_user.username,
chat_id=message.chat.id,
is_check_seven_days=False)
DataBaseFunc.add(user)
DataBaseFunc.commit()
mess = await message.answer(
get_text(user, 'register'),
reply_markup=UserGeneratorKeyboard.register_button(user))
await DataBaseFunc.delete_messages(user)
ms = Message(user_id=user.id, message_id=mess.message_id)
DataBaseFunc.add(ms)
await UserStateRegister.main_menu.set()
elif user.is_register == False:
if (user.chat_id == None):
user.chat_id = message.chat.id
mess = await message.answer(
get_text(user, 'register'),
reply_markup=UserGeneratorKeyboard.register_button(user))
await DataBaseFunc.delete_messages(user)
ms = Message(user_id=user.id, message_id=mess.message_id)
DataBaseFunc.add(ms)
await UserStateRegister.main_menu.set()
else:
if (user.chat_id == None):
user.chat_id = message.chat.id
mess = await message.answer(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)
DataBaseFunc.add(ms)
await UserStateMainMenu.main_menu.set()
async def managing_courses_edit_name_msg(message: types.Message,
state: FSMContext):
data = await state.get_data()
new_time = message.text
course = DataBaseFunc.get_course(data['id_course'])
course.time = int(new_time)
DataBaseFunc.commit()
await message.delete()
user = DataBaseFunc.get_user(message.from_user.id)
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()
def save_timestamp_in_user(user: User, timestamp: float) -> None:
"""Сохраняет время последнего платежа юзера для идентификации инвойса"""
user.last_payload_timestamp = timestamp
DataBaseFunc.commit()
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)
all_users = DataBaseFunc.get_users_with_subscribe()
users = [user for user in all_users if user.is_have_subscription]
for user in users:
for ph in [
subs for subs in user.purchased_subscriptions
if subs.is_check == False
]:
# for ph in [subs for subs in user.purchased_subscriptions]:
date = ph.data_end - datetime.now()
if ((date.days) == 7 and user.is_check_seven_days == False):
send_message_seven(user)
user.is_check_seven_days = True
DataBaseFunc.commit()
if (ph.data_end > datetime.now()):
continue
for channel in ph.courses.channels:
try:
kick_user_from_channel(user, channel.channels)
ph.is_check = True
DataBaseFunc.commit()
except:
continue
send_message(user)
