def create_tg_conversation_handler(self) -> tg.ConversationHandler:
return tg.ConversationHandler(
entry_points=[tg.CommandHandler('start', self.start)],
states={
STAGE_SET_KEY: [tg.MessageHandler(Filters.text, self.set_key)]
},
fallbacks=[])
def group_conv():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('view', group_view)],
states={},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def change_logiks():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('change', logik_change)],
states={
LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, enter_logiks)],
},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def people_conv():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('teacher_admin', teacher_admin)],
states={
GR_ID: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, gr_id)],
USERNAME: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, username)],
LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, logiks)],
},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def main():
print("Connection to Telegram established; starting bot.")
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('start', start, pass_user_data=True)],
states={
CHOOSING: [
ext.RegexHandler('^(Nama|NIM_or_NIP|Email)$',
regular_choice,
pass_user_data=True),
],
TYPING_CHOICE: [
ext.MessageHandler(ext.Filters.text,
regular_choice,
pass_user_data=True),
],
TYPING_REPLY: [
ext.MessageHandler(ext.Filters.text,
received_information,
pass_user_data=True),
],
},
fallbacks=[ext.RegexHandler('^Done$', done, pass_user_data=True)])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start command
# dp.add_handler(ext.CommandHandler(
# ('start'), start))
# Home command
dp.add_handler(ext.CommandHandler(('home'), home))
# Tata Tulis PKL dan TA
dp.add_handler(ext.CommandHandler(('tatatulis'), tatatulis))
# Layanan TA
dp.add_handler(ext.CommandHandler(('layananta'), layananta))
# Layanan PKL
dp.add_handler(ext.CommandHandler(('layananpkl'), layananpkl))
# Button Handler
dp.add_handler(ext.CallbackQueryHandler(button))
# Filter Command
dp.add_handler(ext.MessageHandler((ext.Filters.command), unknowncommand))
updater.start_polling()
updater.idle()
def main(dispatcher):
send_broadcast_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('send_broadcast', __send_broadcast)],
states={
REVIEW: [ext.MessageHandler(ext.Filters.text, __review_message)],
CONFIRMATION: [
ext.MessageHandler(ext.Filters.regex('Yes|No'),
__confirm_broadcast)
]
},
fallbacks=[ext.CommandHandler('cancel', __send_broadcast_cancel)])
dispatcher.add_handler(send_broadcast_handler)
def start_telegram_updater():
updater = t_ext.Updater(os.environ["CECIBOT_TELEGRAM_SECRET"])
updater.dispatcher.add_handler(t_ext.ConversationHandler(
entry_points=[
t_ext.CommandHandler("start", start),
t_ext.MessageHandler(t_ext.Filters.text, only)
],
allow_reentry=True,
states={},
fallbacks=[],
))
updater.dispatcher.add_error_handler(error)
updater.start_polling()
def main(dispatcher):
add_word_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('add_word', __add_word)],
states={
WORD: [ext.MessageHandler(ext.Filters.text, __set_word)],
MEANING: [
ext.MessageHandler(ext.Filters.text, __set_meaning),
ext.CallbackQueryHandler(__word_meaning_verification,
pattern=r'^word_meaning:\d$')
],
MEANING_ERROR:
[ext.MessageHandler(ext.Filters.text, __handle_meaning_error)],
},
fallbacks=[ext.CommandHandler('cancel', __add_word_cancel)])
dispatcher.add_handler(add_word_handler)
def main():
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s")
updater = tex.Updater(
token='1611542237:AAGPMlkeNxp3geL0urxsSsBncnOBROjctsg')
dp = updater.dispatcher
# Handler do jogo
game_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler('start', start)],
states={'ROUND': [tex.CallbackQueryHandler(round)]},
fallbacks=[tex.CommandHandler('start', start)])
dp.add_handler(game_handler)
updater.start_polling()
logging.info("=== Bot running! ===")
updater.idle()
logging.info("=== Bot shutting down! ===")
def create_tg_conversation_handler(self):
return tg.ConversationHandler(
entry_points=[
tg.CommandHandler('track', self.start, pass_user_data=True)
],
states={
SET_SPENT_ON: [
tg.CallbackQueryHandler(self.spent_on,
pattern='^\d{4}-\d{2}-\d{2}$',
pass_user_data=True)
],
SET_ISSUE: [
tg.CallbackQueryHandler(self.issue,
pattern='^\d+$',
pass_user_data=True)
],
SET_COMMENTS: [
tg.MessageHandler(Filters.text,
self.comment,
pass_user_data=True)
],
SET_HOURS: [
tg.CallbackQueryHandler(self.add_hours,
pattern='^[\\d.]+$',
pass_user_data=True),
tg.CallbackQueryHandler(self.reset_hours,
pattern='^Reset$',
pass_user_data=True)
],
},
fallbacks=[
tg.CallbackQueryHandler(self.done,
pattern='^Done$',
pass_user_data=True),
tg.CommandHandler('cancel', self.cancel, pass_user_data=True)
],
)
def cancel(update, context):
user = update.message.from_user
logger.info("User %s canceled the conversation.", user.first_name)
update.message.reply_text('Oh no! :(')
return ext.ConversationHandler.END
VOICE, COMUNE = range(2)
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('sample', sample)],
states={
COMUNE:
[ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, comune)],
VOICE:
[ext.MessageHandler(ext.Filters.audio | ext.Filters.voice, audio)]
},
fallbacks=[ext.CommandHandler('cancel', cancel)])
with open('token', 'r') as tok_f:
token = tok_f.read().strip()
updater = ext.Updater(token=token, use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(start_handler)
dispatcher.add_handler(debug_handler)
dispatcher.add_handler(conv_handler)
update.message.reply_text(ans.answers[ans.BYE][user.language])
user.delete_document()
return tg_ext.ConversationHandler.END
create_pdf_handler = tg_ext.ConversationHandler(
entry_points=[tg_ext.CommandHandler('create_pdf', create_pdf)],
states={
FILENAME: [
tg_ext.MessageHandler(
tg_ext.Filters.text & ~tg_ext.Filters.command, get_filename)
],
AMOUNT_OF_PHOTOS: [
tg_ext.MessageHandler(
tg_ext.Filters.text & ~tg_ext.Filters.command,
get_amount_of_photo)
],
PHOTO: [tg_ext.MessageHandler(tg_ext.Filters.photo, get_photo)],
ADD_OR_END: [
tg_ext.CommandHandler("add", add_photos),
tg_ext.CommandHandler("end", end_pdf)
],
},
fallbacks=[tg_ext.CommandHandler("cancel", cancel)])
dispatcher.add_handler(create_pdf_handler)
updater.start_polling()
conv_handler = tg_ext.ConversationHandler(
entry_points=[
tg_ext.CommandHandler('sock',
sock,
pass_args=True,
pass_user_data=True),
],
states={
SOCK: [
tg_ext.CommandHandler('sock',
sock,
pass_args=True,
pass_user_data=True),
tg_ext.MessageHandler(tg_ext.Filters.text,
send_text,
pass_user_data=True),
tg_ext.MessageHandler(tg_ext.Filters.photo,
send_photo,
pass_user_data=True),
],
},
fallbacks=[
tg_ext.CommandHandler('cancel', cancel),
tg_ext.CommandHandler('done', cancel),
tg_ext.CommandHandler('exit', cancel),
tg_ext.CommandHandler('quit', cancel),
tg_ext.CommandHandler('q', cancel),
],
)
existingPlayer["active"] = False
text = 'Para retornar ao menu do jogo, digite /play'
context.bot.sendMessage(chat_id=update.effective_user.id, text=text)
return tex.ConversationHandler.END
updater = tex.Updater(token=TOKEN, use_context=True)
dispatcher = updater.dispatcher
start_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler('start', start)],
states={
"SET_NICK": [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
set_nick)
]
},
fallbacks=[tex.MessageHandler(tex.Filters.all, invalid_nick)])
play_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler("play", play_command)],
states={
'CHECK_OPTION': [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
check_option)
],
'SPECIFIC_USER': [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
specific_user)
donchian_channel(user, manual)
# ------- handlers -------
admin_handler = tg.CommandHandler('admin', admin_A)
start_handler = tg.CommandHandler('start', start_)
help_handler = tg.CommandHandler('help', help_)
commands_handler = tg.CommandHandler('comandos', commands)
info_handler = tg.CommandHandler('info', info)
carteira_handler = tg.CommandHandler('carteira', carteira)
donchian_handler = tg.CommandHandler('donchian', trigger_donch)
#cancel_handler = tg.CommandHandler('cancelar', cancel)
add_ativo_handler = tg.ConversationHandler(
entry_points = [tg.CommandHandler('adicionar_ativo', add_ativo_A)],
states = {ADD_ATIVO_B: [tg.CommandHandler('adicionar_ativo', add_ativo_A),
tg.MessageHandler(~tg.Filters.command, add_ativo_B)]},
fallbacks = [tg.MessageHandler(tg.Filters.command, cancel)]
)
rem_ativo_handler = tg.ConversationHandler(
entry_points = [tg.CommandHandler('remover_ativo', rem_ativo_A)],
states = {REM_ATIVO_B: [tg.CommandHandler('remover_ativo', rem_ativo_A),
tg.MessageHandler(~tg.Filters.command, rem_ativo_B)]},
fallbacks = [tg.MessageHandler(tg.Filters.command, cancel)]
)
atlz_hora_handler = tg.ConversationHandler(
entry_points = [tg.CommandHandler('hora', atlz_hora_A)],
states = {HORA_B: [tg.CommandHandler('hora', atlz_hora_A),
tg.MessageHandler(~tg.Filters.command, atlz_hora_B)]},
fallbacks = [tg.MessageHandler(tg.Filters.command, cancel)]