def register_handlers_share(dp: Dispatcher):
""" Регистрация message handler для бота """
dp.register_callback_query_handler(
page_callback,
lambda call: call.data.split('#')[0] == 'character',
state="*")
def setup(dp: Dispatcher):
# Команды
dp.register_message_handler(start_from_command, commands=['start'])
dp.register_callback_query_handler(
start_from_callback,
lambda c: c.data and c.data.startswith('main_menu'))
def setup(dp: Dispatcher, loop: AbstractEventLoop = None, *args, **kwargs):
logging.info('Initialize default module')
loop.create_task(
forever_run(
function=check_connection,
interval=CONNECTION_CHECKER_INTERVAL,
))
dp.register_message_handler(cmd_start, Command('start'), state='*')
dp.register_message_handler(cmd_help, Command('help'), state='*')
dp.register_message_handler(cmd_cancel, Command('cancel'), state='*')
dp.register_message_handler(
cmd_start,
lambda message:
[user for user in message.new_chat_members if bot_id == user.id],
content_types=ContentType.NEW_CHAT_MEMBERS,
)
dp.register_message_handler(
cmd_start,
content_types=ContentType.GROUP_CHAT_CREATED,
)
dp.register_callback_query_handler(
answer_callback_empty_button_handler,
lambda query: query.data == 'None',
)
def register_callbacks(cls, dispatcher: Dispatcher = None):
dispatcher = dispatcher or cls.dispatcher
if dispatcher is None:
raise Exception("dispatcher not set")
for i in vars(cls):
data: Union[Button, Input] = getattr(cls, i)
if isinstance(data, Button) and not data.registered:
if cls.default_save:
if data.is_inline():
dispatcher.register_callback_query_handler(
callback=(cls.default_callback_save if data.on_click is None else data.on_click),
text=data.kwargs.get("callback_data"),
state=cls.state
)
else:
dispatcher.register_message_handler(
callback=(cls.default_text_save if data.on_click is None else data.on_click),
text=data.text,
state=cls.state
)
elif isinstance(data, Input) and not data.registered:
dispatcher.register_message_handler(
(cls.default_text_save if data.on_enter is None else data.on_enter),
*data.args,
state=cls.state,
**data.kwargs
)
if data.on_wrong is not None:
dispatcher.register_message_handler(
callback=data.on_wrong,
state=cls.state
)
def feedback_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(
new_feedback,
conv_cb.filter(action="new"),
state="*",
)
dp.register_callback_query_handler(
reply_to_conversation,
conv_cb.filter(action="reply"),
state="*",
)
dp.register_callback_query_handler(
conversation_pages,
conv_cb.filter(action="page"),
state="*",
)
dp.register_callback_query_handler(
conversation_open,
conv_cb.filter(action="open"),
state="*",
)
dp.register_callback_query_handler(
flow_page,
flow_cb.filter(action="page"),
state="*",
)
def setup(dp: Dispatcher):
"""Commands handlers"""
dp.register_message_handler(start_cmd, commands=['start'])
dp.register_message_handler(login_test, commands=['login'])
"""Callback handlers"""
main_menu = MainMenu()
dp.register_callback_query_handler(
main_menu_callback,
lambda callback_query: main_menu.callback_data.filter(action=main_menu.
actions),
state=MainForm.myself)
english_word_menu = EnglishWordMenu()
dp.register_callback_query_handler(
english_menu_callback,
lambda callback_query: english_word_menu.callback_data.filter(
action=english_word_menu.actions),
state=[MainForm.english, EnglishForm, EnglishWordMenuEnterRussianWord])
"""Message handlers"""
dp.register_message_handler(write_english_word_message_handler,
state=EnglishForm.write_english)
dp.register_message_handler(write_russian_word_message_handler,
state=EnglishForm.write_russian)
"""Error handlers"""
@dp.errors_handler(exception=MessageNotModified
) # handle the cases when this exception raises
async def message_not_modified_handler(update, error):
return True # errors_handler must return True if error was handled correctly
def setup(dp: Dispatcher) -> None:
# Register `auth` handlers
dp.register_message_handler(set_code, commands=["set_code"])
dp.register_message_handler(my_code, commands=["my_code"])
dp.register_message_handler(reset_code, commands=["reset_code"])
# Register `absence` handlers
dp.register_message_handler(
menu_handler,
lambda message: message.text and message.text == 'Главное меню',
)
dp.register_message_handler(
get_student,
lambda message: message.text and message.text == 'Расход',
state='*',
)
dp.register_callback_query_handler(
callback_query_process,
lambda callback: True,
state='*',
)
dp.register_message_handler(
send_absence,
lambda message: message.text and message.text == 'Отправить данные',
state='*',
)
def setup(dp: Dispatcher, *args, **kwargs):
logging.info('Initialize surveys module')
# getting survey
dp.register_message_handler(cmd_start, Command('start'), state='*')
# registration
dp.register_message_handler(cmd_register, Command('register'), state='*')
dp.register_message_handler(process_email, state=RegistrationStates.wait_for_email)
dp.register_message_handler(process_code, state=RegistrationStates.wait_for_code)
# unregister
dp.register_message_handler(cmd_unregister, Command('unregister'), state='*')
# info
dp.register_message_handler(cmd_info, Command('info'), state='*')
# answer handler
dp.register_callback_query_handler(
callback_answer_handler,
lambda query: query.data.startswith('answer'),
state='*',
)
# submit handler
dp.register_callback_query_handler(
callback_survey_handler,
lambda query: query.data.startswith('survey'),
)
# plain text for 3rd type of question
dp.register_message_handler(
process_plain_text,
state=QuestionsStates.wait_for_plain_text,
)
def register(dp: Dispatcher, config: typing.Dict[typing.Any,
typing.Any]) -> bool:
dp.register_message_handler(I18nHandlers.cmd_i18n_choose)
dp.register_callback_query_handler(I18nHandlers.query_change_language,
i18n_cb.filter(type='lang_choice'))
return True
def lang_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(lang_list_callback_handler,
lang_cb.filter(id="_"),
state="*")
dp.register_callback_query_handler(lang_callback_handler,
lang_cb.filter(),
state="*")
def register_handlers(dp: Dispatcher):
dp.register_message_handler(entry_point, state=GlobalStates.add_tasks_btn)
dp.register_message_handler(enter_group_id,
state=AddTasksStates.enter_group_id)
dp.register_callback_query_handler(
check_for_admin,
markups.add_tasks_factory.filter(data="0"),
state=AddTasksStates.check_for_admin)
def worker_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(worker_callback_handler,
worker_cb.filter(type=SELECT_COIN_CB),
state="*")
dp.register_callback_query_handler(worker_info_callback_handler,
worker_cb.filter(),
state="*")
def register(self, registry: DialogRegistryProto, dp: Dispatcher, *args,
**filters) -> None:
if "state" not in filters:
filters["state"] = "*"
dp.register_callback_query_handler(self._callback_handler, *args,
**filters)
if "content_types" not in filters:
filters["content_types"] = ContentTypes.ANY
dp.register_message_handler(self._message_handler, *args, **filters)
def blacklist_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(black_list_callback_handler,
worker_black_cb.filter(
type=SELECT_COIN_CB, ),
state="*")
dp.register_callback_query_handler(black_list_info_callback_handler,
worker_black_cb.filter(),
state="*")
def notification_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(notificaion_enable_callback_handler,
notification_cb.filter(),
state="*")
dp.register_callback_query_handler(
notificaion_payout_enable_callback_handler,
notification_payout_cb.filter(),
state="*")
def setup(dp: Dispatcher, loop: AbstractEventLoop=None, *args, **kwargs):
logging.info('Initialize default module')
dp.register_message_handler(cmd_help, Command('help'), state='*')
dp.register_message_handler(cmd_cancel, Command('cancel'), state='*')
dp.register_callback_query_handler(
answer_callback_empty_button_handler,
lambda query: query.data == 'None'
)
def register_handlers(dp: Dispatcher):
dp.register_message_handler(info_handler, commands='info')
dp.register_message_handler(contacts_handler, commands='contacts')
dp.register_message_handler(cancel_handler, state='*', commands='cancel')
dp.register_message_handler(cancel_handler, Text(equals='отмена', ignore_case=True), state='*')
dp.register_callback_query_handler(cancel_callback_handler, lambda callback_query: callback_query.data == "cancel",
state='*')
def register_handlers_location(dp: Dispatcher):
dp.register_message_handler(location_start,
Text(startswith='🌍'),
state='*')
dp.register_message_handler(location_search,
state=SetLocation.waiting_loc_name)
dp.register_callback_query_handler(location_confirm,
Text(endswith='city'),
state=SetLocation.confirm_loc_name)
def register(dp: Dispatcher, config: typing.Dict[typing.Any, typing.Any]) -> bool:
dp.register_message_handler(BroadcastHandlers.cmd_calendar, commands=['calendar'])
dp.register_callback_query_handler(
BroadcastHandlers.query_change_calendar, calendar_cb.filter(action='change'))
dp.register_callback_query_handler(
BroadcastHandlers.query_day, calendar_cb.filter(action='select_day'))
return True
def change_coins_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(
change_coins_for_account_callback_handler,
menu_cb.filter(type="account", action="c_coins"),
state="*")
dp.register_callback_query_handler(
change_coin_enabled_setting_coins_for_account,
coin_account_cb.filter(action=['on', 'off']),
state="*")
def setup(dp: Dispatcher):
dp.register_message_handler(from_command, commands=['swatermark'])
dp.register_callback_query_handler(
from_callback,
lambda c: c.data and c.data.startswith('watermark_from_settings'))
dp.register_message_handler(process,
state=SWatermarkState.sget_pic,
content_types=ContentTypes.PHOTO)
def faq_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(
faq_callback_handler,
question_answer_cb.filter(action='page'),
state="*")
dp.register_callback_query_handler(
faq_info_callback_handler,
question_answer_cb.filter(action='open'),
state="*")
def delete_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(
delete_account_callback_handler,
delete_account_cb.filter(action="choose"),
state="*")
dp.register_callback_query_handler(
delete_account_confirmation_callback_handler,
delete_account_cb.filter(action="yes"),
state="*")
def register_handler(self, dp: Dispatcher, *args, **kwargs):
dp.register_message_handler(self.handle_message,
state=self.states,
content_types=ContentTypes.ANY,
*args,
**kwargs)
dp.register_callback_query_handler(self.handle_callback,
state=self.states,
*args,
**kwargs)
def setup(dp: Dispatcher):
dp.register_message_handler(bot_start, CommandStart(), state='*')
chat.setup(dp)
inline_commands.setup(dp)
dp.register_callback_query_handler(
card_buttons_handler,
lambda callback: callback.data.split("::")[0] == "card",
state='*')
def register_handlers_bonds(dp: Dispatcher):
"""
Регистрация хэндлеров \n
See example: https://mastergroosha.github.io/telegram-tutorial-2/fsm/
:param dp: Dispatcher
:return: None
"""
dp.register_message_handler(bonds_introduce, commands="bonds", state="*")
dp.register_callback_query_handler(bonds_next_item,
state=GetBondsStates.next_item_step)
def currency_menu_group(dp: Dispatcher):
dp.register_callback_query_handler(currency_callback_handler,
currency_cb.filter(
action="open",
id="_",
),
state="*")
dp.register_callback_query_handler(currency_update_callback_handler,
currency_cb.filter(),
state="*")
def setup(dp: Dispatcher, *args, **kwargs):
logging.info('Initialize buylist module')
dp.register_message_handler(cmd_list, Command('list'))
dp.register_message_handler(cmd_add, Command('add'))
dp.register_message_handler(add_to_list, state=AddFSM.waiting_for_add)
dp.register_callback_query_handler(
answer_callback_list_handler, lambda query: query.data.startswith(
constants.INLINE_PREFIX_CHANGE_MENU))
dp.register_callback_query_handler(
answer_empty_list, lambda query: query.data.startswith(
constants.INLINE_PREFIX_EMPTY_LIST))
def register(self, dp: Dispatcher):
dp.register_callback_query_handler(
self.join,
lambda c: c.data and c.data == self.name
)
dp.register_message_handler(
self.handle,
state=self.state_obj.input_state,
content_types=ContentTypes.TEXT
)
def setup_tg_handlers(dp: Dispatcher):
dp.register_message_handler(start_cmd, commands=['start'])
dp.register_message_handler(help_cmd, commands=['help'])
dp.register_message_handler(current_cmd, commands=['current'])
dp.register_message_handler(vk_convs, commands=['convs'])
dp.register_message_handler(vk_chats, commands=['chats'])
dp.register_message_handler(chat_register, commands=['regchat'])
dp.register_message_handler(conv_register, commands=['regconv'])
dp.register_message_handler(
anything, content_types=['photo', 'document', 'animation', 'text'])
dp.register_callback_query_handler(callback_handler,
lambda chosen_inline_query: True)
