def test_basic(self, dp, poll):
handler = PollHandler(self.callback_basic)
dp.add_handler(handler)
assert handler.check_update(poll)
dp.process_update(poll)
assert self.test_flag
def test_slot_behaviour(self, recwarn, mro_slots):
inst = PollHandler(self.callback_basic)
for attr in inst.__slots__:
assert getattr(inst, attr, 'err') != 'err', f"got extra slot '{attr}'"
assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot"
inst.custom, inst.callback = 'should give warning', self.callback_basic
assert len(recwarn) == 1 and 'custom' in str(recwarn[0].message), recwarn.list
def test_slot_behaviour(self, mro_slots):
inst = PollHandler(self.callback)
for attr in inst.__slots__:
assert getattr(inst, attr,
"err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(inst)) == len(set(
mro_slots(inst))), "duplicate slot"
def initialize_bot(self, is_env):
updater = Updater(token=self.TOKEN, use_context=True)
dispatcher = updater.dispatcher
self.foo = dispatcher
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=logging.INFO,
)
start_handler = CommandHandler("start", self.start)
dispatcher.add_handler(start_handler)
askdelete_handler = MessageHandler(
Filters.regex("^@" + updater.bot.username + "$"), self.askdelete)
askdelete_ban_handler = MessageHandler(
Filters.regex("^@" + updater.bot.username + " ban$"),
self.askdelete_ban)
set_handler = CommandHandler("settings", self.set_cmd)
dispatcher.add_handler(askdelete_handler)
dispatcher.add_handler(askdelete_ban_handler)
dispatcher.add_handler(PollAnswerHandler(self.receive_poll_answer))
dispatcher.add_handler(PollHandler(self.delete))
dispatcher.add_handler(set_handler)
dispatcher.add_handler(CallbackQueryHandler(self.query_func))
if is_env:
updater.start_webhook(
listen="0.0.0.0",
# (c) https://t.me/c/1186975633/22915
port=self.config.port,
url_path=self.config.bot_api,
)
updater.bot.set_webhook(url=self.config.url + self.config.bot_api)
else:
updater.start_polling()
async def test_context(self, app, poll):
handler = PollHandler(self.callback)
app.add_handler(handler)
async with app:
await app.process_update(poll)
assert self.test_flag
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater(TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
# Start the Bot
#updater.start_polling()
#added to deploy to heroku
updater.start_webhook(listen="0.0.0.0",
port=int(PORT),
url_path=TOKEN,
webhook_url='https://cawpawbot.herokuapp.com/' +
TOKEN)
#updater.bot.setWebhook(webhook_url='https://cawpawbot.herokuapp.com/'+TOKEN)
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main(updater: Updater):
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
def prepare():
create_database()
apply_migrations()
updater = Updater(TOKEN, request_kwargs=REQUEST_KWARGS, use_context=True)
j = updater.job_queue
set_timer(j)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# set data
dp.bot_data["activities"] = activities
dp.bot_data["cards_buffer"] = cards_buffer
dp.bot_data["cards_buffer_data"] = cards_buffer_data
dp.bot_data["logger"] = logger
add_flash_cards(dp)
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("delete", delete_flash_card_request))
dp.add_handler(CommandHandler("quiz", quiz))
dp.add_handler(PollHandler(receive_quiz_answer))
dp.add_handler(MessageHandler(Filters.poll, receive_poll))
dp.add_handler(MessageHandler(Filters.text, choose_flash_card, pass_user_data=True))
dp.add_handler(
CallbackQueryHandler(
get_reply_meaning, pattern=r"^ADD__.*$", pass_chat_data=True
)
)
dp.add_handler(
CallbackQueryHandler(
start_setting_custom_meaning, pattern=OTHER, pass_chat_data=True
)
)
dp.add_handler(
CallbackQueryHandler(
delete_flash_card_chosen, pattern=r"^DELETE__.*$", pass_chat_data=True
)
)
# log all errors
dp.add_error_handler(error)
return updater
def test_pass_job_or_update_queue(self, dp, poll):
handler = PollHandler(self.callback_queue_1, pass_job_queue=True)
dp.add_handler(handler)
dp.process_update(poll)
assert self.test_flag
dp.remove_handler(handler)
handler = PollHandler(self.callback_queue_1, pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll)
assert self.test_flag
dp.remove_handler(handler)
handler = PollHandler(self.callback_queue_2, pass_job_queue=True, pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll)
assert self.test_flag
def test_pass_user_or_chat_data(self, dp, poll):
handler = PollHandler(self.callback_data_1, pass_user_data=True)
dp.add_handler(handler)
dp.process_update(poll)
assert self.test_flag
dp.remove_handler(handler)
handler = PollHandler(self.callback_data_1, pass_chat_data=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll)
assert self.test_flag
dp.remove_handler(handler)
handler = PollHandler(self.callback_data_2, pass_chat_data=True, pass_user_data=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll)
assert self.test_flag
def main() -> None:
# load environment variables
# config = dotenv_values(".env")
load_dotenv()
updater = Updater(token=os.environ["TRANSCRIBEBOT_TELEGRAM_TOKEN"], use_context=True)
dispatcher: Dispatcher = updater.dispatcher
# add handlers
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(MessageHandler(ZockenFilter(), make_poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
# start polling
updater.start_polling()
def main() -> None:
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(__TOKEN__, use_context=True)
job = updater.job_queue
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('cook', cook))
dispatcher.add_handler(CommandHandler('bd', bd))
dispatcher.add_handler(MessageHandler(Filters.text, kovra))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
dispatcher.add_handler(CommandHandler("set", set_timer))
dispatcher.add_handler(CommandHandler("unset", unset))
dispatcher.add_handler(CommandHandler("news", news))
dispatcher.add_handler(CommandHandler('coinflip', coinflip,
pass_args=True))
dispatcher.add_handler(
CommandHandler('random', random_number, pass_args=True))
target_time = datetime.time(hour=8, minute=0)
news_time = datetime.time(hour=6, minute=12)
joke_time = datetime.time(hour=6, minute=0)
picture_time = datetime.time(hour=6, minute=6)
horoscope_time = datetime.time(hour=5, minute=55)
job.run_daily(daily_job, target_time, days=range(7))
job.run_daily(daily_news, news_time, days=range(7))
job.run_daily(daily_joke, joke_time, days=range(7))
job.run_daily(daily_pciture, picture_time, days=range(7))
job.run_daily(daily_horoscope, horoscope_time, days=range(7))
# on noncommand i.e message - echo the message on Telegram
#dispatcher.add_handler(MessageHandler(Filters.text, echo))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main():
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
TOKEN = Config.get_config()["keys"]["telegramkey"]
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("quiz", quiz))
dp.add_handler(PollHandler(receive_quiz_answer))
dp.add_handler(MessageHandler(Filters.poll, receive_poll))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater("1733062635:AAEfN_XL5R5x7ZOfBaQjw_Wu0eGLcejHS-o")
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main():
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', start))
dp.add_handler(CommandHandler('poll', poll))
dp.add_handler(PollAnswerHandler(receive_poll_answer))
dp.add_handler(CommandHandler('quiz', quiz))
dp.add_handler(PollHandler(receive_quiz_answer))
dp.add_handler(CommandHandler('preview', preview))
dp.add_handler(MessageHandler(Filters.poll, receive_poll))
dp.add_handler(CommandHandler('help', help_handler))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main():
updater = Updater(DefaultConfig.TELEGRAM_TOKEN, use_context=True)
dp = updater.dispatcher
# command handlers
dp.add_handler(CommandHandler("help", help_command_handler))
dp.add_handler(CommandHandler("start", start_command_handler))
# message handler
dp.add_handler(MessageHandler(Filters.text, main_handler))
# suggested_actions_handler
dp.add_handler(
CallbackQueryHandler(main_handler,
pass_chat_data=True,
pass_user_data=True))
# quiz answer handler
dp.add_handler(
PollHandler(poll_handler, pass_chat_data=True, pass_user_data=True))
# log all errors
dp.add_error_handler(error)
# Start the Bot
if DefaultConfig.MODE == 'webhook':
updater.start_webhook(listen="0.0.0.0",
port=int(DefaultConfig.PORT),
url_path=DefaultConfig.TELEGRAM_TOKEN)
updater.bot.setWebhook(DefaultConfig.WEBHOOK_URL +
DefaultConfig.TELEGRAM_TOKEN)
logging.info(f"Start webhook mode on port {DefaultConfig.PORT}")
else:
updater.start_polling()
logging.info(f"Start polling mode")
updater.idle()
def main():
logger.info("creating updater")
updater = Updater(os.environ['TEL_BOT_TOKEN'], use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', cmd.start.start))
dp.add_handler(CommandHandler('quiz', cmd.quiz.quiz))
dp.add_handler(CommandHandler('q', cmd.quiz.quiz))
dp.add_handler(
CommandHandler(
'quiz3',
lambda update, context: cmd.quiz.quiz(update, context, 3)))
dp.add_handler(
CommandHandler(
'q3', lambda update, context: cmd.quiz.quiz(update, context, 3)))
dp.add_handler(
CommandHandler(
'quiz4',
lambda update, context: cmd.quiz.quiz(update, context, 4)))
dp.add_handler(
CommandHandler(
'q4', lambda update, context: cmd.quiz.quiz(update, context, 4)))
dp.add_handler(PollHandler(cmd.quiz.receive_quiz_answer))
dp.add_handler(CommandHandler('help', cmd.help.help_handler))
dp.add_handler(CommandHandler('h', cmd.help.help_handler))
dp.add_handler(CommandHandler('short', cmd.help.short_handler))
dp.add_handler(CommandHandler('credits', cmd.help.credits_handler))
dp.add_handler(CommandHandler('qr', cmd.help.qr_handler))
dp.add_handler(CommandHandler('sources', cmd.sources.sources_handler))
dp.add_handler(CommandHandler('userinfo', cmd.userinfo.userinfo_handler))
logger.info("starting to poll")
updater.start_polling()
updater.idle()
def main():
"""Instanciate a Defaults object"""
# Create the EventHandler and pass it your bot's token.
q = mq.MessageQueue(all_burst_limit=29,
all_time_limit_ms=1017,
group_burst_limit=15,
group_time_limit_ms=55000,
autostart=True)
# set connection pool size for bot
request = Request(con_pool_size=12)
testbot = MQBot(configs.TOKEN, request=request, mqueue=q)
pp = PicklePersistence(filename='rabot', store_bot_data=True)
updater = telegram.ext.updater.Updater(bot=testbot,
persistence=pp,
use_context=True)
# Get the dispatcher to register handlers CallbackQueryHandler(language)
dp = updater.dispatcher
dp.add_handler(MessageHandler(Filters.regex('^TOP$'), botify.top))
dp.add_handler(
MessageHandler(Filters.regex('^PROGRESS$'), botify.check_progress))
dp.add_handler(MessageHandler(Filters.regex('^HELP$'), botify.help))
dp.add_handler(MessageHandler(Filters.regex('^MY RA$'), botify.myra))
dp.add_handler(MessageHandler(Filters.regex('^PROFILE$'), botify.profile))
dp.add_handler(CommandHandler(command='start', callback=botify.start))
dp.add_handler(CommandHandler(command='help', callback=botify.help))
dp.add_handler(CommandHandler(command='top', callback=botify.top))
dp.add_handler(CommandHandler(command='gid', callback=botify.gid))
dp.add_handler(CommandHandler(command='solo', callback=botify.solo_learn))
dp.add_handler(
CommandHandler(command='progress', callback=botify.check_progress))
dp.add_handler(
CommandHandler(command='studyrooms', callback=botify.studyrooms))
dp.add_handler(CommandHandler(command='teachers',
callback=botify.teachers))
dp.add_handler(
CommandHandler(command='classrooms', callback=botify.classrooms))
dp.add_handler(CommandHandler(command='rector', callback=botify.rector))
dp.add_handler(CommandHandler(command='settopic',
callback=botify.settopic))
dp.add_handler(
CommandHandler(command='support', callback=botify.ask_donation))
dp.add_handler(CommandHandler(command='topic', callback=botify.topic))
dp.add_handler(
CommandHandler(command='stop', callback=botify.session_manager))
dp.add_handler(
MessageHandler(Filters.command & Filters.reply & Filters.group,
botify.bonus))
dp.add_handler(
MessageHandler(Filters.reply & (Filters.text | Filters.voice),
botify.reply_check))
dp.add_handler(
MessageHandler(Filters.status_update.new_chat_members,
botify.unauth_group))
dp.add_handler(MessageHandler(Filters.text, botify.message_counter))
dp.add_handler(MessageHandler(Filters.dice, botify.solo_learn))
dp.add_handler(CallbackQueryHandler(botify.javis))
dp.add_handler(PollHandler(botify.poll_private))
dp.add_handler(PollAnswerHandler(botify.poll_listener))
# log all errors
# dp.add_error_handler(botify.error)
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def quiz_response():
return PollHandler(
receive_quiz_answer,
pass_chat_data=True,
pass_user_data=True
)
def __init__(self):
PollHandler.__init__(self, callback=self.callback)
def main():
logger.info("creating updater")
updater = Updater(os.environ['TEL_BOT_TOKEN'], use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', cmd.start.start))
dp.add_handler(CommandHandler('quiz', cmd.quiz.quiz))
dp.add_handler(CommandHandler('q', cmd.quiz.quiz))
dp.add_handler(
CommandHandler(
['quiz2', 'q2'],
lambda update, context: cmd.quiz.quiz(update, context, 2)))
dp.add_handler(
CommandHandler(
['quiz3', 'q3'],
lambda update, context: cmd.quiz.quiz(update, context, 3)))
dp.add_handler(
CommandHandler(
['quiz4', 'q4'],
lambda update, context: cmd.quiz.quiz(update, context, 4)))
dp.add_handler(PollHandler(cmd.quiz.receive_quiz_answer))
dp.add_handler(CommandHandler(['help', 'h'], cmd.help.help_handler))
dp.add_handler(CommandHandler('short', cmd.help.short_handler))
dp.add_handler(CommandHandler('credits', cmd.help.credits_handler))
dp.add_handler(CommandHandler('qr', cmd.download.qr_handler))
dp.add_handler(CommandHandler('wc', cmd.download.wc_handler))
dp.add_handler(CommandHandler('wcm', cmd.download.wc_movie_handler))
dp.add_handler(CommandHandler('wca', cmd.download.wc_anim_handler))
dp.add_handler(
CommandHandler(
'wch', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True)))
dp.add_handler(
CommandHandler(
'wch5', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=5)))
dp.add_handler(
CommandHandler(
'wch10', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=10)))
dp.add_handler(
CommandHandler(
'wch15', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=15)))
dp.add_handler(
CommandHandler(
'wch20', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=20)))
dp.add_handler(
CommandHandler(
'wch25', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=25)))
dp.add_handler(
CommandHandler(
'wch30', lambda update, context: cmd.download.wc_anim_handler(
update, context, hourly=True, top=30)))
dp.add_handler(CommandHandler('hd', cmd.download.headings_handler))
dp.add_handler(CommandHandler('sources', cmd.sources.sources_handler))
dp.add_handler(CommandHandler('domain', cmd.domain.domain_handler))
dp.add_handler(CommandHandler('userinfo', cmd.userinfo.userinfo_handler))
dp.add_handler(CommandHandler('hist', cmd.download.histograms_handler))
dp.add_handler(CommandHandler('top', cmd.top.top_handler))
dp.add_handler(CommandHandler('tops', cmd.top.tops_handler))
dp.add_handler(CommandHandler('rss', cmd.sources.update_handler))
logger.info("starting to poll")
updater.start_polling()
updater.idle()
def test_context(self, cdp, poll):
handler = PollHandler(self.callback_context)
cdp.add_handler(handler)
cdp.process_update(poll)
assert self.test_flag
def test_other_update_types(self, false_update):
handler = PollHandler(self.callback_basic)
assert not handler.check_update(false_update)
if __name__ == '__main__':
# TOKEN = HERE
updater = Updater(TOKEN, use_context=True,
request_kwargs={'read_timeout': 6, 'connect_timeout': 7})
dp = updater.dispatcher
if os.path.isfile('active_chats'):
data.deserialize()
dp.add_handler(CommandHandler('start', help_menu))
dp.add_handler(CommandHandler('status', status))
dp.add_handler(CommandHandler('menu', store))
dp.add_handler(CommandHandler('help', help_menu))
dp.add_handler(CommandHandler('chat', help_menu))
dp.add_handler(CommandHandler('cancel', cancel))
dp.add_handler(CommandHandler('skip', skip))
dp.add_handler(CommandHandler('chat_id', chat_id))
dp.add_handler(CallbackQueryHandler(callback_query_handler))
dp.add_handler(MessageHandler(Filters.text & ~Filters.command, message_handler))
dp.add_handler(MessageHandler(Filters.sticker, sticker_handler))
dp.add_handler(MessageHandler(Filters.all, message_all_handler))
dp.add_handler(PollHandler(poll_handler))
dp.add_handler(PollAnswerHandler(poll_answer_handler))
dp.add_error_handler(error_handle)
Db.get_instance().create_black_list()
Db.get_instance().create_active_command_list()
updater.start_polling()
updater.idle()
def main():
# Create the Updater and pass it your bot's token.
updater = Updater(TOKEN, use_context=True)
# Configure notifications job
job_queue = updater.job_queue
job_queue.run_repeating(send_notis, interval=10, first=0)
# Get the dispatcher to register handlers
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start_msg))
dp.add_handler(CommandHandler("help", help_msg))
# Handlers for polls
dp.add_handler(MessageHandler(Filters.poll, dojobot.handle_received_poll))
dp.add_handler(PollHandler(dojobot.receive_poll_answer))
dp.add_handler(MessageHandler(Filters.status_update.new_chat_members, greet_group))
dp.add_handler(MessageHandler(Filters.voice, handle_audio))
dp.add_handler(MessageHandler(Filters.text & ~Filters.command, handle_text_msg))
dp.add_handler(MessageHandler(Filters.document, store_document))
# Change meeting reminder callback query handlers
dp.add_handler(
CallbackQueryHandler(dojobot.remind_main_menu, pattern="remind_main")
)
dp.add_handler(CallbackQueryHandler(dojobot.remind_first_menu, pattern=r"rf.*"))
dp.add_handler(
CallbackQueryHandler(
dojobot.change_remind, pattern=rf"{consts.CHANGE_REMIND}.*"
)
)
dp.add_handler(
CallbackQueryHandler(dojobot.cancel_del, pattern="cancel_change_reminder")
)
# Cancel meeting callback query handlers
dp.add_handler(
CallbackQueryHandler(
dojobot.cancel_meeting_main_menu, pattern="cancel_meeting_main"
)
)
dp.add_handler(
CallbackQueryHandler(dojobot.cancel_meeting_first_menu, pattern=r"cf.*")
)
dp.add_handler(CallbackQueryHandler(dojobot.cancel_meeting, pattern=r"cm.*"))
dp.add_handler(
CallbackQueryHandler(dojobot.cancel_del, pattern="cancel_cancel_meeting")
)
# Meeting agenda callback query handlers
dp.add_handler(
CallbackQueryHandler(
dojobot.store_agenda_callback, pattern=rf"{consts.STORE_AGENDA}.*"
)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.get_agenda_callback, pattern=rf"{consts.GET_AGENDA}.*"
)
)
# Meeting notes callback query handlers
dp.add_handler(
CallbackQueryHandler(
dojobot.store_notes_callback, pattern=rf"{consts.STORE_NOTES}.*"
)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.get_notes_callback, pattern=rf"{consts.GET_NOTES}.*"
)
)
# Task callback query handlers
dp.add_handler(
CallbackQueryHandler(dojobot.ask_task_name, pattern=consts.EDIT_TASK_NAME)
)
dp.add_handler(
CallbackQueryHandler(dojobot.ask_task_summary, pattern=consts.EDIT_TASK_SUMMARY)
)
dp.add_handler(
CallbackQueryHandler(dojobot.ask_task_user, pattern=consts.EDIT_TASK_USER)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.task_user_callback, pattern=rf"{consts.SET_TASK_USER}.*"
)
)
dp.add_handler(
CallbackQueryHandler(dojobot.ask_task_status, pattern=consts.EDIT_TASK_STATUS)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.task_status_callback, pattern=rf"{consts.SET_TASK_STATUS}.*"
)
)
dp.add_handler(
CallbackQueryHandler(dojobot.ask_task_date, pattern=consts.EDIT_TASK_DATE)
)
dp.add_handler(
CallbackQueryHandler(dojobot.create_task, pattern=consts.CREATE_TASK_DONE)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.cancel_create_task, pattern=consts.CANCEL_CREATE_TASK
)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.update_task_callback, pattern=rf"{consts.UPDATE_TASK}.*"
)
)
dp.add_handler(
CallbackQueryHandler(
dojobot.task_feedback_callback, pattern=rf"{consts.TASK_FEEDBACK}.*"
)
)
# Start the Bot
updater.start_polling()
LOGGER.info("Bot started polling")
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
