def get_date_hour(bot, update):
hour = update.get_effective_message().text
dispatcher.set_conversation_data(update, "hour", hour)
user_peer = update.get_effective_user()
if not 0 <= int(hour) < 24:
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_hour),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
bot.send_message(TemplateMessage(Message.GET_ALARM_MINUTE,
button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_minute),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def get_date_year(bot, update):
user_peer = update.get_effective_user()
year = update.get_effective_message().text
dispatcher.set_conversation_data(update, "year", year)
if int(year) < 1397:
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_year),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
print("salammmmmmmmmmmmmmmmmmmmmmmmmm")
else:
bot.send_message(TemplateMessage(Message.GET_ALARM_MONTH, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_month),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def get_date_day(bot, update):
day = update.get_effective_message().text
dispatcher.set_conversation_data(update, "day", day)
user_peer = update.get_effective_user()
if not (
(0 < int(day) < 32
and 0 < int(dispatcher.get_conversation_data(update, "month")) < 7) or
(0 < int(day) < 31
and 6 < int(dispatcher.get_conversation_data(update, "month")) < 13)):
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_day),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
bot.send_message(TemplateMessage(Message.GET_ALARM_HOUR, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_hour),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def start_bot(bot, update):
user_peer = update.get_effective_user()
input = update.get_effective_message()
print(input.text)
btn_list = [
TemplateMessageButton("ساختن هشدار جدید ", "/create_alarm", 0),
TemplateMessageButton("اضافه کردن بدهی ", "/add_debt", 0),
TemplateMessageButton("گرفتن فایل اکسل صورتحساب ها ", "/get_excel", 0)
]
temlate_message = TemplateMessage(
general_message=Message.START_BOT_MESSAGE, btn_list=btn_list)
bot.send_message(temlate_message,
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=["/create_alarm"]),
start_creating_alarm),
MessageHandler(TemplateResponseFilter(keywords=["/add_debt"]),
start_get_debt_conversation),
MessageHandler(TemplateResponseFilter(keywords=["/get_excel"]),
send_excel_report),
MessageHandler(TextFilter(keywords=["/start"]), start_bot),
MessageHandler(TemplateResponseFilter(keywords=["/start"]), start_bot)
])
def get_alarm_stop_message(bot, update):
user_peer = update.get_effective_user()
alarm_stop_message = update.get_effective_message()
if check_stop_message_repetition(user_peer.get_json_str(),
alarm_stop_message.text):
bot.send_message(TemplateMessage(Message.STOP_MESSAGE_REPETIOTION,
button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_alarm_stop_message),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
dispatcher.get_conversation_data(
update, "alarm").stop_message = alarm_stop_message.text
bot.send_message(TemplateMessage(Message.GET_ALARM_PHOTO, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(PhotoFilter(), get_alarm_photo),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def initiate_search_officers(self, bot, update):
self.handlers.extend(self.dispatcher.message_handlers)
user = update.get_effective_user()
message = TemplateMessage(
TextMessage(ConstantMessage.officer_search_criterion), [
TemplateMessageButton(ButtonMessage.all_officers),
TemplateMessageButton(ButtonMessage.main_menu_message)
])
self.send_message(bot, update, message, user,
sys._getframe().f_code.co_name)
self.handlers.extend([
MessageHandler(
TemplateResponseFilter(keywords=[ButtonMessage.all_officers]),
self.handle_customer_criterion_input),
MessageHandler(
TemplateResponseFilter(
keywords=[ButtonMessage.main_menu_message]),
self.show_menu),
])
# TODO: This seems odd to me to add two lists, find a better way if possible
self.dispatcher.register_conversation_next_step_handler(
update, self.handlers + [
MessageHandler(TextFilter(),
self.handle_customer_criterion_input)
])
def get_tweet_text(bot, update):
user_peer = update.get_effective_user()
user = get_registered_user(bot, update)
if user:
dispatcher.set_conversation_data(update, "user", user)
general_message = TextMessage(ReadyText.send_text_twitter)
btn_list = [
TemplateMessageButton(text=ButtonText.cancel,
value=ButtonText.cancel,
action=0)
]
template_message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
"message": template_message,
"update": update,
"bot": bot,
"try_times": 1
}
bot.send_message(template_message,
user_peer,
success_callback=success_send_message,
failure_callback=failure_send_message,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(
update, common_handlers + [
MessageHandler(TextFilter(), send_tweet),
MessageHandler(DefaultFilter(), start_conversation)
])
def get_tweet_text(bot, update):
user_peer = update.get_effective_user()
user_id = user_peer.peer_id
user = get_user(user_id=user_id)
if not check_user_registration(update, user_peer, user):
return 0
general_message = TextMessage(ReadyMessage.send_text_twitter)
btn_list = [
TemplateMessageButton(text=TMessage.cancel,
value=TMessage.cancel,
action=0)
]
template_message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
"message": template_message,
"user_peer": user_peer,
"try_times": 1
}
bot.send_message(template_message,
user_peer,
success_callback=success,
failure_callback=failure,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
CommandHandler("info", info),
MessageHandler(TextFilter(), send_tweet),
MessageHandler(DefaultFilter(), start_conversation)
])
def reminder_text(bot, update):
state = dispatcher.get_conversation_data(update, current_state)
if state == REMINDER_PICTURE:
message = update.get_effective_message()
dispatcher.set_conversation_data(update, Attr.file_id, message.file_id)
dispatcher.set_conversation_data(update, Attr.file_access_hash,
message.access_hash)
dispatcher.set_conversation_data(update, Attr.file_size,
message.file_size)
message = TextMessage(ReadyText.enter_reminder_text)
else:
message = TextMessage(ReadyText.wrong_answer_pls_text)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.getting_picture,
UserData.message: message,
UserData.attempt: SendingAttempt.first,
UserData.logger: my_logger,
UserData.bot: bot
}
bot.respond(update,
message,
success_send_message,
failure_send_message,
kwargs=kwargs)
dispatcher.set_conversation_data(update, current_state, REMINDER_TEXT)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TextFilter(), reminder_finished),
MessageHandler(DefaultFilter(), reminder_text)
])
def reminder_amount(bot, update):
state = dispatcher.get_conversation_data(update, current_state)
if state == REMINDER_CARD_NUMBER:
dispatcher.set_conversation_data(update, Attr.card_number,
update.get_effective_message().text)
message = TextMessage(ReadyText.amount_entering)
else:
message = TextMessage(ReadyText.wrong_answer_pls_enter_number)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.ask_amount,
UserData.message: message,
UserData.attempt: SendingAttempt.first,
UserData.logger: my_logger,
UserData.bot: bot
}
bot.respond(update,
message,
success_send_message,
failure_send_message,
kwargs=kwargs)
dispatcher.set_conversation_data(update, current_state, REMINDER_AMOUNT)
dispatcher.register_conversation_next_step_handler(
update, common_handlers + [
MessageHandler(TextFilter(pattern=Pattern.money_amount),
reminder_picture),
MessageHandler(DefaultFilter(), reminder_amount)
])
def read_step_1(bot, update, wrong_input=False):
user = _get_peer(update)
text = ""
if wrong_input:
text = BotMessage.wrong_input_page + "\n" + BotMessage.choose_page_number
all_marked = get_all_marked(user.peer_id)
btn = []
keywords = []
my_logger.info(
"\n\n\n\n\n\n\n all Marked : {}\n\n\n\n\n\n".format(all_marked))
if len(all_marked) > 0:
text = BotMessage.choose_page_book_mark + " " + BotMessage.choose_page_number
for mark in all_marked:
btn.append(
TemplateMessageButton(text=ButtonMessage.read_page.format(
persian.convert_en_numbers(mark[0])),
value=mark[0],
action=0))
keywords.append(str(mark[0]))
else:
text = BotMessage.choose_page_number
btn.append(
TemplateMessageButton(ButtonMessage.return_to_main_menu,
ButtonMessage.return_to_main_menu, 0))
txt_msg = TextMessage(text)
message = TemplateMessage(txt_msg, btn)
send_message(message, _get_peer(update))
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=keywords), read_step_2),
MessageHandler(TextFilter(), read_step_2),
MessageHandler(DefaultFilter(), start_bot),
])
def get_date_minute(bot, update):
minute = update.get_effective_message().text
dispatcher.set_conversation_data(update, "minute", minute)
user_peer = update.get_effective_user()
if not 0 <= int(minute) < 60:
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_date_minute),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
# print(create_time(year, month, day, hour, minute))
dispatcher.get_conversation_data(
update, "alarm").start_time = create_time(
dispatcher.get_conversation_data(update, "year"),
dispatcher.get_conversation_data(update, "month"),
dispatcher.get_conversation_data(update, "day"),
dispatcher.get_conversation_data(update, "hour"),
dispatcher.get_conversation_data(update, "minute"))
bot.send_message(TemplateMessage(Message.GET_ALARM_REPETITION_PERIOD,
button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), finish_creating_alarm),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def tafsir_step_1(bot, update, start=1, end=30):
txt = BotMessage.choose_soore
txt_msg = TextMessage(txt)
soore_list = soore_show(start, end)
btn = []
for soore in soore_list:
btn.append(TemplateMessageButton(soore, soore, 0))
if end < 114:
btn.append(
TemplateMessageButton(ButtonMessage.show_more,
ButtonMessage.show_more, 0))
btn.append(
TemplateMessageButton(ButtonMessage.return_to_main_menu,
ButtonMessage.return_to_main_menu, 0))
msg = TemplateMessage(txt_msg, btn)
send_message(msg, _get_peer(update), Step.conversation_starter)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=soore_show(1, 114)),
tafsir_step_2),
MessageHandler(
TemplateResponseFilter(keywords=ButtonMessage.show_more),
functools.partial(tafsir_step_1, start=end + 1, end=end + 30)),
MessageHandler(
TemplateResponseFilter(keywords=ButtonMessage.return_to_main_menu),
start_bot),
MessageHandler(DefaultFilter(), tafsir_step_1)
])
def add_reminder(bot, update):
state = dispatcher.get_conversation_data(update, current_state)
if state == ADD_REMINDER:
message = TextMessage(ReadyText.wrong_format)
else:
message = TextMessage(ReadyText.enter_reminder_date)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.ask_time,
UserData.message: message,
UserData.attempt: SendingAttempt.first,
UserData.logger: my_logger,
UserData.bot: bot
}
bot.respond(update,
message,
success_send_message,
failure_send_message,
kwargs=kwargs)
dispatcher.set_conversation_data(update, current_state, ADD_REMINDER)
dispatcher.register_conversation_next_step_handler(
update, common_handlers + [
MessageHandler(TextFilter(), set_time),
MessageHandler(DefaultFilter(), add_reminder)
])
def ask_type(bot, update):
if notification.get(Attr.periodic_type) is None:
notification[Attr.iterate_number] = 0
else:
notification[Attr.iterate_number] = int(
update.get_effective_message().text_message)
general_message = TextMessage(BotMessages.notification_type_selection)
btn_list = [
TemplateMessageButton(BotMessages.normal, ResponseValue.normal,
MessageButtonAction.default),
TemplateMessageButton(BotMessages.debt, ResponseValue.debt,
MessageButtonAction.default)
]
message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.ask_type,
UserData.message: message,
UserData.attempt: SendingAttempt.first
}
bot.respond(update,
message,
success_callback=success,
failure_callback=failure,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=[ResponseValue.normal]),
ask_picture),
MessageHandler(TemplateResponseFilter(keywords=[ResponseValue.debt]),
ask_card_number),
MessageHandler(DefaultFilter(), wrong_type)
])
def ask_picture(bot, update):
if notification.get(Attr.type):
notification[Attr.money_amount] = update.get_effective_message().text
else:
notification[Attr.type] = ResponseValue.normal
message = TemplateMessage(
general_message=TextMessage(BotMessages.picture_request),
btn_list=[
TemplateMessageButton(BotMessages.no_picture_needed,
ResponseValue.no_picture,
MessageButtonAction.default)
])
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: UserData.ask_picture,
UserData.message: message,
UserData.attempt: SendingAttempt.first
}
bot.respond(update, message, success, failure, kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(
TemplateResponseFilter(keywords=[ResponseValue.no_picture]),
ask_text),
MessageHandler(PhotoFilter(), getting_picture),
CommandHandler([Command.start], conversation_starter),
MessageHandler(DefaultFilter(), wrong_picture)
])
def periodic_state(bot, update):
str_date = update.get_effective_message().text
notification[Attr.date_time] = jdatetime.datetime.strptime(
str_date, Config.accepted_datetime_format)
general_message = TextMessage(BotMessages.periodic_state_selection)
btn_list = [
TemplateMessageButton(BotMessages.only_once, ResponseValue.only_once,
MessageButtonAction.default),
TemplateMessageButton(BotMessages.iterative, ResponseValue.iterative,
MessageButtonAction.default)
]
message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.periodic_state,
UserData.message: message,
UserData.attempt: SendingAttempt.first
}
bot.respond(update,
message,
success_callback=success,
failure_callback=failure,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(
TemplateResponseFilter(keywords=[ResponseValue.only_once]),
ask_type),
MessageHandler(
TemplateResponseFilter(keywords=[ResponseValue.iterative]),
period_type),
CommandHandler([Command.start], conversation_starter),
MessageHandler(DefaultFilter(), wrong_periodic_state)
])
def period_type(bot, update):
general_message = TextMessage(BotMessages.periodic_type_selection)
btn_list = [
TemplateMessageButton(BotMessages.daily, ResponseValue.daily,
MessageButtonAction.default),
TemplateMessageButton(BotMessages.weekly, ResponseValue.weekly,
MessageButtonAction.default),
TemplateMessageButton(BotMessages.monthly, ResponseValue.monthly,
MessageButtonAction.default)
]
message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.period_type,
UserData.message: message,
UserData.attempt: SendingAttempt.first
}
bot.respond(update,
message,
success_callback=success,
failure_callback=failure,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=[ResponseValue.daily]),
ask_iterate_number),
MessageHandler(TemplateResponseFilter(keywords=[ResponseValue.weekly]),
ask_iterate_number),
MessageHandler(
TemplateResponseFilter(keywords=[ResponseValue.monthly]),
ask_iterate_number),
CommandHandler([Command.start], conversation_starter),
MessageHandler(DefaultFilter(), wrong_period_type)
])
def remove_from_book_mark(bot, update, page_number):
user = _get_peer(update)
is_removed = remove_book_mark(peer_id=user.peer_id,
page_number=page_number)
if is_removed == 1:
text_message = TextMessage(
BotMessage.removed_from_book_mark.format(
persian.convert_en_numbers(page_number)))
btn = [
TemplateMessageButton(
ButtonMessage.back_to_read.format(
persian.convert_en_numbers(page_number)),
ButtonMessage.back_to_read.format(
persian.convert_en_numbers(page_number)), 0),
TemplateMessageButton(ButtonMessage.return_to_main_menu,
ButtonMessage.return_to_main_menu, 0)
]
message = TemplateMessage(text_message, btn)
send_message(message=message, peer=user)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(
TemplateResponseFilter(
keywords=ButtonMessage.back_to_read.format(
persian.convert_en_numbers(page_number))),
functools.partial(read_step_2, change_page=page_number)),
MessageHandler(DefaultFilter(), start_bot)
])
else:
check_message("asdasdasd", update)
def ask_question(bot, update):
user_peer = update.get_effective_user()
my_message = TextMessage("*Your Template Message created!*")
kwargs = {"update": update}
bot.send_message(my_message,
user_peer,
success_callback=success_send_message,
failure_callback=failure_send_message,
kwargs=kwargs)
# Set client message as general message of a template message
general_message = update.get_effective_message()
# Create how many buttons you like with TemplateMessageButton class
btn_list = [
TemplateMessageButton(text="yes", value="yes", action=0),
TemplateMessageButton(text="no", value="no", action=0)
]
# Create a Template Message
template_message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
bot.send_message(template_message,
user_peer,
success_callback=success_send_message,
failure_callback=failure_send_message,
kwargs=kwargs)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TemplateResponseFilter(keywords=["yes"]),
positive_answer),
MessageHandler(TemplateResponseFilter(keywords=["no"]),
negative_answer)
])
def get_debt_date_day(bot, update):
user_peer = update.get_effective_user()
debt_day = update.get_effective_message()
dispatcher.set_conversation_data(update, "debt_day", debt_day.text)
if not ((0 < int(debt_day.text) < 32 and 0 < int(
dispatcher.get_conversation_data(update, "debt_month")) < 7) or
(0 < int(debt_day.text) < 31 and 6 < int(
dispatcher.get_conversation_data(update, "debt_month")) < 13)):
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_debt_date_day),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
dispatcher.get_conversation_data(
update, "debt").date = "{}:{}:{}".format(
dispatcher.get_conversation_data(update, "debt_year"),
dispatcher.get_conversation_data(update, "debt_month"),
dispatcher.get_conversation_data(update, "debt_day"))
print(dispatcher.get_conversation_data(update, "debt").user_id)
bot.send_message(TemplateMessage(Message.GET_DEBT_PHOTO, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(PhotoFilter(), get_debt_photo),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def get_debt_date_month(bot, update):
user_peer = update.get_effective_user()
debt_month = update.get_effective_message()
dispatcher.set_conversation_data(update, "debt_month", debt_month.text)
if not (0 < int(debt_month.text) < 13):
bot.send_message(TemplateMessage(Message.INVALID_INPUT, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_debt_date_month),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
else:
bot.send_message(TemplateMessage(Message.GET_DEBT_DAY, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(
update, [
MessageHandler(TextFilter(), get_debt_date_day),
MessageHandler(TemplateResponseFilter(keywords="/start"),
start_bot)
])
def number_of_repetitions(bot, update):
state = dispatcher.get_conversation_data(update, current_state)
if state == SET_DATE:
message = update.get_effective_message()
dispatcher.set_conversation_data(update, Attr.periodic_type,
message.text)
message = TextMessage(ReadyText.iterate_number_selection)
else:
message = TextMessage(ReadyText.wrong_answer_pls_enter_number)
kwargs = {
UserData.user_peer: update.get_effective_user(),
UserData.step_name: Step.ask_iterate_number,
UserData.message: message,
UserData.attempt: SendingAttempt.first,
UserData.logger: my_logger,
UserData.bot: bot
}
bot.respond(update,
message,
success_send_message,
failure_send_message,
kwargs=kwargs)
dispatcher.set_conversation_data(update, current_state,
NUMBER_OF_REPETITIONS)
dispatcher.register_conversation_next_step_handler(
update, common_handlers + [
MessageHandler(TextFilter(pattern=Pattern.number), reminder_type),
MessageHandler(DefaultFilter(), number_of_repetitions)
])
def purchase_message(bot, update):
message = update.get_effective_message()
user_peer = update.get_effective_user()
first_purchase_message = PurchaseMessage(msg=message, account_number=6037991067471130, amount=100,
money_request_type=MoneyRequestType.normal)
bot.send_message(first_purchase_message, user_peer, success_callback=success, failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [MessageHandler(BankMessageFilter(), payment),
MessageHandler(DefaultFilter(), default_handler)])
def conversation_starter(bot, update):
message = TextMessage("*Hi , nice to meet you*\nplease tell me your name.")
# Get client user object by a function called (get_effective_user)
user_peer = update.get_effective_user()
# Set any user data in kwargs mode
kwargs = {"message": message, "update": update}
bot.send_message(message, user_peer, success_callback=success_send_message, failure_callback=failure_send_message,
kwargs=kwargs)
# You can put more than one Filters for your handler
dispatcher.register_conversation_next_step_handler(update, [MessageHandler(TextFilter(), ask_name),
MessageHandler(DefaultFilter(), skip_name)])
def conversation_starter(bot, update):
user_peer = update.get_effective_user()
general_message = TextMessage("Hi ,Are you hungry?")
btn_list = [TemplateMessageButton(text="yes", value="yes", action=0),
TemplateMessageButton(text="no", value="no", action=0)]
template_message = TemplateMessage(general_message=general_message, btn_list=btn_list)
bot.send_message(template_message, user_peer, success_callback=success, failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [MessageHandler(TemplateResponseFilter(keywords=["yes"]),
find_location),
MessageHandler(TemplateResponseFilter(keywords=["no"]),
no_thanks)])
def conversation_starter(bot, update):
message = TextMessage(
"Hi , nice to meet you :)\nplease send me a contact.")
user_peer = update.get_effective_user()
bot.send_message(message,
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(ContactFilter(), ask_contact),
MessageHandler(DefaultFilter(), no_contact)
])
def get_name_creditor(bot, update):
user_peer = update.get_effective_user()
creditor_name = update.get_effective_message()
dispatcher.get_conversation_data(update,
"debt").creditor_name = creditor_name.text
bot.send_message(TemplateMessage(Message.GET_DEBT_YEAR, button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TextFilter(), get_debt_date_year),
MessageHandler(TemplateResponseFilter(keywords="/start"), start_bot)
])
def get_amount(bot, update):
user_peer = update.get_effective_user()
amount = update.get_effective_message()
dispatcher.get_conversation_data(update, "debt").amount = amount.text
bot.send_message(TemplateMessage(Message.GET_DEBT_CARD_NUMBER,
button_list),
user_peer,
success_callback=success,
failure_callback=failure)
dispatcher.register_conversation_next_step_handler(update, [
MessageHandler(TextFilter(), get_card_number),
MessageHandler(TemplateResponseFilter(keywords="/start"), start_bot)
])
