def send_tweet(bot, update):
user_peer = update.get_effective_user()
tweet_text = update.get_effective_message().text
user = dispatcher.get_conversation_data(update, "user")
if send_tweet_api(user=user, tweet_text=tweet_text):
general_message = TextMessage(ReadyText.success_tweet)
else:
general_message = TextMessage(ReadyText.fail_tweet)
btn_list = [
TemplateMessageButton(text=ButtonText.back,
value=ButtonText.back,
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.finish_conversation(update)
def show_current_money_branches(bot, update):
user_peer = update.get_effective_user()
money_changer = select_money_changer_by_peer_id(user_peer.peer_id)
branches = select_branches_by_money_changer_id(
money_changer_id=money_changer.id)
dispatcher.set_conversation_data(update, "branches", branches)
if branches:
branches_buttons, keywords = get_template_buttons_from_branches(
branches)
template_message = TemplateMessage(
TextMessage(BotTexts.choose_branch_for_remove), branches_buttons)
send_message(message=template_message,
peer=user_peer,
step=Step.request_province_name)
dispatcher.register_conversation_next_step_handler(
update,
handlers=common_handlers + [
MessageHandler(TemplateResponseFilter(keywords=keywords),
remove_money_branch)
])
else:
buttons_list = [BotButtons.back_to_main_menu]
template_message = TemplateMessage(
TextMessage(BotTexts.no_branches_found), buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.request_province_name)
dispatcher.finish_conversation(update)
def verify(bot, update):
user_peer = update.get_effective_user()
auth = dispatcher.get_conversation_data(update, "auth")
oauth_verifier = update.get_effective_message().text
final_dict = final_verify(oauth_verifier=oauth_verifier, auth=auth)
new_user = User(peer_id=int(user_peer.peer_id),
access_hash=user_peer.access_hash,
twitter_user_id=final_dict.get('user_id'),
screen_name=final_dict.get('screen_name'),
oauth_token=final_dict.get('oauth_token'),
oauth_token_secret=final_dict.get('oauth_token_secret'))
result = User.add_new_user(new_user)
if result and result == ReadyText.register_before:
general_message = TextMessage(ReadyText.register_before)
elif result:
general_message = TextMessage(ReadyText.success_insert_user)
else:
general_message = TextMessage(ReadyText.failure_insert_user)
message = TemplateMessage(general_message=general_message,
btn_list=main_menu)
kwargs = {"message": message, "update": update, "bot": bot, "try_times": 1}
bot.send_message(message,
user_peer,
success_callback=success_send_message,
failure_callback=failure_send_message,
kwargs=kwargs)
dispatcher.finish_conversation(update)
def send_tweet(bot, update):
user_peer = update.get_effective_user()
user_id = user_peer.peer_id
tweet_text = update.get_effective_message().text
user = get_user(user_id=user_id)
if send_tweet_api(final_oauth_token=user.final_oauth_token,
final_oauth_token_secret=user.final_oauth_token_secret,
tweet_text=tweet_text):
general_message = TextMessage(ReadyMessage.success_tweet)
else:
general_message = TextMessage(ReadyMessage.fail_tweet)
btn_list = [
TemplateMessageButton(text=TMessage.back,
value=TMessage.back,
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.finish_conversation(update)
def request_money_changer(bot, update):
user_peer = update.get_effective_user()
sender_name = update.get_effective_message().text
dispatcher.set_conversation_data(update,
key="sender_name",
value=sender_name)
money_changers = select_ready_money_changers()
buttons_list, keywords = get_buttons_from_money_changers(money_changers)
if buttons_list:
buttons_list += [BotButtons.back_to_main_menu]
template_message = TemplateMessage(
TextMessage(BotTexts.choose_one_money_changer), buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.request_money_changer)
dispatcher.register_conversation_next_step_handler(
update,
handlers=common_handlers + [
MessageHandler(TemplateResponseFilter(keywords=keywords),
request_province)
])
else:
buttons_list += [BotButtons.back_to_main_menu]
template_message = TemplateMessage(
TextMessage(BotTexts.no_money_changer_found), buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.request_money_changer)
dispatcher.finish_conversation(update)
def handle_report_begin_date(self, bot, update):
user = update.get_effective_user()
message = arabic_to_eng_number(update.get_effective_message().text)
if re.match(RegexPattern.interval_pattern, message):
split_message = message.split('-')
self.dispatcher.set_conversation_data(
update=update,
key='start_time_delta',
value=split_message[0]
)
self.dispatcher.set_conversation_data(
update=update,
key='end_time_delta',
value=split_message[1]
)
self.create_and_send_final_report(update, bot)
else:
row_date = re.match(RegexPattern.jalali_input_pattern, message)
if row_date:
message = TemplateMessage(
TextMessage(ConstantMessage.service_report_end_date),
[TemplateMessageButton(ButtonMessage.main_menu_message)]
)
self.dispatcher.set_conversation_data(
update=update,
key='begin_date',
value=row_date
)
self.send_message(
bot,
update,
message,
user,
sys._getframe().f_code.co_name
)
self.dispatcher.register_conversation_next_step_handler(
update,
self.handlers +
[
MessageHandler(
TextFilter(),
self.handle_report_end_date
),
]
)
else:
message = TextMessage(ConstantMessage.bad_format)
self.send_message(
bot,
update,
message,
user,
sys._getframe().f_code.co_name
)
def update_money_changer(bot, update):
user_peer = update.get_effective_user()
text_entered = arabic_to_eng_number(update.get_effective_message().text)
previous_state = dispatcher.get_conversation_data(update, "previous_state")
money_changer = select_money_changer_by_peer_id(user_peer.peer_id)
res = None
text_message = None
if previous_state == request_remittance_fee_percent:
percent = float(text_entered)
res = update_money_changer_remittance_fee_percent(
money_changer=money_changer, percent=percent)
text_message = TextMessage(
BotTexts.remittance_fee_percent_updated_successfully.format(
percent))
elif previous_state == request_dollar_rial:
dollar_rial = float(text_entered)
res = update_money_changer_dollar_rial(money_changer=money_changer,
dollar_rial=dollar_rial)
text_message = TextMessage(
BotTexts.dollar_rial_updated_successfully.format(dollar_rial))
elif previous_state == request_dollar_afghani:
dollar_afghani = float(text_entered)
res = update_money_changer_dollar_afghani(
money_changer=money_changer, dollar_afghani=dollar_afghani)
text_message = TextMessage(
BotTexts.dollar_afghani_updated_successfully.format(
dollar_afghani))
elif previous_state == request_card_number:
card_number = text_entered
res = update_money_changer_card_number(money_changer=money_changer,
card_number=card_number)
text_message = TextMessage(
BotTexts.card_number_updated_successfully.format(card_number))
if res:
buttons_list = [BotButtons.back_to_main_menu]
template_message = TemplateMessage(text_message, buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.update_money_changer)
dispatcher.register_conversation_next_step_handler(
update,
handlers=common_handlers + [
MessageHandler(TextFilter(Patterns.float_numbers),
request_sender_name)
])
else:
buttons_list = [BotButtons.back_to_main_menu]
template_message = TemplateMessage(TextMessage(BotTexts.error),
buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.update_money_changer)
dispatcher.finish_conversation(update)
def search_tweets(bot, update):
query = update.get_effective_message().text
user = dispatcher.get_conversation_data(update, "user")
statuses = search_api(user=user, query=query)
statuses = statuses.get("statuses")
if statuses:
loop = asyncio.get_event_loop()
loop.call_soon(send_status_message, 0, loop, statuses, bot, update)
dispatcher.finish_conversation(update)
else:
btn_list = [
TemplateMessageButton(text=ButtonText.back,
value=ButtonText.back,
action=0)
]
general_message = TextMessage(ReadyText.no_search_result)
template_message = TemplateMessage(general_message=general_message,
btn_list=btn_list)
kwargs = {
"message": template_message,
"update": update,
"bot": bot,
"try_times": 1
}
bot.respond(update,
template_message,
success_callback=success_send_message,
failure_callback=failure_send_message,
kwargs=kwargs)
dispatcher.finish_conversation(update)
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 echo(bot, update):
message = TextMessage('*Hello*')
# Send a message to client
bot.reply(update,
message,
success_callback=success,
failure_callback=failure)
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 start(bot, update):
message = TextMessage('*Hello this message will be edited when you send /edit command*')
# Send a message to client
request = bot.respond(update, message, success_callback=success_send_message, failure_callback=failure_send_message)
global request_random_id
request_random_id = request.get_json_object()['body']['randomId']
print(request_random_id)
def start_conversation(bot, update):
user_peer = update.get_effective_user()
general_message = TextMessage(ReadyMessage.start_conversation)
btn_list = [
TemplateMessageButton(text=TMessage.send_tweet,
value=TMessage.send_tweet,
action=0),
TemplateMessageButton(text=TMessage.get_home_time_line,
value=TMessage.get_home_time_line,
action=0),
TemplateMessageButton(text=TMessage.search,
value=TMessage.search,
action=0),
TemplateMessageButton(text=TMessage.info,
value=TMessage.info,
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.finish_conversation(update)
def __init__(self,
peer,
file_id="7406116810654813185",
access_hash="201707397",
name="Page.jpg",
file_size="385192",
mime_type="image/jpeg",
thumb="",
width=80,
height=80,
ext_width=None,
ext_height=None,
file_storage_version=1,
caption_text=TextMessage("hey"),
checksum=None,
algorithm=None,
sender=None):
super().__init__(peer, file_id, access_hash, name, file_size,
mime_type, caption_text, checksum, algorithm,
file_storage_version, sender)
self.thumb = str(thumb)
self.width = int(width)
self.height = int(height)
self.ext_width = int(ext_width) if ext_width else width
self.ext_height = int(ext_height) if ext_height else height
def show_menu(self, bot, update, response=None, user_data=None):
self.dispatcher.clear_conversation_data(update=update)
user_peer = update.get_effective_user()
if not User.exists(user_peer.peer_id):
session.add(
User(peer_id=user_peer.peer_id,
access_hash=user_peer.access_hash))
session.commit()
categories = session.query(Category).all()
category_list = [
TemplateMessageButton(category.description)
for category in categories
]
message = TemplateMessage(TextMessage(ConstantMessage.menu_message),
category_list)
kwargs = {
'update': update,
'user_id': user_peer.peer_id,
'step': sys._getframe().f_code.co_name
}
bot.send_message(message,
user_peer,
success_callback=self.success_sending_message,
failure_callback=self.failure_send_message,
**kwargs)
def money_changer_panel(bot, update):
user_peer = update.get_effective_user()
money_changer = select_money_changer_by_peer_id(user_peer.peer_id)
buttons_list = [
BotButtons.register_branch, BotButtons.update_card_number,
BotButtons.update_dollar_rial, BotButtons.update_dollar_afghani,
BotButtons.update_remittance_fee_percent, BotButtons.remove_branch,
BotButtons.help
]
dollar_rial = money_changer.dollar_rial
remittance_fee_percent = money_changer.remittance_fee_percent
dollar_afghani = money_changer.dollar_afghani
if not money_changer.dollar_rial:
dollar_rial = BotTexts.undefined
if not money_changer.dollar_afghani:
dollar_afghani = BotTexts.undefined
if not money_changer.remittance_fee_percent:
remittance_fee_percent = BotTexts.undefined
text = BotTexts.money_changer_info.format(money_changer.name,
money_changer.card_number,
dollar_rial, dollar_afghani,
remittance_fee_percent)
text = eng_to_arabic_number(text)
text += BotTexts.choose_one_option
template_message = TemplateMessage(TextMessage(text), buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.start_bot_for_logged_in_users)
dispatcher.finish_conversation(update)
def file_upload_success(result, user_data):
file_id = str(user_data.get(Attr.file_id, None))
file_url = str(user_data.get(Attr.url))
access_hash = str(user_data.get(Attr.user_id, None))
user_data = user_data[UserData.kwargs]
user_peer = user_data[UserData.user_peer]
my_logger = user_data[UserData.logger]
bot = user_data[UserData.bot]
my_logger.info(LogText.successful_report_upload,
extra={
UserData.user_id: user_peer.peer_id,
UserData.file_url: file_url
})
file_size = os.path.getsize('files/{}.csv'.format(user_peer.peer_id))
doc_message = DocumentMessage(
file_id=file_id,
access_hash=access_hash,
name=BotConfig.receipts_report_name,
file_size=file_size,
mime_type=MimeType.csv,
caption_text=TextMessage(text=ReadyText.receipts_report))
kwargs = {
UserData.user_peer: user_peer,
UserData.doc_message: doc_message,
UserData.report_attempt: SendingAttempt.first,
UserData.logger: my_logger,
UserData.bot: bot
}
bot.send_message(doc_message,
user_peer,
success_callback=receipt_report_success,
failure_callback=receipt_report_failure,
kwargs=kwargs)
def reply(self,
update,
message,
success_callback=None,
failure_callback=None,
**kwargs):
if isinstance(update, FatSeqUpdate) and update.is_message_update():
message_id = update.body.random_id
user_peer = update.get_effective_user()
if isinstance(message, BaseMessage):
return self.send_message(message,
user_peer,
BotQuotedMessage(
message_id, user_peer),
success_callback=success_callback,
failure_callback=failure_callback,
**kwargs)
else:
return self.send_message(TextMessage(message),
user_peer,
BotQuotedMessage(
message_id, user_peer),
success_callback=success_callback,
failure_callback=failure_callback,
**kwargs)
def success_upload_document(user_data, server_response):
file_id = str(server_response.get("file_id", None))
access_hash = str(server_response.get("user_id", None))
document_message = DocumentMessage(
file_id=file_id,
access_hash=access_hash,
name=name,
file_size=file_size,
mime_type=BotConfig.excel_mime_type,
caption_text=TextMessage(text=name),
file_storage_version=1)
admin_list = get_admin_peers()
for admin in admin_list:
kwargs = {
"user_peer": admin,
"step_name": 'excel_report',
"succedent_message": None,
"message": document_message,
"attempt": 1,
"bot": bot
}
bot.send_message(message=document_message,
peer=admin,
success_callback=step_success,
failure_callback=step_failure,
kwargs=kwargs)
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 verify(bot, update):
user_peer = update.get_effective_user()
user_id = user_peer.peer_id
auth = dispatcher.get_conversation_data(update, "auth")
oauth_verifier = update.get_effective_message().text
access_hash = user_peer.access_hash
final_dict = final_verify(oauth_verifier=oauth_verifier,
oauth_token=auth['oauth_token'],
oauth_token_secret=auth['oauth_token_secret'])
result = insert_user(
user_id=user_id,
access_hash=access_hash,
final_oauth_token=final_dict.get("final_oauth_token"),
final_oauth_token_secret=final_dict.get("final_oauth_token_secret"))
if not result or not final_dict:
text_message = TextMessage(ReadyMessage.fail_insert_user)
kwargs = {
"message": text_message,
"user_peer": user_peer,
"try_times": 1
}
bot.send_message(text_message,
user_peer,
success_callback=success,
failure_callback=failure,
kwargs=kwargs)
dispatcher.finish_conversation(update)
return 0
general_message = TextMessage(ReadyMessage.success_insert_user)
btn_list = [
TemplateMessageButton(text=TMessage.send_tweet,
value=TMessage.send_tweet,
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.finish_conversation(update)
def db_pulling():
my_logger.info(LogMessage.reading_message_db)
current_time = datetime.datetime.now()
message_tobe_sent = session.query(Message).filter(
Message.sent != MessageStatus.sent).filter(
# not sent messages
cast(Message.sending_time, Date) == current_time.date()).filter(
Message.sending_time < current_time).all()
for msg in message_tobe_sent:
my_logger.info(LogMessage.db_has_message_to_send)
notification = msg.notification
user_peer = UserPeer(notification.peer_id,
notification.peer_access_hash)
if notification.file_id:
message = PhotoMessage(file_id=notification.file_id,
access_hash=notification.file_access_hash,
name=BotMessages.photo_name,
file_size=notification.file_size,
mime_type=MimeType.image,
caption_text=TextMessage(notification.text),
file_storage_version=1,
thumb=None)
else:
message = TextMessage(notification.text)
if notification.type == ResponseValue.debt:
if isinstance(message, TextMessage):
message = PhotoMessage(file_id=DefaultPhoto.file_id,
access_hash=DefaultPhoto.access_hash,
name=BotMessages.photo_name,
file_size=DefaultPhoto.file_size,
mime_type=MimeType.image,
caption_text=TextMessage(
notification.text),
file_storage_version=1,
thumb=None)
final_message = PurchaseMessage(
msg=message,
account_number=notification.card_number,
amount=notification.money_amount,
money_request_type=MoneyRequestType.normal)
else:
final_message = message
loop.call_soon(send_message, final_message, user_peer, msg,
SendingAttempt.first)
loop.call_later(Config.db_message_checking_interval, db_pulling)
async def send_alarm(bot=dispatcher.bot):
while (True):
current_time = jdatetime.datetime.now()
if current_time.hour == 21:
for debt in search_debt_for_send(current_time):
user_peer = Peer.load_from_json(debt.user_id)
target_photo = get_photo_by_id(debt.photo_id)
photo_message = PhotoMessage(
target_photo.file_id, target_photo.access_hash,
target_photo.name, target_photo.file_size,
target_photo.mime_type, target_photo.thumb,
target_photo.width, target_photo.height,
target_photo.ext_width, target_photo.ext_height,
target_photo.file_storage_version,
TextMessage(target_photo.caption_text),
target_photo.checksum, target_photo.algorithm)
photo_message.caption_text = TextMessage(debt.creditor_name)
purchase_message = PurchaseMessage(photo_message,
debt.card_number,
debt.amount,
MoneyRequestType.normal)
bot.send_message(purchase_message,
user_peer,
success_callback=success,
failure_callback=failure)
bot.send_message(TemplateMessage(
TextMessage("بازگشت به منوی اصلی "), btn_list=button_list),
user_peer,
success_callback=success,
failure_callback=failure)
for alarm in search_alarm_for_send(current_time):
user_peer = Peer.load_from_json(alarm.user_id)
update_alarm_time(alarm)
photo = PhotoMessage.load_from_json(alarm.photo_json)
photo.caption_text = TextMessage(alarm.message)
bot.send_message(photo,
user_peer,
success_callback=success,
failure_callback=failure)
bot.send_message(TemplateMessage(
TextMessage("بازگشت به منوی اصلی "), btn_list=button_list),
user_peer,
success_callback=success,
failure_callback=failure)
await asyncio.sleep(30)
def success_upload_image(user_data, server_response):
file_id = str(server_response.get("file_id", None))
access_hash = str(server_response.get("user_id", None))
photo_message = PhotoMessage(file_id=file_id, access_hash=access_hash, name=name, file_size=file_size,
mime_type=mime_type, file_storage_version=file_storage_version, width=width,
height=height, caption_text=TextMessage(text=caption_text), thumb=thumb)
self.send_message(message=photo_message, peer=user_peer, success_callback=success_callback,
failure_callback=failure_callback, kwargs=kwargs)
def setUpClass(cls):
peer = Peer(peer_type="User",
peer_id=1422775695,
access_hash="asdqweqwdasd")
message = TextMessage("ASD")
cls.update_request = EditMessage(updated_message=message,
peer=peer,
random_id=123465)
def edit(bot, update):
user_peer = update.get_effective_user()
message = TextMessage('*message edited*')
# edit nd a message to client
bot.edit_message(message=message,
user_peer=user_peer,
random_id=request_random_id,
success_callback=success_edit_message,
failure_callback=failure_edit_message)
def help_me(bot, update):
user_peer = update.get_effective_user()
buttons_list = [BotButtons.back_to_main_menu]
template_message = TemplateMessage(general_message=TextMessage(
BotTexts.help_message),
btn_list=buttons_list)
send_message(message=template_message, peer=user_peer, step=Step.help)
dispatcher.register_conversation_next_step_handler(
update, handlers=common_handlers)
def success_upload_document(user_data, server_response):
file_id = str(server_response.get("file_id", None))
access_hash = str(server_response.get("user_id", None))
document_message = DocumentMessage(file_id=file_id, access_hash=access_hash, name=name,
file_size=file_size, mime_type=mime_type,
caption_text=TextMessage(text=caption_text),
file_storage_version=file_storage_version)
self.respond(update=update, message=document_message, success_callback=success_callback,
failure_callback=failure_callback, kwargs=kwargs)
def test_update_message_content(self):
message = TextMessage("ASD")
peer = Peer(peer_type="User",
peer_id=1422775695,
access_hash="asdqweqwdasd")
self.assertIsInstance(
Bot.edit_message(self.bot,
message=message,
user_peer=peer,
random_id=13246), Request)
def insert_branch(bot, update):
user_peer = update.get_effective_user()
address = update.get_effective_message().text
province = dispatcher.get_conversation_data(update, "province")
money_changer = select_money_changer_by_peer_id(user_peer.peer_id)
table_object = MoneyChangerBranch(money_changer_id=money_changer.id,
address=address,
province=province)
res = insert_to_table(table_object)
buttons_list = [BotButtons.back_to_main_menu]
if res:
text_message = TextMessage(BotTexts.branch_inserted_successfully)
else:
text_message = TextMessage(BotTexts.error)
template_message = TemplateMessage(text_message, buttons_list)
send_message(message=template_message,
peer=user_peer,
step=Step.insert_branch)
dispatcher.finish_conversation(update)
