def handler(request, message: dict, user_chat_id: int):
text = message.get('text', None)
message_id = message['message_id']
user = classes.User(request.http_session, classes.User.Mode.SEND_AD, user_chat_id)
user.set_username()
user.send_ad()
user.database.started = True
if text in ('بازگشت 🔙', 'Back 🔙'):
user.go_back()
raise RequestInterruption()
match user.database:
case models.User(rank=(
user.database.Rank.OWNER | user.database.Rank.ADMIN | user.database.Rank.KHIAR
)) if text in (switch_options := ('/admin', '/user')):
if text == switch_options[0]:
user.menu_cleanup()
user.database.menu_mode = user.database.MenuMode.ADMIN
user.database.menu = models.User.Menu.ADMIN_MAIN
user.send_message(user.translate('admin_panel'), keyboards.admin, message_id)
user.database.save()
raise RequestInterruption()
else:
user.menu_cleanup()
user.database.menu_mode = user.database.MenuMode.USER
user.database.menu = models.User.Menu.USER_MAIN
user.send_message(user.translate('user_panel'), keyboards.user, message_id)
user.database.save()
raise RequestInterruption()
def handler(rate_option: str, meme_id: id, query_id: str, answer_query,
inliner: User):
try:
meme = Meme.objects.get(id=meme_id)
except (Meme.DoesNotExist, ValueError):
inliner.database.save()
raise RequestInterruption()
if rate_option == 'up':
if meme.voters.filter(user_id=inliner.database.user_id).exists():
answer_query(
query_id, user_messages['voted_before'].format(
user_messages[meme.type_string]), True)
else:
inliner.add_voter(meme)
meme.votes = F('votes') + 1
meme.save()
answer_query(
query_id, user_messages['meme_voted'].format(
user_messages[meme.type_string]), False)
else:
if meme.voters.filter(user_id=inliner.database.user_id).exists():
inliner.remove_voter(meme)
meme.votes = F('votes') - 1
meme.save()
answer_query(query_id, user_messages['took_vote_back'], False)
else:
answer_query(query_id, user_messages['not_voted'], True)
def handler(vote_option: str, query_id: str, meme_id: int, answer_query, inliner: UserClass):
try:
meme = Meme.objects.get(id=meme_id, status=Meme.Status.PENDING)
except Meme.DoesNotExist:
raise RequestInterruption()
match vote_option:
case 'a':
if inliner.database.rank in BOT_ADMINS and inliner.database.menu == User.Menu.ADMIN_GOD_MODE:
answer_query(
query_id, admin_messages['admin_meme_accepted'].format(admin_messages[meme.type_string]), True
)
meme.accept(inliner.session)
elif not inliner.like_meme(meme):
answer_query(query_id, inliner.translate('vote_before', inliner.translate(
meme.type_string
)), True)
else:
answer_query(query_id, inliner.translate('voted'), False)
case 'd':
if inliner.database.rank in BOT_ADMINS and inliner.database.menu == User.Menu.ADMIN_GOD_MODE:
answer_query(
query_id, admin_messages['admin_meme_denied'].format(admin_messages[meme.type_string]), True
)
meme.deny(inliner.session)
elif not inliner.dislike_meme(meme):
answer_query(query_id, inliner.translate('vote_before', inliner.translate(
meme.type_string
)), True)
else:
answer_query(query_id, inliner.translate('voted'), False)
case _:
answer_query(query_id, inliner.translate(
'voting_results', meme.accept_vote.count(), meme.deny_vote.count()
), True, 180)
def handler(meme_id: int, query_id: str, answer_query, inliner: UserClass):
try:
meme = Meme.objects.get(id=meme_id, status=Meme.Status.PENDING)
except (Meme.DoesNotExist, ValueError):
inliner.database.save()
raise RequestInterruption()
match inliner.report_meme(meme):
case ReportResult.REPORTED:
answer_query(query_id, user_messages['report_submitted'], True)
case ReportResult.REPORTED_BEFORE:
answer_query(query_id, user_messages['reported_before'].format(user_messages[meme.type_string]), True)
case ReportResult.REPORT_FAILED:
answer_query(query_id, user_messages['report_reviewed'].format(user_messages[meme.type_string]), True)
def handler(playlist_id: int, query_id: str, answer_query, inliner: UserClass):
try:
inliner.database.current_playlist = Playlist.objects.get(
id=playlist_id, creator=inliner.database
)
except (Playlist.DoesNotExist, ValueError):
inliner.database.save()
raise RequestInterruption()
inliner.menu_cleanup()
inliner.database.menu_mode = inliner.database.MenuMode.USER
inliner.database.menu = User.Menu.USER_MANAGE_PLAYLIST
inliner.database.back_menu = 'manage_playlists'
answer_query(query_id, user_messages['managing_playlist'], False)
inliner.send_message(user_messages['manage_playlist'], manage_playlist)
def handler(callback_type: ObjectType, meme_id: id, query_id: str, answer_query, inliner: UserClass):
try:
match callback_type:
case ObjectType.PRIVATE_VOICE.value:
inliner.database.current_meme = inliner.get_private_voice(meme_id)
inliner.database.back_menu = 'manage_private_voices'
inliner.database.menu = User.Menu.USER_MANAGE_PRIVATE_VOICE
case ObjectType.SUGGESTED_VOICE.value:
inliner.database.current_meme = inliner.get_suggested_meme(
meme_id, MemeType.VOICE
)
inliner.database.back_menu = 'voice_suggestions'
inliner.database.menu = User.Menu.USER_MANAGE_VOICE_SUGGESTION
case ObjectType.SUGGESTED_VIDEO.value:
inliner.database.current_meme = inliner.get_suggested_meme(
meme_id, MemeType.VIDEO
)
inliner.database.back_menu = 'video_suggestions'
inliner.database.menu = User.Menu.USER_MANAGE_VIDEO_SUGGESTION
case ObjectType.PLAYLIST_VOICE.value:
inliner.database.current_meme = inliner.database.current_playlist.voices.get(
id=meme_id
)
inliner.database.back_menu = 'manage_playlist'
inliner.database.menu = User.Menu.USER_MANAGE_PLAYLIST_VOICE
except Meme.DoesNotExist:
inliner.database.save()
raise RequestInterruption()
temp_current_meme = inliner.database.current_meme
inliner.menu_cleanup()
inliner.database.current_meme = temp_current_meme
inliner.database.menu_mode = inliner.database.MenuMode.USER
if inliner.database.current_meme.type == MemeType.VOICE:
meme_translation = user_messages['voice']
meme_keyboard = manage_voice
else:
meme_translation = user_messages['video']
meme_keyboard = manage_video
answer_query(query_id, user_messages['manage_meme'].format(meme_translation), False)
inliner.send_message(
user_messages['managing_meme'].format(meme_translation), meme_keyboard
)
def handler(request, inline_query, user_chat_id):
query = inline_query['query']
offset = inline_query['offset']
inline_query_id = inline_query['id']
user = User(request.http_session, User.Mode.SEND_AD, user_chat_id)
user.upload_voice()
if not user.database.started:
user.database.save()
answer_inline_query(inline_query_id, str(), str(),
user.translate('start_the_bot'), 'new_user',
request.http_session)
raise RequestInterruption()
user.send_ad()
user.set_username()
user.database.save()
if user.database.status != 'f':
results, next_offset = user.get_memes(query, offset)
answer_inline_query(inline_query_id, dumps(results), next_offset,
user.translate('add_meme'), 'suggest_meme',
request.http_session)
def handler(command: str, meme_id: int, message_id: int, query_id: str,
answer_query, inliner: User):
try:
deleted_meme = Meme.objects.get(id=meme_id, status=Meme.Status.DELETED)
except Meme.DoesNotExist:
raise RequestInterruption()
user = User(inliner.session,
User.Mode.NORMAL,
instance=deleted_meme.sender)
if command == 'r':
deleted_meme.status = Meme.Status.ACTIVE
assigned_admin = User(inliner.session,
User.Mode.NORMAL,
instance=deleted_meme.assigned_admin)
deleted_meme.assigned_admin = None
deleted_meme.save()
assigned_admin.send_message(assigned_admin.translate(
'deleted_meme_recovered',
assigned_admin.translate(deleted_meme.type_string),
deleted_meme.name),
parse_mode='HTML')
answer_query(
query_id, translations.admin_messages['meme_recovered'].format(
translations.admin_messages[deleted_meme.type_string]), True)
edit_message_reply_markup(settings.MEME_LOGS,
recovered,
message_id=message_id,
session=inliner.session)
else:
deleted_meme.delete()
user.send_message(
translations.user_messages['deleted_by_admins'].format(
translations.user_messages[deleted_meme.type_string],
deleted_meme.name))
edit_message_reply_markup(settings.MEME_LOGS,
deleted,
message_id=message_id,
session=inliner.session)
def handler(command: str, target_id: int, message_id: int, query_id: str, answer_query, inliner: UserClass):
inliner.delete_message(message_id)
if not (target_message := get_message(target_id)):
inliner.database.save()
raise RequestInterruption()
def handler(command: str, target_id: int, message_id: int, query_id: str, answer_query, inliner: User):
if not (target_delete := get_delete(target_id)):
raise RequestInterruption()
def handler(request, callback_query, user_chat_id):
answer_query = functions.answer_callback_query(request.http_session)
if callback_query['data'] == 'none':
raise RequestInterruption()
query_id = callback_query['id']
inliner = classes.User(request.http_session, classes.User.Mode.SEND_AD, user_chat_id)
inliner.upload_voice()
if not inliner.database.started:
answer_query(query_id, inliner.translate('start_to_use'), True)
inliner.database.save()
raise RequestInterruption()
inliner.send_ad()
callback_data = callback_query['data'].split(':')
try:
message = callback_query['message']
except KeyError:
message_id = None
else:
message_id = message['message_id']
match callback_data:
case ('back', ):
inliner.go_back()
case ('p', chat_id):
user_profile.handler(chat_id, query_id, answer_query, inliner)
case (('a' | 'd' | 're') as vote_option, meme_id):
voting.handler(vote_option, query_id, meme_id, answer_query, inliner)
case (('up' | 'down') as rate_option, meme_id):
rating.handler(rate_option, meme_id, query_id, answer_query, inliner)
case ('rep', meme_id):
reporting.handler(meme_id, query_id, answer_query, inliner)
case (ObjectType.PLAYLIST.value, playlist_id):
playlist.handler(playlist_id, query_id, answer_query, inliner)
case ((
ObjectType.PRIVATE_VOICE.value |
ObjectType.SUGGESTED_VOICE.value |
ObjectType.PLAYLIST_VOICE.value |
ObjectType.SUGGESTED_VIDEO.value
) as callback_type, meme_id):
object_types.handler(callback_type, meme_id, query_id, answer_query, inliner)
case (page_type, page_str) if page_type.endswith('page'):
pages.handler(ObjectType(page_type.removesuffix('page')), int(page_str), message_id, inliner)
case ('r' | 'rd' as command, meme_id) if inliner.database.rank in BOT_ADMINS:
delete_logs.handler(command, meme_id, message_id, query_id, answer_query, inliner)
case (('rep_accept' | 'rep_dismiss') as command, meme_id) if inliner.database.rank != User.Rank.USER:
try:
report = Report.objects.get(meme__id=meme_id, status=Report.Status.PENDING)
except Report.DoesNotExist:
answer_query(query_id, admin_messages['meme_already_processed'], False)
functions.edit_message_reply_markup(
settings.MEME_REPORTS_CHANNEL, processed, message_id, session=inliner.session
)
inliner.database.save()
raise RequestInterruption()
reports.handler(command, query_id, message_id, answer_query, report, inliner)
case (command, target_id) if inliner.database.rank == User.Rank.OWNER:
match command:
case 'read' | 'ban' | 'reply':
messages.handler(command, target_id, message_id, query_id, answer_query, inliner)
case 'delete' | 'delete_deny':
delete_requests.handler(command, target_id, message_id, query_id, answer_query, inliner)
inliner.database.save()