async def previous_track(query: types.CallbackQuery):
await query_answer(query)
token = await spotify_api.get_token(query.from_user.id)
if not token:
return SendMessage(query.from_user.id,
'Please authorize',
reply_markup=auth_keyboard(query.from_user.id))
await request_post('https://api.spotify.com/v1/me/player/previous',
headers={'Authorization': f'Bearer {token}'})
await asyncio.sleep(.7)
req = await request_get(
'https://api.spotify.com/v1/me/player/currently-playing',
headers={'Authorization': f'Bearer {token}'})
try:
json = await req.json()
track = AttrDict(json['item'])
except Exception as e:
print_traceback(e)
return SendMessage(query.message.chat.id,
f'Play something in Spotify and try again',
reply_to_message_id=query.message.message_id)
await bot.edit_message_text(
text='Currently playing track:\n' +
f'{track.artists[0].name} - {track.name}'
f'<a href="{track.album.images[0].url}">​</a>',
chat_id=query.message.chat.id,
message_id=query.message.message_id,
reply_markup=current_track_keyboard(track),
parse_mode='HTML')
async def quiz_restart(message: types.Message):
""" Хендлер обработки запроса на рестарт викторины """
current_game = Quiz()
current_player = Player(message.chat.id)
if current_game.check_player(message.chat.id):
if len(current_player.all_answers()) != current_game.get_questions_count():
text = 'Вы еще не завершили викторину, чтобы начать сначала :)'
return SendMessage(message.chat.id, text)
else:
current_game.restart_player(message.chat.id)
q_id = current_player.get_q_id()
buttons = current_game.create_buttons(q_id)
return SendMessage(
message.chat.id,
current_game.get_question(q_id),
reply_markup=buttons
)
else:
text = [
'Вы еще даже не проходили викторину.',
'Как я начну еще раз?',
f'<strong>Напишите мне лучше слово {start.capitalize()}!</strong>'
]
return SendMessage(message.chat.id, '\n'.join(text))
async def user_answer(call: types.CallbackQuery):
""" Хендлер обработки нажатой кнопки """
current_game = Quiz()
current_player = Player(call.from_user.id)
if len(current_player.all_answers()) == current_game.get_questions_count():
result = current_game.get_quiz_results(current_player.all_answers())
return SendMessage(call.from_user.id, current_game.result_answer(result))
elif len(current_player.all_answers()) >= 0:
if current_player.add_answer(call.data):
q_id = current_player.get_q_id(add=True)
text = current_game.get_question(q_id)
else:
q_id = current_player.get_q_id()
text = '\n'.join([
'Ая-яй! Вы уже ответили на этот вопрос :)',
current_game.get_question(q_id)
])
buttons = current_game.create_buttons(q_id)
return SendMessage(
call.from_user.id, text=text,
reply_markup=buttons
)
async def screenshot(message: types.Message):
if message.text.startswith('http://') or message.text.startswith(
'https://'):
await bot.send_message(chat_id=message.chat.id,
text="Wait a second...")
url = message.text
picture_path = "image.png"
try:
driver.get(url)
except:
return SendMessage(chat_id=message.chat.id, text="Incorrect link")
window_size = driver.get_window_size()
width = driver.execute_script(
'return document.body.parentNode.scrollWidth')
height = driver.execute_script(
'return document.body.parentNode.scrollHeight')
driver.set_window_size(width, height)
await message.reply(text="taking a website screenshot...")
driver.find_element_by_tag_name('body').screenshot(picture_path)
driver.set_window_size(window_size['width'], window_size['height'])
await message.reply(text="Done")
return SendDocument(chat_id=message.chat.id,
document=types.InputFile(picture_path),
caption=url)
return SendMessage(chat_id=message.chat.id, text="Incorrect link")
async def fetch_one(message: types.Message):
if not storage.data['is_moderator']:
reply = get_phrase_from_res(JsonTags.DATA_NOT_MODERATOR,
message.from_user.language_code)
return SendMessage(message.chat.id, reply)
result = ""
writ_was_began = False
lines = open("data/new_data.txt").readlines()
lines_to_delete = 0
for line in lines:
print("LINE: " + line)
if "User id" in line and not writ_was_began:
writ_was_began = True
lines_to_delete += 1
result += line
if (line == "" or line == "\n") and writ_was_began:
break
with open("data/new_data.txt", "w") as file:
file.writelines(lines[lines_to_delete:-1])
if result == "":
result = get_phrase_from_res(JsonTags.DATA_IS_EMPTY,
message.from_user.language_code)
return SendMessage(message.chat.id, result)
async def echo(message: aiogram.types.Message):
user_id = message.from_user.id
if message.get_command() == '/start' and message.get_args() != '':
try:
token = message.get_args()
except ValueError:
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.'
)
if not verify_token(token):
return SendMessage(
user_id,
'Ваша персональная ссылка устарела. Обратитесь в центр Клиентской Поддержки.'
)
await init_database(user_id, token)
text = 'Добро пожаловать в Департамент клиентской поддержки! Выберите интересующий вас вопрос:'
else:
text = 'К сожалению, все операторы отсутствуют. Ваш вопрос очень важен для нас, поэтому ответ на него наверняка найдётся ниже:'
if not database_exists(user_id):
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.')
questions = await get_page(user_id)
return SendMessage(user_id, text, reply_markup=questions)
async def get_lyrics(query: types.CallbackQuery):
await query_answer(query)
track_id = query.data.split(':')[2]
result = await genius_api.spotify_match(track_id)
if not result:
return SendMessage(query.message.chat.id,
f'Didn\'t found lyrics for this song',
reply_to_message_id=query.message.message_id)
telegraph_url = await genius_api.telegraph_track(query.message.chat.id,
result)
return SendMessage(query.message.chat.id, telegraph_url)
async def process_podsite(message: types.Message, state: FSMContext):
del state
unsub_sucscess = f'Подписка на {message.text.lower()} отменена'
unsub_unsucscess = f'Подписка на {message.text.lower()} не обнаружена, никаких действий не предпринято'
if await delete_relation(message.chat.id, message.text.lower()):
return SendMessage(chat_id=message.chat.id,
text=unsub_sucscess,
reply_markup=await
keyboards.unsub_keyboard(message.chat.id))
else:
return SendMessage(chat_id=message.chat.id,
text=unsub_unsucscess,
reply_markup=await
keyboards.unsub_keyboard(message.chat.id))
async def cmd_id(message: types.Message):
"""
Return info about user.
"""
if message.reply_to_message:
target = message.reply_to_message.from_user
chat = message.chat
elif message.forward_from and message.chat.type == ChatType.PRIVATE:
target = message.forward_from
chat = message.forward_from or message.chat
else:
target = message.from_user
chat = message.chat
result_msg = [
hbold('Info about user:'******'Chat:'), f"Type: {chat.type}", f"Chat ID: {chat.id}"])
if chat.type != ChatType.PRIVATE:
result_msg.append(f"Title: {chat.title}")
else:
result_msg.append(f"Title: {chat.full_name}")
return SendMessage(message.chat.id,
'\n'.join(result_msg),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML)
async def unknown(message: types.Message):
"""
Handler for unknown messages.
"""
return SendMessage(
message.chat.id,
'I don\'t know what to do with that content type. Sorry :c')
async def callback_watch_select_time(query: CallbackQuery):
search = re.search('^calendar-time-([0-9]{1,2})$', query.data)
time = search.group(1)
if time is not None:
note = await get_last_note(context_data['user_id'])
if note is not None:
notify = await get_notification_by_note(note.id)
if notify is not None:
notify_date = notify.notify_date.replace(hour=int(time))
await update_notification(notify.id, notify_date)
set_notification_job(query.message.chat.id, notify.id,
notify_date,
context_data['user_timezone'])
bot = ctx.get_bot()
await bot.answer_callback_query(
callback_query_id=query.id,
text=_(
'Заметка будет отправлена {0}\nВы можете создать новую заметку, '
'отправив голосовое сообщение'.format(notify_date)),
show_alert=True)
return EditMessageText(chat_id=query.message.chat.id,
message_id=query.message.message_id,
text=help_text,
reply_markup=InlineKeyboardMarkup(),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
return SendMessage(chat_id=query.message.chat.id,
text=_('Ошибка запроса, попробуйте позже'))
async def echo(message: types.Message, state: FSMContext):
cur_state = await state.get_state()
logging.info(f' cur state = {cur_state}')
if cur_state is None:
return
return SendMessage(message.chat.id, 'FIN!')
async def add_place8(message: types.Message):
storage.data["question_list"].append(storage.data["question"])
await Form.question.set()
response = get_phrase_from_res(JsonTags.ADD_QUESTIONS_QUESTION,
message.from_user.language_code)
return SendMessage(message.chat.id, response)
async def add_place1(message: types.Message):
print("Total cancel. Changes discarded")
reply = get_phrase_from_res(JsonTags.ADD_CANCEL,
message.from_user.language_code)
await Form.info.set()
return SendMessage(message.chat.id, reply)
async def bot_start(message: types.Message):
await start.MainMenuState.main_menu.set()
return SendMessage(
message.message_id,
"Этот Бот Создан для Поиска В Поисковых Системах.\n И этот Бот Имеет кастомизацию запросов типичную...\n",
reply_markup=start_kb
)
async def cancel(message: types.Message):
# Get current state context
state = dp.current_state(chat=message.chat.id, user=message.from_user.id)
# If current user in any state - cancel it.
if await state.get_state() is not None:
await state.set_state(state=None)
return SendMessage(message.chat.id, 'Current action is canceled.')
async def add_place9(message: types.Message):
print("Answer: " + message.text)
storage.data["question"].append(message.text)
response = get_phrase_from_res(JsonTags.ADD_QUESTIONS_ANSWER_AGAIN,
message.from_user.language_code)
return SendMessage(message.chat.id, response)
async def unknown(message: types.Message):
"""
Handler for unknown messages.
"""
return SendMessage(
message.chat.id,
f"I don\'t know what to do with content type `{message.content_type()}`. Sorry :c"
)
async def add_place2(message: types.Message):
print("Cancel retry")
await Form.description.set()
response = get_phrase_from_res(JsonTags.ADD_QUESTIONS_DESCRIPTION,
message.from_user.language_code)
return SendMessage(message.chat.id, response)
async def process_subsctiption(message: types.Message):
await UserDialog.adding_subscription.set()
subscribe_start_message = (
'Вход в режим оформления подписки. Введите префикс подсайта латиницей без кавычек. Пример: «cyberpunk»'
'По окончании введите /stop или жамкайте на кнопку ниже')
return SendMessage(chat_id=message.chat.id,
text=subscribe_start_message,
reply_markup=keyboards.sub_kb)
async def my_calendar(message: Message):
markup = await get_my_calendar_markup()
return SendMessage(
chat_id=message.chat.id,
text=_('Ваш календарь голосовых напоминаний. С его помощью можно '
'просмотреть все напоминания, которые будут отправлены в '
'будущем'),
reply_markup=markup)
async def quiz_start(message: types.Message):
""" Хендлер обработки запроса на старт викторины """
current_game = Quiz()
current_player = Player(message.chat.id)
if not current_game.check_player(message.chat.id):
current_game.create_player(message.chat.id)
q_id = current_player.get_q_id()
if q_id > current_game.get_questions_count():
result = current_game.get_quiz_results(current_player.all_answers())
return SendMessage(message.chat.id, current_game.result_answer(result))
buttons = current_game.create_buttons(q_id)
question = current_game.get_question(q_id)
return SendMessage(
message.chat.id, question,
reply_markup=buttons
)
async def get_artist(query: types.CallbackQuery):
await query_answer(query)
artist_id = query.data.split(':')[2]
artist = await spotify_api.match_artist(artist_id)
if artist:
await methods.send_artist(query.message.chat.id, artist)
else:
return SendMessage(query.message.chat.id,
'Artist is not found on Deezer, try manual search')
async def process_unsubsctiption(message: types.Message):
unsub_start_message = (
'Вот список твоих подписок, введи имя подсайта, или просто жмакай на кнопочку с его именем'
)
await UserDialog.deleting_subscription.set()
return SendMessage(chat_id=message.chat.id,
text=unsub_start_message,
reply_markup=await
keyboards.unsub_keyboard(message.chat.id))
async def get_album(query: types.CallbackQuery):
await query_answer(query)
album_id = query.data.split(':')[2]
album = await spotify_api.match_album(album_id)
if album:
await methods.send_album(query.message.chat.id, album)
else:
return SendMessage(query.message.chat.id,
'Album is not found on Deezer, try manual search')
async def download_track(query: types.CallbackQuery):
await query_answer(query)
track_id = query.data.split(':')[2]
track = await spotify_api.match_track(track_id)
if track:
await methods.send_track(query.message.chat.id, track)
else:
return SendMessage(query.message.chat.id,
'Track is not found on Deezer, try manual search')
async def help_message(message: types.Message):
if storage.data['is_moderator']:
reply = get_phrase_from_res(JsonTags.HELP_MODERATOR,
message.from_user.language_code)
else:
reply = get_phrase_from_res(JsonTags.HELP_USER,
message.from_user.language_code)
return SendMessage(message.chat.id, reply)
async def echo(message: types.Message, state: FSMContext):
async with state.proxy() as data:
prev = data['saved']
logging.info(f'message! {message.text}')
data['saved'] = message.text
await Proba.FIN.set()
return SendMessage(message.chat.id, prev)
async def moderator_logout(message: types.Message):
if not storage.data['is_moderator']:
reply = get_phrase_from_res(JsonTags.LOGOUT_FAIL,
message.from_user.language_code)
else:
storage.data['is_moderator'] = False
reply = get_phrase_from_res(JsonTags.LOGOUT_SUCCESS,
message.from_user.language_code)
return SendMessage(message.chat.id, reply)
async def add_place3(message: types.Message):
print("Description: " + message.text)
storage.data["description"] = message.text
await Form.next()
response = get_phrase_from_res(JsonTags.ADD_QUESTIONS_PLACE,
message.from_user.language_code)
return SendMessage(message.chat.id, response)
