def handle_delivery(update, context):
query = update.callback_query
chat_id = query.message.chat_id
print(query.message.text)
if query.data.split(' ')[1] == 'delivery':
button, delivery, lon, lat = query.data.split(' ')
customer_cart = moltin.get_cart(chat_id)
restaurant_address = location.get_delivery_raidus(lon,
lat)['restaurant']
cart_description = get_cart_details(customer_cart)
restaurant_chat_id = moltin.get_restaurant_chat_id(restaurant_address)
context.bot.send_message(chat_id=restaurant_chat_id,
text=cart_description)
context.bot.send_location(chat_id=restaurant_chat_id,
latitude=lat,
longitude=lon)
context.job_queue.run_once(send_reminder, 5, context=chat_id)
return "HANDLE_PAYMENT"
else:
button, pickup, lon, lat = query.data.split(' ')
restaurant_address = location.get_delivery_raidus(lon,
lat)['restaurant']
query.message.reply_text(
f'Спасибо за покупку, ожидаем вас в течение часа, по адрессу:\n{restaurant_address}'
)
def handle_cart(bot, update):
chat_id, data = get_chat_id_and_reply(update)
cart, buttons = moltin.get_cart(chat_id)
message = update.callback_query.message
if data == 'cart':
delete_item_buttons = [[
InlineKeyboardButton(text=b[0], callback_data=b[1])
] for b in buttons]
keyboard = [
*delete_item_buttons,
[InlineKeyboardButton('В меню', callback_data='menu')],
[InlineKeyboardButton('Оплатить', callback_data='waiting_mail')]
]
reply_markup = InlineKeyboardMarkup(keyboard)
bot.send_message(chat_id=chat_id, text=cart, reply_markup=reply_markup)
bot.delete_message(chat_id=message.chat_id,
message_id=message.message_id)
return 'HANDLE_CART'
if data == 'menu':
return handle_start(bot, update)
elif data == 'waiting_mail':
email_request = 'Для оформления заказа пришлите, пожалуйста, почту'
bot.edit_message_text(chat_id=chat_id,
text=email_request,
message_id=message.message_id)
return 'WAITING_MAIL'
else:
moltin.delete_item_from_cart(chat_id, data)
update.callback_query.data = 'cart'
return handle_cart(bot, update)
def send_invoice(bot, update):
query = update.callback_query
chat_id = query.message.chat_id
cart = get_cart(chat_id)
title = f'Заказ {chat_id}'
description = 'Пицца'
payload = 'Pizza_payment'
provider_token = TELEGRAM_PAYMENT_TOKEN
start_parameter = TELEGRAM_PAYMENT_PARAMETER
currency = 'RUB'
prices = [
LabeledPrice(f'{pizza["name"]}, {pizza["quantity"]} шт.',
pizza['unit_price'] * INVOICE_PRICE_MULTIPLIER)
for pizza in cart['products'] if pizza["name"] != DELIVERY_ITEM_NAME
]
delivery = next(item for item in cart['products']
if item['name'] == DELIVERY_ITEM_NAME)
prices.append(
LabeledPrice(delivery['name'],
delivery['unit_price'] * INVOICE_PRICE_MULTIPLIER))
bot.sendInvoice(chat_id, title, description, payload, provider_token,
start_parameter, currency, prices)
return 'WAITING PAYMENT'
def add_delivery_order(bot, update, delivery_price, customer_location):
query = update.callback_query
chat_id = query.message.chat_id
message_id = query.message.message_id
longitude, latitude = customer_location
customer_location = {
'longitude': longitude,
'latitude': latitude,
'delivery-price': delivery_price,
'customer_id': chat_id,
}
add_customer_location(customer_location)
add_delivery_to_cart(chat_id, delivery_price)
cart = get_cart(chat_id)
cart_text = get_cart_items_text(cart)
customer_text = f'Доставим пицу в течении часа после оплаты.\n\n{cart_text}'
keyboard = [[InlineKeyboardButton('💳 Оплатить', callback_data='payment')]]
reply_markup = InlineKeyboardMarkup(keyboard)
bot.edit_message_text(text=customer_text,
chat_id=chat_id,
message_id=message_id,
reply_markup=reply_markup)
return 'WAITING PAYMENT'
def send_cart(bot, update):
query = update.callback_query
chat_id = query.message.chat_id
cart = get_cart(chat_id)
keyboard = [[InlineKeyboardButton('В меню', callback_data='menu')]]
if cart['products']:
text_rows = [
'{0}\n{1}\n{2} per kg\n{3} kg in cart for {4}'.format(
product['name'], product['description'], product['unit_price'],
product['quantity'], product['total_price'])
for product in cart['products']
]
text_rows.append(f'Total: {cart["total_price"]}')
text = '\n\n'.join(text_rows)
keyboard.extend([[
InlineKeyboardButton(f' Убрать {product["name"]}',
callback_data=product['id'])
] for product in cart['products']])
keyboard.append(
[InlineKeyboardButton('Оформить заказ', callback_data='checkout')])
else:
text = 'You don\'t have any items in your cart.'
reply_markup = InlineKeyboardMarkup(keyboard)
bot.edit_message_text(text=text,
chat_id=chat_id,
message_id=query.message.message_id,
reply_markup=reply_markup)
logger.debug(f'Cart sent')
return 'HANDLE_CART'
def handle_menu(bot, update, job_queue):
message_id, chat_id, query_data = get_query_data(update)
if query_data == 'goto_cart':
cart, products, total = get_cart(chat_id)
display_cart(bot, cart, products, total, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CART'
display_description(bot, query_data, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_DESCRIPTION'
def handle_description(bot, update):
call_back = update.callback_query.data
chat_id = str(update.callback_query.message.chat_id)
_id, name, quantity = call_back.split(',')
moltin.get_cart(moltin.cart_url, chat_id, headers)
payload_cart = {
"data": {
"id": _id,
"type": "cart_item",
"quantity": int(quantity)
}
}
headers.update({'Content-Type': 'application/json'})
moltin.add_product_to_cart(moltin.operation_cart_url, headers,
payload_cart, chat_id)
bot.answer_callback_query(callback_query_id=update.callback_query.id,
text=f"product was added to cart.",
show_alert=False)
return 'HANDLE_DESCRIPTION'
def create_basket_buttons(user_id=None):
user_basket = moltin.get_cart(user_id)
keyboard = []
for product in user_basket:
pr_name = product['name']
pr_id = product['cart_id']
keyboard.append(
[InlineKeyboardButton(f'Удалить {pr_name}', callback_data=pr_id)])
keyboard.append(
[InlineKeyboardButton("Назад в меню", callback_data='back_to_menu')])
keyboard.append(
[InlineKeyboardButton("Оформить заказ", callback_data='sell')])
return InlineKeyboardMarkup(keyboard)
def send_order_to_courier(bot, update):
customer_id = update.message.chat_id
customer_location = get_customer_location(str(customer_id))
pizzeria_id, _ = get_nearest_pizzeria(customer_location)
courier_id = get_pizzeria(pizzeria_id)['courier-id']
cart = get_cart(customer_id)
cart_text = get_cart_items_text(cart)
courier_text = f'Заказ {customer_id}\n\n{cart_text}\n\nЗАКАЗ ОПЛАЧЕН'
bot.send_message(chat_id=courier_id, text=courier_text)
longitude, latitude = customer_location
bot.send_location(chat_id=courier_id,
latitude=latitude,
longitude=longitude)
def create_basket_buttons(user_id=None):
user_basket = moltin.get_cart(user_id)
keyboard = VkKeyboard()
for product in user_basket:
pr_name = product["name"]
cart_id = product["cart_id"]
keyboard.add_button(f"Удалить {pr_name}", payload=json.dumps(cart_id))
keyboard.add_line()
keyboard.add_button("Назад в меню",
payload=json.dumps("back"),
color=VkKeyboardColor.POSITIVE)
keyboard.add_line()
keyboard.add_button("Оформить заказ",
payload=json.dumps("order"),
color=VkKeyboardColor.NEGATIVE)
return keyboard.get_keyboard()
def handle_checkout_payment(bot, update, job_queue):
message_id, chat_id, query_data = get_query_data(update)
cart, products, total = get_cart(chat_id)
if query_data == 'goto_payment_cash':
bot.send_message(text=f'Договорились! Напоминаем, что вы заказали:\n{products}\nСумма:{total} руб.', chat_id=chat_id)
elif query_data == 'goto_payment_card':
title = 'Оплата заказа'
description = f'{products}\nСумма:{total} руб.'
payload = PAYMENT_PAYLOAD
provider_token = os.getenv('PAYMENT_TOKEN_TRANZZO')
start_parameter = 'test-payment'
currency = 'RUB'
price = total
prices = [LabeledPrice('Test', price * 100)]
bot.sendInvoice(chat_id, title, description, payload, provider_token,
start_parameter, currency, prices)
bot.delete_message(chat_id=chat_id, message_id=message_id)
def handle_basket(headers, params, recipient_id, message):
if message == 'back_to_menu':
menu_elements = create_all_menu()
request_content = {
'recipient': {
'id': recipient_id
},
'message': {
'attachment': {
'type': 'template',
'payload': {
'template_type': 'generic',
'image_aspect_ratio': 'square',
'elements': menu_elements,
},
}
},
}
response = requests.post(url=FB_API,
params=params,
headers=headers,
json=request_content)
response.raise_for_status()
return 'HANDLE_MENU'
elif message == 'order':
send_message(
recipient_id,
message=
'Где вы находитесь? Введите адрес для выбора ближайшей пиццерии.',
)
return 'HANDLE_ORDER'
elif message.split()[0] == 'add':
product_id = message.split()[1]
moltin.put_in_cart(recipient_id, product_id, 1)
send_message(recipient_id, message='Добавили еще 1 пиццу.')
create_basket_menu(recipient_id)
return 'HANDLE_BASKET'
elif message.split()[0] == 'remove':
product_id = message.split()[1]
user_cart = moltin.get_cart(recipient_id)
product_id_in_cart = next(product['cart_id'] for product in user_cart
if product['product_id'] == product_id)
moltin.delete_item_in_cart(recipient_id, product_id_in_cart)
send_message(recipient_id, message='Удалили из корзины.')
create_basket_menu(recipient_id)
return 'HANDLE_BASKET'
def handle_description(bot, update, job_queue):
message_id, chat_id, query_data = get_query_data(update)
if query_data == 'goto_menu':
display_menu(bot, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_MENU'
elif query_data == 'goto_cart':
cart, products, total = get_cart(chat_id)
display_cart(bot, cart, products, total, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CART'
else:
product_id = query_data
cart, products, total = add_to_cart(chat_id, product_id)
display_cart(bot, cart, products, total, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CART'
def handle_cart(bot, update, job_queue):
message_id, chat_id, query_data = get_query_data(update)
if query_data == 'goto_menu':
display_menu(bot, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_MENU'
elif query_data == 'goto_checkout_geo':
bot.send_message(text=f'ОФОРМЛЕНИЕ ЗАКАЗА:\nДля доставки вашей пиццы'
' отправьте нам геолокацию или адрес текстом.',
chat_id=chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CHECKOUT_GEO'
else:
delete_from_cart(chat_id, query_data)
cart, products, total = get_cart(chat_id)
display_cart(bot, cart, products, total, chat_id)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CART'
def handle_description(update, context):
query = update.callback_query
reference = query.message.chat_id
if query.data.split(' ')[1] == 'cart':
final_amount = moltin.get_cart_total_sum(reference)
cart_descriptions = moltin.get_cart(reference)
reply_markup = get_keyboard(cart_descriptions)
cart_details = get_cart_details(cart_descriptions)
query.message.reply_text(
f'{cart_details}\n\nСумма заказа: {final_amount["formatted"]}$',
reply_markup=reply_markup)
context.bot.delete_message(chat_id=query.message.chat_id,
message_id=query.message.message_id)
return "HANDLE_CART"
else:
button, product_id, quantity = query.data.split(' ')
moltin.add_product_to_cart(reference, product_id, quantity)
update.callback_query.answer('Добавленно в корзину')
def handle_checkout_receipt(bot, update, job_queue):
global database
message_id, chat_id, query_data = get_query_data(update)
cart, products, total = get_cart(chat_id)
customer_id = database.get(f'{chat_id}_id_customer').decode('utf-8')
latitude, longitude, nearest_shop_id = get_customer(customer_id)
address, courier_telegram_id = get_address(nearest_shop_id)
keyboard = [[InlineKeyboardButton('ПО КАРТЕ', callback_data='goto_payment_card')],
[InlineKeyboardButton('НАЛИЧНЫМИ', callback_data='goto_payment_cash')]]
reply_markup = InlineKeyboardMarkup(keyboard)
if query_data == 'goto_checkout_delivery':
bot.send_location(latitude=latitude, longitude=longitude, chat_id=courier_telegram_id)
bot.send_message(text=f'Заказ:\n{products}\nСумма:{total} руб.',
chat_id=courier_telegram_id)
#job_queue.run_once(add_reminder, REMINDER_TIME, context=chat_id)
bot.send_message(text=f'Заказ принят и скоро будет доставлен! Как будете оплачивать?', chat_id=chat_id, reply_markup=reply_markup)
elif query_data == 'goto_checkout_pickup':
bot.send_message(text=f'Отлично! Ждем вас по адресу: {address}. Как будете оплачивать?', chat_id=chat_id, reply_markup=reply_markup)
bot.delete_message(chat_id=chat_id, message_id=message_id)
return 'HANDLE_CHECKOUT_PAYMENT'
def handle_cart(update, context):
query = update.callback_query
if query.data.split(' ')[1] == 'pay':
query.message.reply_text(
"Пришлите пожалуйста свою геолокацию или напишите ваш район")
return "HANDLE_WAITING"
else:
product_id = query.data.split(' ')[1]
reference = query.message.chat_id
moltin.delete_product_from_cart(reference, product_id)
final_amount = moltin.get_cart_total_sum(reference)
cart_descriptions = moltin.get_cart(reference)
reply_markup = get_keyboard(cart_descriptions)
cart_details = get_cart_details(cart_descriptions)
query.message.reply_text(
f'{cart_details}\n\nСумма заказа: {final_amount["formatted"]}$',
reply_markup=reply_markup)
context.bot.delete_message(chat_id=query.message.chat_id,
message_id=query.message.message_id)
return "HANDLE_CART"
def handle_menu(update, context):
query = update.callback_query
reference = query.message.chat_id
if query.data.split(' ')[1] == 'cart':
final_amount = moltin.get_cart_total_sum(reference)
cart_descriptions = moltin.get_cart(reference)
reply_markup = get_keyboard(cart_descriptions)
cart_details = get_cart_details(cart_descriptions)
query.message.reply_text(
f'{cart_details}\n\nСумма заказа: {final_amount["formatted"]}',
reply_markup=reply_markup)
context.bot.delete_message(chat_id=query.message.chat_id,
message_id=query.message.message_id)
return "HANDLE_CART"
else:
product_id = query.data.split(' ')[1]
description = moltin.get_product_description(product_id)
image_url = moltin.get_image_url(product_id)
keyboard = [[
InlineKeyboardButton('1 шт.',
callback_data='button ' + product_id + ' 1'),
InlineKeyboardButton('2 шт.',
callback_data='button ' + product_id + ' 2'),
InlineKeyboardButton('5 шт.',
callback_data='button ' + product_id + ' 5')
], [InlineKeyboardButton('Назад', callback_data='back')
], [InlineKeyboardButton('Корзина', callback_data='button cart')]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_photo(
chat_id=query.message.chat_id,
caption=description,
photo=image_url,
reply_markup=reply_markup,
)
context.bot.delete_message(chat_id=query.message.chat_id,
message_id=query.message.message_id)
return 'HANDLE_DESCRIPTION'
def send_cart(bot, update):
query = update.callback_query
chat_id = query.message.chat_id
cart = get_cart(chat_id)
text = get_cart_items_text(cart)
keyboard = [[InlineKeyboardButton('В меню', callback_data='menu')]]
if text:
keyboard.extend([[
InlineKeyboardButton(f' Убрать {product["name"]}',
callback_data=product['id'])
] for product in cart['products']])
keyboard.append(
[InlineKeyboardButton('Оформить заказ', callback_data='checkout')])
else:
text = 'Ваша корзина пуста'
reply_markup = InlineKeyboardMarkup(keyboard)
bot.edit_message_text(text=text,
chat_id=chat_id,
message_id=query.message.message_id,
reply_markup=reply_markup)
return 'HANDLE_CART'
def update_cart(bot, update, access_token):
query = update.callback_query
button_menu = [InlineKeyboardButton("Меню", callback_data="Меню")]
button_pay = [InlineKeyboardButton("Оплатить", callback_data="Оплатить")]
cart_items = moltin.get_cart_items(access_token, query.message.chat_id)
cart = moltin.get_cart(access_token, query.message.chat_id)
total_price = cart['data']['meta']['display_price']['with_tax']['formatted']
products_in_cart = []
keyboard = []
for product_in_cart in cart_items['data']:
product_name = product_in_cart['name']
description = product_in_cart['description']
price = product_in_cart['meta']['display_price']['with_tax']['unit']['formatted']
quantity = product_in_cart['quantity']
all_price = product_in_cart['meta']['display_price']['with_tax']['value']['formatted']
button = [InlineKeyboardButton(f'Убрать из корзины {product_name}', callback_data=product_in_cart['id'])]
keyboard.append(button)
products_in_cart.append(f'{product_name}\n'
f'{description}\n'
f'{price}per kg\n'
f'{quantity}kg in cart for {all_price}\n\n')
keyboard.append(button_menu)
keyboard.append(button_pay)
reply_markup = InlineKeyboardMarkup(keyboard)
cart_text = ''.join(products_in_cart)
telegram_bot.del_old_message(bot, update)
bot.send_message(chat_id=query.message.chat_id, text=f'{cart_text}\n'
f'*Всего на сумму:\n'
f'{total_price}*', reply_markup=reply_markup,
parse_mode=ParseMode.MARKDOWN)
def create_basket_menu(headers, params, recipient_id):
total = moltin.get_total(recipient_id)
user_cart = moltin.get_cart(recipient_id)
menu_elements = [{
'title':
f'Ваш заказ на сумму: {total}',
'image_url':
BASKET_IMG_URL,
'buttons': [
{
'type': 'postback',
'title': 'Оформить заказ',
'payload': 'order'
},
{
'type': 'postback',
'title': 'Назад в меню',
'payload': 'back_to_menu',
},
],
}]
for product in user_cart:
product_id = product['product_id']
pizza_data = json.loads(
db.get(product_id)) or moltin.get_by_id(product)
pizza_name = pizza_data['name']
pizza_desc = pizza_data['description']
pizza_price = pizza_data['meta']['display_price']['with_tax'][
'formatted']
image_id = pizza_data['relationships']['main_image']['data']['id']
image_url = db.get(image_id) or moltin.get_picture(image_id)
data = {
'title':
f'{pizza_name}, {pizza_price}',
'subtitle':
pizza_desc,
'image_url':
image_url,
'buttons': [
{
'type': 'postback',
'title': 'Добавить еще одну',
'payload': f'add {product_id}',
},
{
'type': 'postback',
'title': 'Удалить',
'payload': f'remove {product_id}',
},
],
}
menu_elements.append(data)
request_content = {
'recipient': {
'id': recipient_id
},
'message': {
'attachment': {
'type': 'template',
'payload': {
'template_type': 'generic',
'image_aspect_ratio': 'square',
'elements': menu_elements,
},
}
},
}
response = requests.post(url=FB_API,
params=params,
headers=headers,
json=request_content)
response.raise_for_status()
def add_delivery_to_cart(cart_id, delivery_price):
cart = get_cart(cart_id)
if not is_delivery_in_cart(cart):
add_cart_custom_item(cart_id, DELIVERY_ITEM_NAME, delivery_price)
