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
