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'))
class KokkoroTelegramBot(KokkoroBot):
def __init__(self, config):
self.config = config
super().kkr_load_modules(self.config) # KokkoroBot init
self.bot = Bot(config.bot.telegram.TELEGRAM_TOKEN)
self.dp = Dispatcher(self.bot)
async def tg_msg_handler(raw_event: types.Message):
await self.kkr_on_message(raw_event)
self.dp.register_message_handler(tg_msg_handler)
@overrides(KokkoroBot)
def kkr_event_adaptor(self, raw_event: types.Message) -> EventInterface:
return TelegramEvent(raw_event)
@overrides(KokkoroBot)
async def kkr_send(self,
ev: TelegramEvent,
msg: SupportedMessageType,
at_sender=False,
filename="image.png"):
if isinstance(msg, str):
await ev.get_raw_event().answer(msg)
else:
raise NotImplementedError
@overrides(KokkoroBot)
def kkr_run(self):
executor.start_polling(self.dp, skip_updates=True)
class TelegramBot(Bot):
def _init_bot(self):
self._bot = TelegramBotClient(token=TELEGRAM_API_TOKEN)
self._dp = Dispatcher(self._bot)
self.actions = {action.command: action() for action in all_actions}
self.commands_list = [f"/{action.command} {action.params} - {action.description}" for action in all_actions]
self._dp.register_message_handler(self._handle_update)
async def _handle_update(self, message: types.Message):
command = message.get_command(pure=True)
if command and command in self.actions.keys():
action = self.actions.get(command)
args = message.get_args().strip().split()
# set params in cache
[USER_COMMANDS_CACHE[f'command:{message.chat["id"]}'].add(arg) for arg in args]
flag, response = action.execute(USER_COMMANDS_CACHE[f'command:{message.chat["id"]}'])
# flush cache if success
if flag:
del USER_COMMANDS_CACHE[f'command:{message.chat["id"]}']
await message.answer(response)
else:
await message.answer("Hi! available commands are:\n\n" + "\n".join(self.commands_list))
def run(self):
executor.start_polling(self._dp, skip_updates=True)
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_base(dp: Dispatcher):
dp.register_message_handler(cmd_start, commands="start", state="*")
dp.register_message_handler(
input_suggesting_msg,
content_types=ContentType.ANY,
state=UserStates.Input_suggesting_msg,
)
def get_seats_number(dp: Dispatcher):
async def _get_seats_number(message: types.Message, state: FSMContext):
logger.info('User %s has set seats: %s', message.from_user.username,
message.text)
async with state.proxy() as data:
seats = message.text.split(',')
data['seats'] = seats
logger.info('Current state: %s', data)
markup = types.ReplyKeyboardMarkup(resize_keyboard=True,
selective=True)
markup.add("OK", "CANCEL")
await TicketOrderState.next()
msg = md.text(md.text('Всё правильно?'),
md.text(md.italic('Станция отправления: '),
md.code(data['from_station'])),
md.text(md.italic('Станция прибытия: '),
md.code(data['to_station'])),
md.text(md.italic('Дата отправления: '),
md.code(data['date'])),
md.text(md.italic('Номер вагона: '),
md.code(data['wagon_number'])),
md.text(md.italic('Бронируемые места: '),
md.code(','.join(data['seats']))),
sep='\n')
await message.reply(msg,
reply_markup=markup,
parse_mode=types.ParseMode.MARKDOWN)
dp.register_message_handler(_get_seats_number,
state=TicketOrderState.seats)
async def register_handlers(dp: Dispatcher):
"""Registration all handlers before processing update."""
dp.register_message_handler(start, commands=['start'])
dp.register_message_handler(echo)
log.debug('Handlers are registered.')
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 get_bot() -> Tuple[Bot, Dispatcher]:
bot = Bot(token=config.telegram_token)
dp = Dispatcher(bot)
dp.register_message_handler(process_messages,
content_types=[ContentType.DOCUMENT])
return bot, dp
async def main():
bot = Bot(token=TOKEN)
try:
disp = Dispatcher(bot=bot)
disp.register_message_handler(start_handler, commands={"cat", "dog"})
await disp.start_polling()
finally:
await bot.close()
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 get_final_confirmation(dp: Dispatcher):
def _filter_ok_response(message: types.Message):
return message.text == 'OK'
def _filter_cancel_response(message: types.Message):
return message.text == 'CANCEL'
async def _cancel_order_from_confirmation(message: types.Message,
state: FSMContext):
current_state = await state.get_state()
if current_state is None:
return
await state.finish()
await message.reply('Бронирование отменено. Заходьте ще.',
reply_markup=types.ReplyKeyboardRemove())
async def _get_final_confirmation(message: types.Message,
state: FSMContext):
async with state.proxy() as data:
ticket_order = TrainOrder(
from_station_id=data['from_station'],
to_station_id=data['to_station'],
train_code=data['train_code'],
date=data['date'],
wagon_number=data['wagon_number'],
wagon_class='Б',
wagon_type=data['wagon_type'],
wagon_railway=35,
)
for seat in data['seats']:
ticket_order.add_seat(seat)
job_id = make_ticket_order_job_id(message.from_user.username,
ticket_order.from_station_id,
ticket_order.to_station_id,
ticket_order.date)
logger.info('Creating periodic job with id: %s', job_id)
client_id = f'{message.from_user.username}-{message.from_user.id}'
train_service = TrainService(client_id)
scheduler.add_job(
poll_ticket_service_task,
'interval',
args=(message, ticket_order, train_service),
seconds=(POLL_PERIOD * 60) + POLL_ADDITIONAL_SECS,
next_run_time=datetime.now() + timedelta(seconds=3),
id=job_id)
await message.reply(
f'OK! Стартую бронирование. Идентификатор бронирования: {md.italic(job_id)}',
reply_markup=types.ReplyKeyboardRemove(),
parse_mode=types.ParseMode.MARKDOWN)
await state.finish()
dp.register_message_handler(_get_final_confirmation,
_filter_ok_response,
state=TicketOrderState.is_ok)
dp.register_message_handler(_cancel_order_from_confirmation,
_filter_cancel_response,
state=TicketOrderState.is_ok)
def register_adminmode_handlers(dp: Dispatcher, admin_chat_id: int):
dp.register_message_handler(reply_to_user,
IsReplyFilter(is_reply=True),
IDFilter(chat_id=admin_chat_id),
content_types=types.ContentTypes.ANY)
dp.register_message_handler(has_no_reply,
IsReplyFilter(is_reply=False),
IDFilter(chat_id=admin_chat_id),
content_types=types.ContentTypes.ANY)
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 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 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_usermode_handlers(dp: Dispatcher):
dp.register_message_handler(cmd_start_user, commands="start")
dp.register_message_handler(cmd_help_user, commands="help")
dp.register_message_handler(text_message, content_types=ContentType.TEXT)
dp.register_message_handler(supported_media, content_types=[
ContentType.ANIMATION, ContentType.AUDIO, ContentType.PHOTO,
ContentType.DOCUMENT, ContentType.VIDEO, ContentType.VOICE
])
dp.register_message_handler(unsupported_types, content_types=ContentType.ANY)
async def start_telegram_bot(bot: Bot, handlers: Handlers):
print('start server')
try:
disp = Dispatcher(bot=bot)
disp.register_message_handler(handlers.start_handler,
commands={"start", "restart"})
await disp.start_polling()
finally:
await bot.close()
async def main(bot_token: str):
bot = Bot(token=bot_token)
try:
disp = Dispatcher(bot=bot)
disp.register_message_handler(re_start_handler, commands={"start", "restart"})
# disp.register_message_handler(re_start_handler, content_types=)
await disp.start_polling()
finally:
await bot.close()
def register_handlers_fsm(dp: Dispatcher):
# text state
dp.register_message_handler(process_text,state=Form.text)
# Geo state
dp.register_message_handler(process_geo_text_check,Text(equals="Вести вручную", ignore_case=False), state=Form.geo)
dp.register_message_handler(process_geo_text, state=Form.geo,content_types=ContentType.TEXT)
dp.register_message_handler(process_geo_link, state=Form.geo,content_types=ContentType.LOCATION)
# Photo get date
dp.register_message_handler(process_photo,state=Form.photo, content_types=ContentType.PHOTO)
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='*')
async def main():
logging.basicConfig(level=logging.INFO)
storage = MemoryStorage()
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot, storage=storage)
dialog = InpuDialog()
dialog.register_handler(dp)
dp.register_message_handler(dialog.start)
await dp.start_polling()
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 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 register_adminmode_handlers(dp: Dispatcher, admin_chat_id: int):
dp.register_message_handler(unsupported_reply_types, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id),
content_types=types.ContentTypes.POLL)
dp.register_message_handler(get_user_info, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id),
commands=["get", "who"])
dp.register_message_handler(admin_help, IDFilter(chat_id=admin_chat_id), commands="help")
dp.register_message_handler(reply_to_user, IsReplyFilter(is_reply=True), IDFilter(chat_id=admin_chat_id),
content_types=types.ContentTypes.ANY)
dp.register_message_handler(has_no_reply, IsReplyFilter(is_reply=False), IDFilter(chat_id=admin_chat_id),
content_types=types.ContentTypes.ANY)
async def main():
bot = Bot(token='BOT TOKEN HERE')
dp = Dispatcher(bot=bot)
dp.register_message_handler(message_handler,
content_types=types.ContentTypes.ANY)
try:
await dp.start_polling()
finally:
await bot.session.close()
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 register_handlers_register(dp: Dispatcher) -> None:
dp.register_message_handler(register_start, commands='register', state='*')
dp.register_message_handler(register_start,
Text(equals='регистрация', ignore_case=True),
state='*')
dp.register_message_handler(register_nickname,
state=OrderRegister.waiting_for_nickname)
dp.register_message_handler(register_password,
state=OrderRegister.waiting_for_password)
dp.register_message_handler(register_password_again,
state=OrderRegister.waiting_for_password_again)
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)
async def main():
# real main
logging.basicConfig(level=logging.INFO)
storage = MemoryStorage()
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot, storage=storage)
registry = DialogRegistry(dp)
registry.register(dialog)
dp.register_message_handler(start, text="/start", state="*")
await dp.start_polling()
