def main():
updater = Updater(telegram_token)
# Get the dispatcher to register handlers
dp = updater.dispatcher
cqh = telegram.ext.CallbackQueryHandler(inline, pass_user_data=True)
states = {
"CHECK_CONTACT_U": [MessageHandler(Filters.contact, got_contact, pass_user_data=True),
MessageHandler(Filters.text, no_contact)],
"MAIN_MENU_A": [RegexHandler(texts.orders_btn_admin, orders_admin),
RegexHandler(texts.edit_btn_admin, edit_admin),
RegexHandler(texts.stat_btn_admin,
ans(text=texts.stat_type, keyboard=stat_type_kbd, next_state="STAT_A")),
RegexHandler(texts.info_btn_admin, info_admin)],
"STAT_A": [RegexHandler(texts.static_stat_btn, static_stat_admin),
RegexHandler(texts.dynamic_stat_btn, dynamic_stat_admin)],
"MAIN_MENU_U": [RegexHandler(texts.catalog_btn_user, catalog_user),
RegexHandler(texts.cart_btn_user, cart_user, pass_user_data=True),
RegexHandler(texts.orders_btn_user, orders_user, pass_user_data=True),
RegexHandler(texts.info_btn_user, info_user)],
"CATALOG_U": [
RegexHandler(btn, ans(text=texts.select_subcategory % btn,
keyboard=catalog.subcat_kbd[btn] + [[texts.main_menu_btn]],
next_state="CATALOG_" + btn + "_U"))
for btn in flatten(catalog.categories_kbd)],
"TO_CART_DONE_U": [RegexHandler(texts.confirm_order_btn, cart_user, pass_user_data=True),
RegexHandler(texts.to_cat_btn, catalog_user)],
"DELIVERY_U": [RegexHandler(texts.delivery_carrier_btn, ans(text=texts.delivery_addr_input,
next_state="DELIVERY_ADDR_U")),
RegexHandler(texts.delivery_pickup_btn, ans(text=texts.delivery_pickup_input,
keyboard=pickup_points,
next_state="PICKUP_POINT_U")),
],
"DELIVERY_ADDR_U": [
MessageHandler(Filters.text, saving_ans(text=texts.delivery_date_input, name="delivery_addr",
next_state="DELIVERY_DATE_U"), pass_user_data=True)],
"DELIVERY_DATE_U": [
MessageHandler(Filters.text, saving_ans(text=texts.delivery_time_input, name="delivery_date",
next_state="DELIVERY_TIME_U", checker=correct_date,
error_text=texts.wrong_date_format),
pass_user_data=True)],
"DELIVERY_TIME_U": [MessageHandler(Filters.text, order_confirm, pass_user_data=True)],
"PICKUP_POINT_U": [MessageHandler(Filters.text, order_confirm, pass_user_data=True)],
"ORDERS_U": [MessageHandler(Filters.text, order_action, pass_user_data=True)],
"ORDERS_SORT_A": [RegexHandler(texts.active_orders_btn, show_active_orders, pass_user_data=True),
RegexHandler(texts.date_orders_btn, ans(texts.date_input, next_state="DATE_INPUT_A")),
RegexHandler(texts.archive_orders_btn, show_archive, pass_user_data=True)],
"DATE_INPUT_A": [MessageHandler(Filters.text, show_date_orders, pass_user_data=True)],
"ORDER_PROCESS_A": [MessageHandler(Filters.text, process_order_admin, pass_user_data=True)],
"EDIT_STATUS_A": [RegexHandler(texts.cancel_status_input_btn,
ans(text=texts.status_input_cancelled,
keyboard=main_kbd_admin, next_state="MAIN_MENU_A")),
MessageHandler(Filters.text, change_order_status, pass_user_data=True)
],
}
states["DATE_INPUT_A"] = states["ORDERS_SORT_A"] + states["DATE_INPUT_A"]
for cat in flatten(catalog.categories_kbd):
states["CATALOG_" + cat + "_U"] = [RegexHandler(btn,
lambda bot, update, user_data, cat=cat, btn=btn:
catalog_item(bot, update, user_data=user_data,
text=str(catalog[cat][btn][0]),
subcat=catalog[cat][btn]),
pass_user_data=True)
for btn in flatten(catalog.subcat_kbd[cat])]
command_handlers = [CommandHandler('start', start, pass_user_data=True), ]
back_to_list_handler = [RegexHandler(texts.to_item_list_btn, catalog_item, pass_user_data=True)]
main_menu_u_handler = [RegexHandler(texts.main_menu_btn,
ans(text=texts.main_menu_btn, keyboard=main_kbd_user,
next_state="MAIN_MENU_U"))]
main_menu_a_handler = [RegexHandler(texts.main_menu_btn,
ans(text=texts.main_menu_btn, keyboard=main_kbd_admin,
next_state="MAIN_MENU_A"))]
# inline buttons and slash-commands must be handled from any chat state
states = {k: (main_menu_u_handler + command_handlers + [cqh] + back_to_list_handler + v if k.endswith("_U") else
main_menu_a_handler + command_handlers + [cqh] + v) for k, v in states.items()}
# Add conversation handler with the states
conversation_handler = ConversationHandler(entry_points=command_handlers, states=states, fallbacks=[])
# load user data and conversations states from file
conversation_handler.conversations, dp.user_data = load_state()
dp.add_handler(conversation_handler)
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Run the bot until the you presses 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()
# save user data and conversations states to file
save_state(conversation_handler.conversations, dp.user_data)
def main(updater):
dispatcher = updater.dispatcher
dbFuncs.initDB()
newList = ConversationHandler(
entry_points=[
CommandHandler('new', new, Filters.private),
CommandHandler('start', start, Filters.private, pass_args=True)
],
states={
SETNAME: [MessageHandler(Filters.text & Filters.private, setName)]
},
fallbacks=[
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
])
listHandler = ConversationHandler(
entry_points=[CallbackQueryHandler(pushInline)],
states={SETTINGS: [CallbackQueryHandler(pushAdmin)]},
fallbacks=[
CallbackQueryHandler(pushInline),
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
],
per_message=True)
dispatcher.add_handler(newList)
dispatcher.add_handler(listHandler)
dispatcher.add_handler(CallbackQueryHandler(pushInline))
dispatcher.add_handler(
CommandHandler('send', sendAll,
Filters.private & Filters.chat(chat_id=[114951690])))
dispatcher.add_handler(CommandHandler('help', help, Filters.private))
dispatcher.add_handler(CommandHandler('backup', backup, Filters.private))
dispatcher.add_handler(InlineQueryHandler(inlineQuery))
dispatcher.add_handler(ChosenInlineResultHandler(chosenQuery))
dispatcher.add_handler(
MessageHandler(Filters.private & Filters.regex(r'^\/.*'), blankCode))
dispatcher.add_handler(
MessageHandler(
Filters.text & Filters.private & Filters.update.edited_message,
editMessage))
dispatcher.add_handler(
MessageHandler(
Filters.private & Filters.text & Filters.reply &
(~Filters.update.edited_message), rcvReply))
dispatcher.add_handler(
MessageHandler(
Filters.text & Filters.private & (~Filters.update.edited_message),
rcvMessage))
dispatcher.add_error_handler(contextCallback)
try:
with open('{0}/userdata'.format(backupsDir), 'rb') as file:
dispatcher.user_data = pload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/newList'.format(backupsDir), 'rb') as file:
newList.conversations = pload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/listHandler'.format(backupsDir), 'rb') as file:
listHandler.conversations = pload(file)
except Exception as e:
logger.warning(repr(e))
updater.start_polling()
updater.idle()
try:
with open('{0}/userdata'.format(backupsDir), 'wb+') as file:
pdump(dispatcher.user_data, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/newList'.format(backupsDir), 'wb+') as file:
pdump(newList.conversations, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/listHandler'.format(backupsDir), 'wb+') as file:
pdump(listHandler.conversations, file)
except Exception as e:
logger.warning(repr(e))
def main(updater):
# Initialize database if necessary
dbFuncs.initDB()
dispatcher = updater.dispatcher
job_queue = updater.job_queue
# Step 1 Conversationhandler: Registration
register = ConversationHandler(
entry_points=[CommandHandler('start', start, Filters.private)],
states={
SETLANG: [
MessageHandler(filters=Filters.private & Filters.text,
callback=setLang,
pass_user_data=True)
],
TGUNDERUSAGE: [
MessageHandler(filters=Filters.private & Filters.text,
callback=tgUnderUsage)
],
EMAIL: [
MessageHandler(filters=Filters.private & Filters.text,
callback=setMail,
pass_user_data=True)
],
MAILUNDERUSAGE: [
MessageHandler(filters=Filters.private & Filters.text,
callback=mailUnderUsage,
pass_user_data=True)
],
CONFIRMATION: [
MessageHandler(filters=Filters.private & Filters.text,
callback=confirmation,
pass_user_data=True)
]
},
fallbacks=[
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
])
# Step 2 ConversationHandler: Mainscreen
control = ConversationHandler(
entry_points=[CallbackQueryHandler(mainScreen)],
states={
MAINSCREEN: [CallbackQueryHandler(mainScreen)],
BILL: [CallbackQueryHandler(bill, pass_user_data=True)],
BUY: [CallbackQueryHandler(buy, pass_user_data=True)],
CONFIRMBUY:
[CallbackQueryHandler(confirmBuy, pass_user_data=True)],
SETTINGS: [CallbackQueryHandler(settings)],
LANGUAGE: [CallbackQueryHandler(language)],
INFORMATIONS: [CallbackQueryHandler(informations)],
REVOKE: [CallbackQueryHandler(revoke)],
},
fallbacks=[
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
],
per_message=True)
dispatcher.add_handler(
CommandHandler('insert', insert, Filters.private, pass_args=True))
# Registering both handlers
dispatcher.add_handler(register)
dispatcher.add_handler(control)
# Registering monthly reminder
job_queue.run_once(callback=monthlyReminder, when=helpFuncs.nextReminder())
# Testreminder, reminds every minute.
# job_queue.run_once(callback = testReminder, when = helpFuncs.testReminder())
try:
with open('{0}/userdata'.format(backupsDir), 'rb') as file:
dispatcher.user_data = pickleload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/register'.format(backupsDir), 'rb') as file:
register.conversations = pickleload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/control'.format(backupsDir), 'rb') as file:
control.conversations = pickleload(file)
except Exception as e:
logger.warning(repr(e))
updater.start_polling()
updater.idle()
try:
with open('{0}/userdata'.format(backupsDir), 'wb+') as file:
pickledump(dispatcher.user_data, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/register'.format(backupsDir), 'wb+') as file:
pickledump(register.conversations, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/control'.format(backupsDir), 'wb+') as file:
pickledump(control.conversations, file)
except Exception as e:
logger.warning(repr(e))
