text, buttons = get_help(chat_id)
await bot.edit_message_text(text, chat_id, query.message.message_id, reply_markup=buttons)
def get_help(chat_id):
text = "Select module to get help"
counter = 0
buttons = InlineKeyboardMarkup(row_width=2)
for module in HELP:
counter += 1
btn_name = get_string(module, "btn", chat_id, dir="HELPS")
buttons.insert(InlineKeyboardButton(btn_name, callback_data=help_page_cp.new(module=module)))
return text, buttons
@dp.callback_query_handler(help_page_cp.filter())
async def get_mod_help_callback(query, callback_data=False, **kwargs):
chat_id = query.message.chat.id
message = query.message
module = callback_data['module']
lang = get_chat_lang(chat_id)
buttons = InlineKeyboardMarkup(row_width=2)
text = LANGUAGES[lang]["HELPS"][module]['text']
if 'buttons' in LANGUAGES[lang]["HELPS"][module]:
counter = 0
for btn in LANGUAGES[lang]["HELPS"][module]['buttons']:
counter += 1
btn_name = LANGUAGES[lang]["HELPS"][module]['buttons'][btn]
buttons.insert(InlineKeyboardButton(
btn_name, callback_data=help_btn_cp.new(module=module, btn=btn)))
buttons.add(InlineKeyboardButton("Back", callback_data='get_help'))
markup = types.InlineKeyboardMarkup()
markup.row(
types.InlineKeyboardButton('👍', callback_data=posts_cb.new(id=post_id, action='like')),
types.InlineKeyboardButton('👎', callback_data=posts_cb.new(id=post_id, action='unlike')),
)
markup.add(types.InlineKeyboardButton('<< Back', callback_data=posts_cb.new(id='-', action='list')))
return text, markup
@dp.message_handler(commands='start')
async def cmd_start(message: types.Message):
await message.reply('Posts', reply_markup=get_keyboard())
@dp.callback_query_handler(posts_cb.filter(action='list'))
async def query_show_list(query: types.CallbackQuery):
await query.message.edit_text('Posts', reply_markup=get_keyboard())
@dp.callback_query_handler(posts_cb.filter(action='view'))
async def query_view(query: types.CallbackQuery, callback_data: dict):
post_id = callback_data['id']
post = POSTS.get(post_id, None)
if not post:
return await query.answer('Unknown post!')
text, markup = format_post(post_id, post)
await query.message.edit_text(text, reply_markup=markup)
await db.antiflood.update_one({"chat_id": chat["chat_id"]},
{"$set": {
"action": action
}},
upsert=True)
await get_data.reset_cache(message.chat.id)
return await message.reply(
strings["setfloodaction_success"].format(action=action))
async def __before_serving__(_):
dp.middleware.setup(AntifloodEnforcer())
@register(cancel_state.filter(), f="cb")
async def cancel_state_cb(event: CallbackQuery):
await event.message.delete()
@cached()
async def get_data(chat_id: int):
return await db.antiflood.find_one({"chat_id": chat_id})
async def __export__(chat_id: int):
data = await get_data(chat_id)
if not data:
return
del data["_id"], data["chat_id"]
return markup
@dp.message_handler(commands='pokemons')
async def cmd_start(message: types.Message, state: FSMContext):
async with state.proxy() as data:
if message.get_args().isdigit():
argument = message.get_args()
data['List'] = argument
if not data.get('stapList'):#ваще ідеал писать отакз
Listok = list()
data['stapList'] = Listok
id_pok = message.get_args()
if id_pok.isdigit():
await message.reply("Page", reply_markup=await get_pokemon_list_keyboard(int(id_pok)))
@dp.callback_query_handler(pokemon_cb.filter(action='page'))
async def query_show_list(query: types.CallbackQuery, callback_data: dict, state: FSMContext):
start_id = int(callback_data['id'])
async with state.proxy() as data:
data['List'] = start_id
print(start_id)
await query.message.edit_text('{} Page'.format(int(start_id // 6) + 1), reply_markup=await get_pokemon_list_keyboard(int(start_id)))
@dp.callback_query_handler(pokemon_cb.filter(action='view'))
async def query_show_list(query: types.CallbackQuery, callback_data: dict, state: FSMContext):
start_id = int(callback_data['id'])
async with state.proxy() as data:
if data.get('stapList'):
data.get('stapList').append(start_id)
else:
InlineKeyboardButton(strings["no_btn"],
callback_data=wlcm_sec_config_cancel.new(
user_id=message.from_user.id, level=level)),
InlineKeyboardButton(strings["yes_btn"],
callback_data=wlcm_sec_config_proc.new(
chat_id=chat_id,
user_id=message.from_user.id,
level=level)))
await message.reply(
strings['ask_for_time_customization'].format(time=format_timedelta(
convert_time(get_str_key("JOIN_CONFIRM_DURATION")),
locale=strings['language_info']['babel'])),
reply_markup=buttons)
@register(wlcm_sec_config_cancel.filter(), f='cb', allow_kwargs=True)
@chat_connection(admin=True)
@get_strings_dec("greetings")
async def welcome_security_config_cancel(event: CallbackQuery, chat: dict,
strings: dict, callback_data: dict,
**_):
if int(callback_data['user_id']) == event.from_user.id and is_user_admin(
chat['chat_id'], event.from_user.id):
await event.message.edit_text(
text=strings['welcomesecurity_enabled'].format(
chat_name=chat['chat_title'], level=callback_data['level']))
@register(wlcm_sec_config_proc.filter(), f='cb', allow_kwargs=True)
@chat_connection(admin=True)
@get_strings_dec("greetings")
@get_strings_dec('feds')
async def del_fed_cmd(message, fed, strings):
fed_name = html.escape(fed['fed_name'], False)
fed_id = fed['fed_id']
fed_owner = fed['creator']
buttons = InlineKeyboardMarkup()
buttons.add(InlineKeyboardButton(text=strings['delfed_btn_yes'], callback_data=delfed_cb.new(fed_id=fed_id,
creator_id=fed_owner)))
buttons.add(InlineKeyboardButton(
text=strings['delfed_btn_no'], callback_data=f'cancel_{fed_owner}'))
await message.reply(strings['delfed'] % fed_name, reply_markup=buttons)
@decorator.register(delfed_cb.filter(), f='cb', allow_kwargs=True)
@get_strings_dec('feds')
async def del_fed_func(event, strings, callback_data=None, **kwargs):
fed_id = callback_data['fed_id']
fed_owner = callback_data['creator_id']
if event.from_user.id != int(fed_owner):
return
await db.feds.delete_one({'fed_id': fed_id})
await get_fed_by_id.reset_cache(fed_id)
await get_fed_by_creator.reset_cache(int(fed_owner))
async for subscribed_fed in db.feds.find({'subscribed': fed_id}):
await db.feds.update_one(
{'_id': subscribed_fed['_id']},
{'$pull': {'subscribed': fed_id}}
await start_review(query.from_user)
return
# Find floor options
await check_floors(query, pois)
@dp.callback_query_handler(REVIEW_HOUSE_CB.filter(), state='*')
async def review_from_house(query: types.CallbackQuery,
callback_data: Dict[str, str]):
house = callback_data['house']
pois = await db.get_poi_by_house(house)
await check_floors(query, pois, house)
@dp.callback_query_handler(FLOOR_CB.filter(), state='*')
async def select_floor(query: types.CallbackQuery, callback_data: Dict[str,
str]):
house = callback_data['house']
floor = callback_data['floor']
if floor == '*':
floor = None
await start_review(query.from_user, None if house == '-' else house, floor)
@dp.callback_query_handler(state='*', text='stop_review')
async def stop_review(query: types.CallbackQuery):
info = await get_user(query.from_user)
info.review = None
info.review_ctx = None
await delete_msg(bot, query)
callback_data=keyboards_query.new(
action='remote_control', value='reboot')),
InlineKeyboardButton('➕ Громкость',
callback_data=keyboards_query.new(
action='remote_control',
value='amixer -D pulse sset Master 10%+')),
InlineKeyboardButton('🌙 Выключение',
callback_data=keyboards_query.new(
action='remote_control',
value='shutdown -P 0.30')),
InlineKeyboardButton('➖ Громкость',
callback_data=keyboards_query.new(
action='remote_control',
value='amixer -D pulse sset Master 10%-')))
@dp.message_handler(commands='start')
async def select_report(message: types.Message):
await bot.send_message(message.chat.id,
'Выберите действие',
reply_markup=create_menu_keyboard())
@dp.callback_query_handler(keyboards_query.filter(action='remote_control'))
async def send_repo(query: types.CallbackQuery, callback_data: dict):
os.system(callback_data['value'])
if __name__ == '__main__':
executor.start_polling(dp)
callback_data='humor_value')
menu_kb_inl.add(button_inl_random)
await call.message.answer(mods.humor(), reply_markup=menu_kb_inl
) # +'Тут скоро будут шутки-прибаутки')
'''MENU'''
cb = CallbackData("post", "id", "action")
button = types.InlineKeyboardButton(text="Лайкнуть",
callback_data=cb.new(id=5, action="like"))
@dp.callback_query_handler(cb.filter())
async def callbacks(call: types.CallbackQuery, callback_data: dict):
post_id = callback_data["id"]
action = callback_data["action"]
@dp.message_handler(lambda message: message.text == 'foq_u')
async def foq_u(message: types.Message):
await message.reply('foq_u!')
''' ECHO '''
"""
@dp.message_handler()
async def echo(message: types.Message):
# old style:
reply_markup=get_kb_approve(index, chat_id)
)
def get_kb_approve(index: int, chat_id: int) -> InlineKeyboardMarkup:
return InlineKeyboardMarkup(inline_keyboard=[[
InlineKeyboardButton(
text="Да", callback_data=approve_cb.new(index=index, chat_id=chat_id, y_n="yes")
),
InlineKeyboardButton(
text="Нет", callback_data=approve_cb.new(index=index, chat_id=chat_id, y_n="no_one")
)
]])
@dp.callback_query_handler(approve_cb.filter(y_n="no_one"), is_superuser=True)
@dp.throttled(rate=3)
async def not_save_user_karma(callback_query: types.CallbackQuery, callback_data: typing.Dict[str, str]):
await callback_query.answer()
index = int(callback_data["index"])
chat_id = int(callback_data["chat_id"])
elem = get_element_approve(index)
save_problems_list((elem['name'], elem['username'], elem['karma']))
await callback_query.message.edit_text(**next_approve(get_element_approve(index + 1), index + 1, chat_id))
@dp.callback_query_handler(approve_cb.filter(y_n="yes"), is_superuser=True)
@dp.throttled(rate=3)
async def save_user_karma(callback_query: types.CallbackQuery, callback_data: typing.Dict[str, str]):
await callback_query.answer()
return types.InlineKeyboardMarkup().row(
types.InlineKeyboardButton('👍',
callback_data=vote_cb.new(action='up')),
types.InlineKeyboardButton('👎',
callback_data=vote_cb.new(action='down')))
@dp.message_handler(commands=['start'])
async def cmd_start(message: types.Message):
amount_of_likes = likes.get(message.from_user.id,
0) # get value if key exists else set to 0
await message.reply(f'Vote! Now you have {amount_of_likes} votes.',
reply_markup=get_keyboard())
@dp.callback_query_handler(vote_cb.filter(action='up'))
async def vote_up_cb_handler(query: types.CallbackQuery, callback_data: dict):
logging.info(
callback_data) # callback_data contains all info from callback data
likes[query.from_user.id] = likes.get(
query.from_user.id, 0) + 1 # update amount of likes in storage
amount_of_likes = likes[query.from_user.id]
await bot.edit_message_text(
f'You voted up! Now you have {amount_of_likes} votes.',
query.from_user.id,
query.message.message_id,
reply_markup=get_keyboard())
@dp.callback_query_handler(vote_cb.filter(action='down'))
await delete_restriction_message(users_id=users_id,
chat_id=chat_id,
message_id=message_id)
members_db.close()
return (user_id)
else:
members_db.close()
#if no users awaits unrestriction we can delete message for unrestriction
await delete_restriction_message(users_id=users_id,
chat_id=chat_id,
message_id=message_id)
members_db.close()
return (0)
@dp.callback_query_handler(button_click.filter(action=["done"]))
async def welcome_and_unrestrict(query, callback_data: typing.Dict[str, str]):
# handling pressing button. Unrestrict user and sending him welcome message
# welcome message will be deleted automatically after %delte_time time
user = query["from"]
message = query.message
await query.answer()
#check is user is restricted and return his id. return 0 otherwise
restricted_id = await unrestrict_and_check_user(
chat_id=message.chat.id,
user_id=user.id,
message_id=message.message_id)
logging.debug(restricted_id)
if restricted_id:
messages_db = SQLmessages()
date='0')))
start_keyboard.add(
InlineKeyboardButton(text='Афиша \U0001F4E2',
callback_data=date_cb.new(action='show_all',
date='0')))
await message.answer(
"Привет! \n"
"Я телеграм-бот кинотеатра 'Два луча' и я могу помочь тебе выбрать подходящий сеанс. \n"
"Выбери 'Показать календарь', чтобы выбрать подходящую дату похода в кино. \n"
"Или нажимай 'Афиша', чтобы увидеть все фильмы в прокате",
reply_markup=start_keyboard)
# Нажатие на кнопку "Календарь"
@dp.callback_query_handler(date_cb.filter(action='show_calendar'))
async def show_calendar(query: CallbackQuery):
"""
Shows calendar
:param query:
:return:
"""
keyboard = InlineKeyboardMarkup()
db = DBDriver()
for date in db.get_dates():
keyboard.add(
InlineKeyboardButton(text=format_date(date[1]),
callback_data=date_cb.new(action='show_date',
date=date[2])))
await bot.send_message(
page = int(message.get_args()) * 6 - 5 #
async with state.proxy() as data:
#.get() - бля якшо существуэ то верне существующый якшо немає то верне новий пустий
l = data.get('StorageList', [])
data['StorageList'] = l
data['StorageList'].insert(
0, page) #вродіби так інсертить на 0 позіцию твої данні
print("data[st..]-->>")
print(data['StorageList'][0])
data['StorageList'][0] = page
await message.reply("Page:{}".format(int(args) // 6 + 1),
reply_markup=await
get_pokemon_list_keyboard(int(page)))
@dp.callback_query_handler(pokemon_cb.filter(action='page'))
async def query_show_list(query: types.CallbackQuery, callback_data: dict,
state: FSMContext):
start_id = int(callback_data['id'])
async with state.proxy() as data:
print(data['StorageList'][0])
data['StorageList'][0] = start_id
async with state.proxy() as data:
if callback_data['Del'] == 'yes':
print("Srabotolo Del______________")
data['StorageList'].pop(-1)
print(data['StorageList'][0])
await query.message.edit_text('Page:{}'.format(int(start_id) // 6 + 1),
reply_markup=await
get_pokemon_list_keyboard(int(start_id)))
disable_web_page_preview=True)
@register(cmds='lang', user_admin=True, has_args=True)
@get_strings_dec('language')
async def select_lang_msg(message, strings):
lang = get_arg(message).lower()
if lang not in LANGUAGES:
await message.reply(strings['not_supported_lang'])
return
await change_lang(message, lang)
@register(select_lang_cb.filter(), user_admin=True, f='cb', allow_kwargs=True)
async def select_lang_callback(query, callback_data=None, **kwargs):
lang = callback_data['lang']
back_btn = callback_data['back_btn']
await change_lang(query.message, lang, e=True, back_btn=back_btn)
async def __stats__():
return f"* <code>{len(LANGUAGES)}</code> languages loaded.\n"
async def __export__(chat_id):
lang = await get_chat_lang_info(chat_id)
return {'language': lang['code']}
for idx, title in await db.fetchall('SELECT * FROM categories'):
markup.add(
InlineKeyboardButton(title,
callback_data=category_cb.new(id=idx,
action='view')))
markup.add(
InlineKeyboardButton('+ Добавить категорию',
callback_data='add_category'))
await message.answer('Настройка категорий:', reply_markup=markup)
@dp.callback_query_handler(IsAdmin(), category_cb.filter(action='view'))
async def category_callback_handler(query: CallbackQuery, callback_data: dict,
state: FSMContext):
category_idx = callback_data['id']
products = await db.fetchall(
'''SELECT * FROM products product
WHERE product.tag = (SELECT title FROM categories WHERE idx=$1)''',
(category_idx, ))
await query.message.delete()
await query.answer('Все добавленные товары в эту категорию.')
await state.update_data(category_index=category_idx)
await show_products(query.message, products, category_idx)
button = help_markup(MOD_HELP)
button.add(InlineKeyboardButton(
strings['back'], callback_data='go_to_start'))
await message.reply(strings['help_header'], reply_markup=button)
@register(cmds='help', only_groups=True)
@disableable_dec('help')
@get_strings_dec('pm_menu')
async def help_cmd_g(message, strings):
text = (strings['btn_group_help'])
button = InlineKeyboardMarkup().add(InlineKeyboardButton(
text=text, url="https://t.me/Hitsuki_BOT?start"))
await message.reply(strings['help_header'], reply_markup=button)
@register(helpmenu_cb.filter(), f='cb', allow_kwargs=True)
@get_strings_dec('pm_menu')
async def helpmenu_callback(query, strings, callback_data=None, **kwargs):
mod = callback_data['mod']
if not mod in MOD_HELP:
await query.answer()
return
msg = strings["help_for"].format(mod_name=mod)
msg += f"{MOD_HELP[mod]}"
button = InlineKeyboardMarkup().add(
InlineKeyboardButton(text=strings['back'], callback_data='get_help'))
with suppress(MessageNotModified):
await query.message.edit_text(msg, disable_web_page_preview=True, reply_markup=button)
await query.answer(strings["help_for_a"].format(mod_name=mod))
await db.antiflood.update_one({"chat_id": chat['chat_id']},
{"$set": {
"action": action
}},
upsert=True)
await get_data.reset_cache(message.chat.id)
return await message.reply(
strings['setfloodaction_success'].format(action=action))
async def __before_serving__(_):
dp.middleware.setup(AntifloodEnforcer())
@register(cancel_state.filter(), f='cb')
async def cancel_state_cb(event: CallbackQuery):
await event.message.delete()
@cached()
async def get_data(chat_id: int):
return await db.antiflood.find_one({'chat_id': chat_id})
async def __export__(chat_id: int):
data = await get_data(chat_id)
if not data:
return
del data['_id'], data['chat_id']
InlineKeyboardButton(strings["back"], callback_data="go_to_start"))
await message.reply(strings["help_header"], reply_markup=button)
@register(cmds="help", only_groups=True)
@disableable_dec("help")
@get_strings_dec("pm_menu")
async def help_cmd_g(message, strings):
text = strings["btn_group_help"]
button = InlineKeyboardMarkup().add(
InlineKeyboardButton(text=text,
url="http://t.me/DoraemonxRobot?start"))
await message.reply(strings["help_header"], reply_markup=button)
@register(helpmenu_cb.filter(), f="cb", allow_kwargs=True)
async def helpmenu_callback(query, callback_data=None, **kwargs):
mod = callback_data["mod"]
if not mod in MOD_HELP:
await query.answer()
return
msg = f"Help for <b>{mod}</b> module:\n"
msg += f"{MOD_HELP[mod]}"
button = InlineKeyboardMarkup().add(
InlineKeyboardButton(text="Back", callback_data="get_help"))
with suppress(MessageNotModified):
await query.message.edit_text(msg,
disable_web_page_preview=True,
reply_markup=button)
await query.answer("Help for " + mod)
).format(users=", ".join(users.values())),
reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[buttons]),
)
await join_list.create_list(
chat_id=message.chat.id, message_id=msg.message_id, users=users.keys()
)
return True
@dp.message_handler(content_types=types.ContentTypes.LEFT_CHAT_MEMBER)
async def left_chat_member(message: types.Message):
# TODO: Remove user from join-list when user was left from chat
raise SkipHandler
@dp.callback_query_handler(cb_join_list.filter())
async def cq_join_list(query: types.CallbackQuery, callback_data: dict):
answer = callback_data["answer"]
logger.info(
"User {user} choose answer {answer} in join-list in chat {chat} and message {message}",
user=query.from_user.id,
chat=query.message.chat.id,
answer=repr(answer),
message=query.message.message_id,
)
in_list = await join_list.pop_user_from_list(
chat_id=query.message.chat.id,
message_id=query.message.message_id,
user_id=query.from_user.id,
)
if not in_list:
text = ''
text += strings['select_chat_to_connect']
markup = InlineKeyboardMarkup(row_width=1)
for chat_id in reversed(connected_data['history'][-3:]):
chat = await db.chat_list.find_one({'chat_id': chat_id})
markup.insert(
InlineKeyboardButton(
chat['chat_title'],
callback_data=connect_to_chat_cb.new(chat_id=chat_id)))
await message.reply(text, reply_markup=markup)
# Callback for prev. function
@register(connect_to_chat_cb.filter(), f='cb', allow_kwargs=True)
async def connect_chat_keyboard_cb(message, callback_data=False, **kwargs):
chat_id = int(callback_data['chat_id'])
chat = await db.chat_list.find_one({'chat_id': chat_id})
await def_connect_chat(message.message,
message.from_user.id,
chat_id,
chat['chat_title'],
edit=True)
# In pm with args - connect to chat by arg
@register(cmds='connect', has_args=True, only_pm=True)
@get_chat_dec()
@get_strings_dec('connections')
async def connect_to_chat_from_arg(message, chat, strings):
else:
answer_text = (
"Щоб я запам'ятав твій нік на сервері, будь ласка, скопіюй та "
"надішли наступну команду в чаті Minecraft:\n\n"
f"<pre>/link {message.from_user.id}</pre>")
await message.answer(answer_text,
parse_mode="html",
disable_web_page_preview=True,
reply_markup=reply_markup,
reply=reply_to_msg)
return True
@dp.callback_query_handler(lambda cbq: types.ChatType.is_private(cbq.message),
cb_linking.filter())
async def cq_linking(query: types.CallbackQuery, callback_data: dict,
user: User):
logger.info(
"User {user_id} try to link Minecraft account to Telegram user.",
user_id=query.from_user.id)
if user.mc_username:
query_answer_text = "Я пам'ятаю твій нікнейм."
new_message_text = (
f"Твій нік на сервері вже збережено - <b>{user.mc_username}</b>!")
else:
await user.update(mc_username=callback_data["mc_username"]).apply()
await state.finish()
path_list = path(message.chat.id, user_data['folder_name'])
os.makedirs(path_list.tmp_audio_samples())
os.makedirs(path_list.processed_audio_samples())
os.makedirs(path_list.tmp_query_audio())
os.makedirs(path_list.processed_query_audio())
os.makedirs(path_list.fingerprint_db_dir_path(), exist_ok=True)
db.create_folder(message.chat.id, user_data['folder_name'])
await message.reply(f'Папка "{user_data["folder_name"]}" создана!')
await folder_list_menu_message(message, 'start')
@dp.callback_query_handler(remove_folder_cb.filter(), state='*')
async def delete_folder_step_1_message(call: types.CallbackQuery,
callback_data: dict):
folder_id = int(callback_data['folder_id'])
folder_info = db.select_folder(folder_id)
keyboard_markup = types.InlineKeyboardMarkup()
delete_btn = types.InlineKeyboardButton(
'Да!', callback_data=remove_folder_process_cb.new(folder_id))
back_btn = types.InlineKeyboardButton(
'« ', callback_data=manage_folder_cb.new(folder_id))
keyboard_markup.row(delete_btn)
keyboard_markup.row(back_btn)
await call.message.edit_text(
f'Вы действительно хотите удалить папку "{folder_info[1]}"?\n'
f'Также будут удалены ВСЕ аудио сэмплы, которые находятся в папке "{folder_info[1]}".\n\n'
await ReleaseState.sel_build_type.set()
text = "<b>Releasing new OrangeFox build</b>"
text += "\nSelect build type:"
buttons = InlineKeyboardMarkup(row_width=2).add(
InlineKeyboardButton(
"Stable", callback_data=build_type_cp.new(build_type='stable')),
InlineKeyboardButton(
"Beta/RC", callback_data=build_type_cp.new(build_type='beta')))
buttons.add(InlineKeyboardButton("Exit", callback_data='cancel'))
await message.reply(text, reply_markup=buttons)
@dp.callback_query_handler(build_type_cp.filter(), state="*")
async def upload_file_promt(query, callback_data, state, **kwargs):
await ReleaseState.upload_file.set()
async with state.proxy() as data:
data['build_type'] = callback_data['build_type']
text = f'Great! Please now upload your file here.'
await query.message.edit_text(text)
@dp.message_handler(state=ReleaseState.upload_file,
content_types=types.ContentTypes.DOCUMENT)
async def upload_file(message, state, **kwargs):
msg = await message.reply("Downloading file...")
# Parse filename
file_name = message.document.file_name
#
# handlers
@dp.message_handler(Command('start'))
async def start_command(msg: Message):
await msg.reply(
text='используйте комманду /help что бы ознакомиться с функциями бота')
@dp.message_handler(Command('buy'))
async def buy_cube(msg: Message):
await msg.answer('выбирайте фирму куба', reply_markup=choice)
@dp.callback_query_handler(bot_callback.filter(item_name='gan'))
async def buying_gan(call: CallbackQuery, callback_data: dict):
await call.answer(cache_time=60)
await call.message.answer(text='вот все возможные кубы фирмы Gan',
reply_markup=choice_gans_category)
@dp.callback_query_handler(bot_callback.filter(item_name='gan'))
async def buying_gan(call: CallbackQuery, callback_data: dict):
await call.answer(cache_time=60)
await call.message.answer(text='вот все возможные кубы фирмы Gan',
reply_markup=choice_gans_category)
@dp.callback_query_handler(bot_callback.filter(item_name='ganx'))
async def buying_gan(call: CallbackQuery, callback_data: dict):
return False
poi = await db.get_next_unchecked()
if not poi:
await bot.send_message(user.id, tr(('queue', 'empty')))
return True
await print_poi(user, poi)
content = tr(('queue', 'new_poi'))
kbd = types.InlineKeyboardMarkup().add(
types.InlineKeyboardButton(
'✔️ ' + tr(('queue', 'validated')),
callback_data=POI_VALIDATE_CB.new(id=str(poi.id))))
await bot.send_message(user.id, content, reply_markup=kbd)
@dp.callback_query_handler(POI_VALIDATE_CB.filter(), state='*')
async def validate_poi(query: types.CallbackQuery, callback_data: Dict[str,
str]):
poi = await db.get_poi_by_id(int(callback_data['id']))
if not poi:
await query.answer(tr(('queue', 'poi_lost')))
return
await db.validate_poi(poi.id)
await query.answer(tr(('queue', 'validated_ok')))
await print_next_queued(query.from_user)
async def print_next_queued(user: types.User):
info = await get_user(user)
if not info.is_moderator():
return False
if handler is not None:
await message.reply(text, reply_markup=buttons)
async def save_filter(message, data, strings):
if await db.filters.find_one(data):
# prevent saving duplicate filter
await message.reply("Duplicate filter!")
return
await db.filters.insert_one(data)
await update_handlers_cache(data["chat_id"])
await message.reply(strings["saved"])
@register(filter_action_cp.filter(), f="cb", allow_kwargs=True)
@chat_connection(only_groups=True, admin=True)
@get_strings_dec("filters")
async def register_action(
event, chat, strings, callback_data=None, state=None, **kwargs
):
if not await is_user_admin(event.message.chat.id, event.from_user.id):
return await event.answer("You are not admin to do this")
filter_id = callback_data["filter_id"]
action = FILTERS_ACTIONS[filter_id]
user_id = event.from_user.id
chat_id = chat["chat_id"]
handler = redis.get(f"add_filter:{user_id}:{chat_id}")
'Oops... Something went wrong, please call the command again!')
try:
os.remove('tmp/NekobinRobot_' + str(randomint) + ".jpg")
except:
pass
try:
x[str(ch_id)]['url'].pop(0)
except:
traceback.print_exc()
try:
x[str(ch_id)]['id'].pop(0)
except:
traceback.print_exc()
@dp.callback_query_handler(callback_cb.filter(function='→ Next'))
async def callback_more(query: types.CallbackQuery, callback_data: dict):
try:
c_id = parse_data['commands'].index(lastcmd.get(query.message.chat.id))
except:
c_id = 1
await query.message.edit_reply_markup()
await commands(message=query.message,
chan=parse_data['chan'][c_id],
data=lastcmd.get(query.message.chat.id))
@dp.callback_query_handler(callback_cb.filter(function='↧ Download'))
async def callback_download(query: types.CallbackQuery, callback_data: dict):
await query.message.edit_reply_markup()
await idd(message=query.message, tags='id:' + callback_data['data'])
@register(cmds="lang", has_args=True, user_can_change_info=True)
@get_strings_dec("language")
async def select_lang_msg(message, strings):
lang = get_arg(message).lower()
if lang not in LANGUAGES:
await message.reply(strings["not_supported_lang"])
return
await change_lang(message, lang)
@register(
select_lang_cb.filter(),
f="cb",
allow_kwargs=True,
)
async def select_lang_callback(query, callback_data=None, **kwargs):
lang = callback_data["lang"]
back_btn = callback_data["back_btn"]
await change_lang(query.message, lang, e=True, back_btn=back_btn)
async def __stats__():
return f"* <code>{len(LANGUAGES)}</code> languages loaded.\n"
async def __export__(chat_id):
lang = await get_chat_lang_info(chat_id)
message, parse_mode=types.ParseMode.MARKDOWN)
keyboard = inline_keyboard_factory(inline_query=query, name=name)
results.append(
types.InlineQueryResultArticle(
id=index,
title=name.title(),
input_message_content=content,
reply_markup=keyboard,
))
await bot.answer_inline_query(inline_query.id,
results=results,
cache_time=1)
@dp.callback_query_handler(quote_cb.filter(query_type=QueryType.INLINE.value))
async def inline_callback_handler(query, callback_data):
logger.info("inline_callback_handler, callback_data=%r", callback_data)
message_text = quotes.quote(callback_data["name"])
keyboard = inline_keyboard_factory(
inline_query=callback_data["inline_query"],
name=callback_data["name"],
)
try:
await bot.edit_message_text(
inline_message_id=query.inline_message_id,
text=message_text,
parse_mode=types.ParseMode.MARKDOWN,
reply_markup=keyboard,
)
