async def btm(query: types.CallbackQuery): answer_data = query.data if answer_data == "back_to_main": query.answer("....") await query.message.edit_text("Welcome", reply_markup=main_markup()) else: query.answer("oops Error :(")
async def product(callback: types.CallbackQuery, state: FSMContext): data = await state.get_data() if data == {}: await callback.message.edit_text('Что вы ищете?', reply_markup=clothes_kb.type_object) await callback.answer() await state.reset_data() return await callback.answer() await state.update_data(number=None) i = 0 # номер страницы товара p = False # маркер выхода из меню товара в категории part = 'previous_part' if callback.data == 'product': callback.data = data['part'] p = True if callback.data == 'next_part': part = callback.data callback.data = data['sex'] i = 1 elif callback.data == 'previous_part': part = callback.data callback.data = data['sex'] await state.update_data(sex=callback.data, part=part) if p: await callback.message.edit_text('Выберите товар:', reply_markup=change[data['type']][callback.data][i]) await callback.answer() return else: await callback.answer() await callback.message.edit_reply_markup(reply_markup=change[data['type']][callback.data][i]) return
async def calendar_notification_watch_handler(query: CallbackQuery, callback_data: dict): user_id = query.from_user.id episode_id = callback_data['id'] prev_watched = callback_data.get('watched') == '1' store = Storage.get_current() sess, user_pref = await asyncio.gather(trakt_session(user_id), store.get_pref(user=user_id)) on_watch = user_pref.get('on_watch', 'hide') watched = await sess.watched(episode_id) # if message was created more than 48 hours ago then it cannot be deleted now = datetime.now() delta = now - query.message.date if on_watch == 'delete' and delta >= timedelta(hours=48): warn = await query.message.reply( "quick note: bot cannot delete messages older then 48 hours", disable_notification=True) asyncio.create_task(postponed_delete(warn, delay=5)) on_watch = 'hide' # delete message if it is marked as watched if on_watch == 'delete': watched = await toggle_watched_status(sess, episode_id, watched) if watched: logger.debug("episode is watched and on_watch=delete") await asyncio.gather( store.update_data(user=user_id, data={'deleted_episode': episode_id}), query.message.delete(), query.answer("added to history"), ) return # sync with current watch status else: if watched is prev_watched: watched = await toggle_watched_status(sess, episode_id, watched) else: msg = 'watched' if watched else 'unwatched' logger.debug(f"user already marked this as {msg}") se = await sess.search_by_episode_id(episode_id, extended=True) logger.debug(se) # update keyboard hide = on_watch == 'hide' markup = await CalendarNotification.markup(se, watched, hide=hide) await asyncio.gather( query.message.edit_text(query.message.html_text, reply_markup=markup, disable_web_page_preview=hide and watched), query.answer( "added to history" if watched else "removed from history"), )
async def test_cb_zero(self): cb = CallbackData('zero') assert cb.new() == 'zero' assert (await cb.filter().check(CallbackQuery(data='zero'))) == { 'callback_data': { '@': 'zero' } } assert (await cb.filter().check(CallbackQuery(data='zero:'))) is False assert (await cb.filter().check(CallbackQuery(data='bla'))) is False
async def test_callback_query_reserve_book(self): """Reserve state main message""" test_message = Message() test_message.chat = self.chat test_message.from_user = self.user test_message.message_id = 122 test_callback_query = CallbackQuery() test_callback_query.message = test_message await self.callback_query_reserve_book(test_callback_query) passed, alert = self.assert_params(self.result_text, "Callback: reserve book") assert passed, alert
async def on_pre_process_callback_query(self, event: CallbackQuery, data: dict): proxy = StorageProxy( storage=self.storage, user_id=event.from_user.id, chat_id=event.message.chat.id, state_groups=self.state_groups, ) data[STORAGE_KEY] = proxy original_data = event.data intent_id, callback_data = remove_indent_id(event.data) if intent_id: context = await proxy.load_context(intent_id) stack = await proxy.load_stack(context.stack_id) if stack.last_intent_id() != intent_id: logger.warning( f"Outdated intent id ({intent_id}) for stack ({stack.id})") raise CancelHandler() event.data = callback_data else: context = None stack = await proxy.load_stack() data[STACK_KEY] = stack data[CONTEXT_KEY] = context data[CALLBACK_DATA_KEY] = original_data
async def _send(self, image: BytesIO, *kb_list: InlineKeyboardMarkup): bot = Bot.get_current() user = User.get_current() call = CallbackQuery.get_current() message = Message.get_current() kb_list = [kb for kb in kb_list if kb] # clean from None if call: reply_to = call.message.message_id elif message: reply_to = message and message.message_id else: reply_to = None if len(kb_list) == 0: kb = None elif len(kb_list) == 1: kb = kb_list[0] else: kb = inline.merge_inline_keyboards(kb_list[0], kb_list[1]) await bot.send_photo(user.id, image, reply_markup=kb, reply_to_message_id=reply_to)
async def show_watch_btn(c: CallbackQuery): kp_id: int = int(c.data.split('|')[1]) film = await hdvb.find_by_kp_id(kp_id) if film.kinopoisk_id: views_counter.increment_day_views() await c.bot.edit_message_reply_markup( chat_id=c.from_user.id, message_id=c.message.message_id, reply_markup=templates.btn_search_film(film.iframe_url, film.kinopoisk_id, more_btn=False)) await hdvb.up_film_rating(film) else: c.answer('Ошибка')
async def modify_message(query: CallbackQuery): """ That's how `Markup` and `Markdown` buttons work Basically it edits message just changing its parse_mode """ message = query.message if query.data == SHOW_FORMATTED: bot.parse_mode = detect_message_text_formatting(message) markup = SHOW_RAW_MARKUP new_text = message.text else: markup = SHOW_FORMATTED_MARKUP to_html = query.data == SHOW_RAW_HTML with dont_change_plain_urls: bot.parse_mode = 'html' if to_html else 'markdown' # https://github.com/aiogram/aiogram/pull/205/ new_text = message.html_text if to_html else message.md_text bot.parse_mode = None answer_callback = asyncio.create_task( query.answer()) # remove 'Loading...' on user side quickly try: await message.edit_text(new_text, disable_web_page_preview=True, reply_markup=markup) except CantParseEntities as e: answer_callback.cancel() await query.answer(str(e), show_alert=True) except MessageNotModified: answer_callback.cancel() await query.answer('Message has no formatting') else: await answer_callback
async def on_process_callback_query(self, call: types.CallbackQuery, _: dict): """ This handler is called when dispatcher receives a call """ # Get current handler call.conf['neko'] = self.neko call.message.conf['neko'] = self.neko call.message.from_user = call.from_user
async def set_default_mode(cls, c: CallbackQuery): user_db = ForwardsToTextUser(c.from_user.id) user_db.set_default_mode(c.data.split()[-1]) try: c.data = 'fwd_to_text settings default_mode' await cls.start_setting_default_mode(c) except tg_excs.MessageNotModified: await bot.answer_callback_query(c.id, 'Ничего не изменено.')
async def update_boolean(query: types.CallbackQuery, callback_data: Dict[str, str], state: FSMContext): poi = (await state.get_data())['poi'] attr = callback_data['attr'] svalue = callback_data['value'] if svalue == 'null': value = None else: value = svalue == 'true' if attr == 'wifi': poi.has_wifi = value elif attr == 'cards': poi.accepts_cards = value else: query.answer(f'Unknown field {attr}') await delete_msg(query) await state.set_data({'poi': poi}) await EditState.confirm.set() await print_edit_options(query.from_user, state)
async def test_cb(self): cb = CallbackData('simple', 'action') assert cb.new('x') == 'simple:x' assert cb.new(action='y') == 'simple:y' assert cb.new('') == 'simple:' assert (await cb.filter().check(CallbackQuery(data='simple:'))) == { 'callback_data': { '@': 'simple', 'action': '' } } assert (await cb.filter().check(CallbackQuery(data='simple:x'))) == { 'callback_data': { '@': 'simple', 'action': 'x' } } assert (await cb.filter(action='y').check( CallbackQuery(data='simple:x'))) is False
async def any_callback(callback: types.CallbackQuery): message = callback.message user_id, message_id = message.chat.id, message.message_id table = db_main.Table(tables.names_dict["delivery_adress"]) adresses = table.select_all(["id", "delivery_adress"]) table.close() keyboard, callback, text = [], [], "" for adress_id, adress in adresses: keyboard.append([adress]) callback.append(["set_adress {adress_id}".format(adress_id=adress_id)]) text += adress + "\n" keyboard.append(["Отмена"]) callback.append(["cancel_adress"]) await bot.send_message(user_id, text, reply_markup=keyboard_main.inline( keyboard, callback))
async def help_(query: types.CallbackQuery): answer_data = query.data query.answer("welcome ...") if answer_data == "help_cb": await bot.send_message(query.from_user.id, """ well hi {} iam TyNy bot Im here to manage your groups \n\n Notice : DO NOT FORGET TO MAKE ME ADMIN My Commands = /ban => use this to kick someone from your group /mute [time] => use this to mute someone pin => use this to pin a message unpin => use this to unpin your group message unban => use this to unban a banned member :| dice => Fun command group info => shows your group info admins => shows admin groups :/ lock on => it will lock your group ( No one can send message until you unlock it) lock off => it will unlock your group lock content => it will lock the media messages :/ unlock content => it will unlock your contents Link => it will show you your group link world info => shows some information about corona virus and BTC Price and ..... HOPE YOU ENJOY =) """.format(query.from_user.first_name), reply_markup=back_to_first()) elif answer_data == "ad_cb": await bot.send_message(query.from_user.id, """ Developed by iPzX @iPzXx source = https://github.com/ipzx/TyNy-bot """, reply_markup=back_to_first())
async def test_cb_double(self): cb = CallbackData('double', 'pid', 'action') assert cb.new('123', 'x') == 'double:123:x' assert cb.new(pid=456, action='y') == 'double:456:y' assert cb.new('', 'z') == 'double::z' assert cb.new('789', '') == 'double:789:' assert (await cb.filter().check(CallbackQuery(data='double::'))) == { 'callback_data': { '@': 'double', 'pid': '', 'action': '' } } assert (await cb.filter().check(CallbackQuery(data='double:x:'))) == { 'callback_data': { '@': 'double', 'pid': 'x', 'action': '' } } assert (await cb.filter().check(CallbackQuery(data='double::y'))) == { 'callback_data': { '@': 'double', 'pid': '', 'action': 'y' } } assert (await cb.filter(action='x').check(CallbackQuery(data='double:123:x') )) == { 'callback_data': { '@': 'double', 'pid': '123', 'action': 'x' } }
async def handle_callback(cq: types.CallbackQuery): data = json.loads(cq.as_json()) chat_id = data.get("message").get("chat").get("id") message_id = data.get("message").get("message_id") callback_data = data.get("data") if callback_data is None: return is_media = callback_data.startswith("media") is_target = callback_data.startswith("target") if is_media: _, id = callback_data.split(":", 1) updated_media = await db.update_media(chat_id, int(id)) await bot.edit_message_text( f"*Выбрать СМИ*\nВыбрано источников: {len(updated_media)}", chat_id, message_id, ) await bot.edit_message_reply_markup( chat_id, message_id, reply_markup=get_media_keyboard_markup(updated_media)) return if is_target: _, target = callback_data.split(":", 1) updated_targets = await db.update_targets(chat_id, target) updated_targets_count = len(updated_targets) if updated_targets_count == 0: await bot.edit_message_text("Нет ни одной цели", chat_id, message_id) try: await bot.edit_message_reply_markup(chat_id, message_id, reply_markup=None) except MessageNotModified: pass else: await bot.edit_message_text( f"Число целей: {updated_targets_count}", chat_id, message_id) await bot.edit_message_reply_markup( chat_id, message_id, reply_markup=get_targets_keyboard_markup(updated_targets), ) return
async def test_equals_list(self, test_filter_list, test_text, ignore_case): test_filter = Text(equals=test_filter_list, ignore_case=ignore_case) async def check(obj): result = await test_filter.check(obj) if ignore_case: _test_filter_list = list(map(str.lower, test_filter_list)) _test_text = test_text.lower() else: _test_filter_list = test_filter_list _test_text = test_text assert result is (_test_text in _test_filter_list) await check(Message(text=test_text)) await check(CallbackQuery(data=test_text)) await check(InlineQuery(query=test_text)) await check(Poll(question=test_text))
async def test_equals_string(self, test_filter_text, test_text, ignore_case): test_filter = Text(equals=test_filter_text, ignore_case=ignore_case) async def check(obj): result = await test_filter.check(obj) if ignore_case: _test_filter_text = test_filter_text.lower() _test_text = test_text.lower() else: _test_filter_text = test_filter_text _test_text = test_text return result is (_test_text == _test_filter_text) assert await check(Message(text=test_text)) assert await check(CallbackQuery(data=test_text)) assert await check(InlineQuery(query=test_text)) assert await check(Poll(question=test_text))
async def test_startswith(self, test_prefix, test_text, ignore_case): test_filter = Text(startswith=test_prefix, ignore_case=ignore_case) async def check(obj): result = await test_filter.check(obj) if ignore_case: _test_prefix = test_prefix.lower() _test_text = test_text.lower() else: _test_prefix = test_prefix _test_text = test_text return result is _test_text.startswith(_test_prefix) assert await check(Message(text=test_text)) assert await check(CallbackQuery(data=test_text)) assert await check(InlineQuery(query=test_text)) assert await check(Poll(question=test_text))
async def _update(self, image: BytesIO, *kb_list: InlineKeyboardMarkup): bot = Bot.get_current() user = User.get_current() call = CallbackQuery.get_current() media = InputMedia(media=image) if len(kb_list) == 0: kb = None elif len(kb_list) == 1: kb = kb_list[0] else: kb = inline.merge_inline_keyboards(kb_list[0], kb_list[1]) await bot.edit_message_media(media, user.id, call.message.message_id, reply_markup=kb)
async def test_endswith_list(self, test_postfix_list, test_text, ignore_case): test_filter = Text(endswith=test_postfix_list, ignore_case=ignore_case) async def check(obj): result = await test_filter.check(obj) if ignore_case: _test_postfix_list = map(str.lower, test_postfix_list) _test_text = test_text.lower() else: _test_postfix_list = test_postfix_list _test_text = test_text return result is any(map(_test_text.endswith, _test_postfix_list)) assert await check(Message(text=test_text)) assert await check(CallbackQuery(data=test_text)) assert await check(InlineQuery(query=test_text)) assert await check(Poll(question=test_text))
async def test_contains_list(self, test_filter_list, test_text, ignore_case): test_filter = Text(contains=test_filter_list, ignore_case=ignore_case) async def check(obj): result = await test_filter.check(obj) if ignore_case: _test_filter_list = list(map(str.lower, test_filter_list)) _test_text = test_text.lower() else: _test_filter_list = test_filter_list _test_text = test_text return result is all( map(_test_text.__contains__, _test_filter_list)) assert await check(Message(text=test_text)) assert await check(CallbackQuery(data=test_text)) assert await check(InlineQuery(query=test_text)) assert await check(Poll(question=test_text))
def callback(call: CallbackQuery): """Callback's handler.""" call.answer(cache_time=6) callback_data = call.data logging.info(f'{callback_data=}') return callback_data
async def unknow_query_handler(query: types.CallbackQuery): logger.info('Got this callback data: {}', query.data) logger.info('Got this query.as_json: {}', query.as_json()) await query.answer("Don't know what to do))")
async def _run_check(check, test_text): assert await check(Message(text=test_text)) assert await check(CallbackQuery(data=test_text)) assert await check(InlineQuery(query=test_text)) assert await check(Poll(question=test_text))
async def query_handler(query: types.CallbackQuery): user = await db.users.find_one({'uid': query.from_user.id}) if user is None: return await query.answer() if query.data.startswith('CertReg'): await db.users.find_one_and_update({'uid': user['uid']}, {'$set': {'stage': Stage.get_certnum}}) return await query.message.edit_text(t('GET_CERTNUM')) elif query.data.startswith('ManualReg'): template = (await aq.aapi.get_registration_template())['template'] num = len(template['tokens']) await db.users.find_one_and_update({'uid': user['uid']}, {'$set': {'stage': Stage.template, 'template_stage': 0, 'tokens_num': num, 'template': template}}) await query.message.answer(template['tokens'][0]['text']) elif query.data.startswith('AllQueues'): queues = (await aq.aapi.list_queues())['queues'] num = len(list(filter(lambda x: x['active'], queues))) if num > 0: await query.message.edit_text(t('ALL_QUEUES', locale=user['lang']), reply_markup=keyboards.get_queues_kbd(queues, my_queues=False)) else: await query.answer(t('NO_QUEUES', locale=user['lang'])) elif query.data.startswith('MyQueues'): user_data = await aq.aapi.get_user_info(user['uid']) queues = user_data['queues'] num = len(list(filter(lambda x: x['active'], queues))) if num > 0: await query.message.edit_text(t('MY_QUEUES', locale=user['lang']), reply_markup=keyboards.get_queues_kbd(queues, my_queues=True)) else: await query.answer(t('NO_MY_QUEUES', locale=user['lang'])) elif query.data.startswith('GetQueue'): user_data = await aq.aapi.get_user_info(user['uid']) queues = user_data['queues'] queue_id = int(query.data.split('GetQueue', 1)[1]) if any(map(lambda x: queue_id == x['id'], queues)): # user already in queue query.data = f'GetMyQueue{queue_id}' # edit data to pass query to GetMyQueue handler await query_handler(query) # recursive call modified query else: await db.users.find_one_and_update({'uid': user['uid']}, {'$set': {'get_queue': queue_id, 'stage': Stage.geo}}) return await query.message.answer(t('GEO', locale=user['lang']), reply_markup=keyboards.get_geo_kbd(user['lang'])) elif query.data.startswith('GetMyQueue'): user_data = await aq.aapi.get_user_info(user['uid']) queues = user_data['queues'] queue_id = int(query.data.split('GetMyQueue', 1)[1]) try: queue = list(filter(lambda x: queue_id == x['id'], queues))[0] except IndexError: return await query.answer(t('USER_NO_MORE_IN_QUEUE'), user['lang']) try: if queue['position']['status'] == 'processing': return await query.message.edit_text(t('USER_QUEUE_PROCESSING', locale=user['lang'], queue_name=queue['name']), reply_markup=keyboards.get_update_my_queue_kbd(queue_id, user['lang']), parse_mode=types.ParseMode.HTML) elif queue['position']['status'] == 'waiting': return await query.message.edit_text(t('USER_QUEUE_INFO', locale=user['lang'], queue_name=queue['name'], pos=queue['position']['relativePosition']), reply_markup=keyboards.get_update_my_queue_kbd(queue_id, user['lang']), parse_mode=types.ParseMode.HTML) else: logger.error('Unknown queue position status', queue['position']['status']) except exceptions.MessageNotModified: await query.answer(t('NO_UPDATES', locale=user['lang'])) elif query.data.startswith('LeaveQueue'): queue_id = int(query.data.split('LeaveQueue', 1)[1]) await db.users.find_one_and_update({'uid': user['uid']}, {'$set': {'leave_queue': queue_id, 'stage': Stage.leave_queue}}) return await query.message.edit_text(t('LEAVE_QUEUE'), reply_markup=keyboards.get_to_menu_kbd(user['lang'])) elif query.data.startswith('RegInQueue'): queue_id = int(query.data.split('RegInQueue', 1)[1]) await aq.aapi.add_user_to_queue(user['uid'], queue_id) await query.message.edit_text(t('REGISTER_IN_QUEUE_SUCCESS', locale=user['lang']), reply_markup=keyboards.get_menu_kbd(user['lang'])) elif query.data.startswith('Menu'): await db.users.find_one_and_update({'uid': user}, {'$set': {'stage': Stage.menu}}) await query.message.edit_text(t('MENU', locale=user['lang']), reply_markup=keyboards.get_menu_kbd(user['lang']), parse_mode=types.ParseMode.HTML) elif query.data.startswith('ChangeData'): await db.users.delete_one({'uid': user['uid']}) await start_handler(query.message) await query.message.delete_reply_markup() else: logger.warning(f'Got invalid command {query.data}') await query.answer()
async def remove_markers_dict(cls, c: CallbackQuery): user_db = ForwardsToTextUser(c.from_user.id) user_db.delete_dictionary(int(c.data.split()[-1])) c.data = 'fwd_to_text settings dicts' await cls.edit_dicts_settings(c=c)
async def product_show(callback: types.CallbackQuery, state: FSMContext): data = await state.get_data() if data == {}: await callback.message.edit_text('Что вы ищете?', reply_markup=clothes_kb.type_object) await callback.answer() await state.reset_data() return notification = False # уведомление о единственном товаре при листании товаров now_state = await state.get_state() if not data['number']: # номер товара в списке пользователя number = 0 else: number = data['number'] if callback.data == 'next_product': number += 1 notification = True callback.data = data['product'] elif callback.data == 'previous_product': number -= 1 notification = True callback.data = data['product'] if ('States:set_category', 'States:sales2cat_add', 'States:sales2cat_end').count(now_state): logging.info(f"{data['type']}, {data['sex']}, {callback.data}") await callback.message.edit_text(f"Тип: {category[data['type']]} " f"\nПол: {category[data['sex']]} " f"\nКатегория: {category[callback.data]}", reply_markup=accept_kb) await state.update_data(product=callback.data) await callback.answer() # logging.info(f'Получение продукта до запроса в бд - {time()-t}') return # logging.info(f'Получение продукта до запроса в бд - {time()-t}') t = time() try: res = await get_product(data['sex'], callback.data, number) except KeyError: await callback.message.edit_text('Что вы ищете?', reply_markup=clothes_kb.type_object) await callback.answer() await state.reset_data() return logging.info(f'Запрос в бд {time() - t}') if res is False: await callback.answer(text='Этого товара еще нет :( ', cache_time=1) # logging.info(f'Получение продукта после запроса - {time()-t}') return elif res[0][9] == -1: number = 0 elif res[0][9] >= 0: number = res[0][8] elif res[0][9] == -2 and notification is True: await callback.answer(text='Других товаров нет', cache_time=1) # logging.info(f'Получение продукта после запроса - {time()-t}') return kb = product_kb if now_state == 'States:edit_product': kb = edit_product_inline elif now_state == 'States:delete_product': kb = delete_product_inline # logging.info(f'Получение продукта после запроса - {time()-t}') await callback.message.edit_text(res[0][4] + str(res[0][2]) + res[0][1], parse_mode='HTML', reply_markup=kb) await state.update_data(product=callback.data, number=number) await callback.answer()
async def on_process_callback_query(self, callback_query: types.CallbackQuery, data: dict): callback_query.db = self.db