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, )