main.py - master - AlexF88/FFB

main.py
300 строк12 KB
Alex
Fix delet message products ib cart
17 июл 2026, 12:37
17 июл 2026, 12:37d4a129a
import asyncio
import logging
from email import message
from os import getenv

from aiogram.client.default import DefaultBotProperties

from keyboards import reply_kb
from proxy import proxy

from aiogram import Bot, Dispatcher, F
from aiogram.filters import CommandStart
from aiogram.types import Message, CallbackQuery, FSInputFile, InputMediaPhoto, LabeledPrice
from aiogram.exceptions import TelegramBadRequest
from dotenv import load_dotenv

from keyboards.inline_kb import *
from keyboards.reply_kb import *
from database.db_utils import *
from utils.caption import *


load_dotenv()
TOKEN = getenv('TOKEN')
PAYME=getenv('PYMENT')
PYMT=getenv('PYMT')
MANAGER=getenv('MANAGER')
dp = Dispatcher()
bot = Bot(TOKEN, default=DefaultBotProperties(parse_mode='HTML'), session=proxy())


@dp.message(CommandStart())
async def command_start(message: Message):
    '''Старт бота'''
    await message.answer(f'Здравствуйте, <b>{message.from_user.full_name}!</b> \n'
                         f'Вас приветствует бот доставки')
    await start_register_user(message)


async def start_register_user(message: Message):
    '''Первая регистрация пользователя с проверко на существование'''
    chat_id = message.chat.id
    full_name = message.from_user.full_name
    if db_register_user(full_name, chat_id):
        await message.answer(text='Авторизация прошла успешно')
        await show_main_menu(message)
    else:
        await message.answer(text='Для связи с Вами нужен Ваш контакт',
                             reply_markup=share_phone_button())


@dp.message(F.contact)
async def update_user_info_finish_register(message: Message):
    '''Обновление данных пользователя его контактом'''
    chat_id = message.chat.id
    phone = message.contact.phone_number
    dp_update_user(chat_id, phone)
    if db_creat_user_cart(chat_id):
        await message.answer(text='Регистрация прошла успешно')

    await show_main_menu(message)


async def show_main_menu(message: Message):
    '''Сделатьт заказ, История, Корзинка, Настройка'''
    await message.answer(text='Выбирите направление',
                         reply_markup=generate_main_menu())


@dp.message(F.text == 'Сделать заказ')
async def make_order(message: Message):
    '''Реакция на кнопку Сделать заказ'''
    chat_id = message.chat.id
    await bot.send_message(chat_id=chat_id,
                           text='Погнали',
                           reply_markup=back_to_main_menu())
    await message.answer(text='Выберите категорию',
                         reply_markup=generate_category_menu(chat_id))


@dp.message(F.text.regexp(r'^Г[а-я]+ [а-я]{4}'))
async def return_to_main_menu(message:Message):
    '''Реакция на кнопку Главное меню'''
    try:
        await bot.delete_message(chat_id=message.chat.id,
                                 message_id=message.message_id)
    except TelegramBadRequest as e:
        if "message to delete not found" not in e.message:
            raise
    await show_main_menu(message)


@dp.callback_query(F.data.regexp(r'category_[1-9]'))
async def show_product_button(call: CallbackQuery):
    '''Показ всех продуктов выбранной категории'''
    chat_id = call.message.chat.id
    message_id = call.message.message_id
    category_id = int(call.data.split('_')[-1])
    await bot.edit_message_text(text='Выберите продукт',
                                chat_id=chat_id,
                                message_id=message_id,
                                reply_markup=show_product_by_catrgory(category_id))

@dp.callback_query(F.data == 'return_to_category')
async def return_to_category_button(call: CallbackQuery):
    '''Возврат к выбору категории продукта'''
    chat_id = call.message.chat.id
    message_id = call.message.message_id
    await bot.edit_message_text(chat_id=chat_id,
                                 message_id=message_id,
                                 text='Выберите категорию',
                                 reply_markup=generate_category_menu(chat_id))


@dp.callback_query(F.data.contains('product_'))
async def show_product_detail(call:CallbackQuery):
    '''Показ выбранного продукта с его информацией'''
    chat_id = call.message.chat.id
    message_id = call.message.message_id
    product_id = int(call.data.split('_')[-1])
    product = db_get_product_by_id(product_id)
    await bot.delete_message(chat_id=chat_id,
                             message_id=message_id)
    if user_cart_id := db_get_user_cart(chat_id):
        db_update_to_cart(price=product.price,
                          cart_id=user_cart_id.id)

        text = text_for_caption(product.product_name, product.description, product.price)

        await bot.send_message(chat_id=chat_id,
                               text='Выберите модификатор',
                               reply_markup=back_arrow_button())

        await bot.send_photo(chat_id=chat_id,
                             photo=FSInputFile(path=product.image),
                             caption=text,
                             reply_markup=generate_constructor_button())
    else:
        await bot.send_message(chat_id=chat_id,
                               text='Нет вашего контакта',
                               reply_markup = share_phone_button())


@dp.message(F.text == 'Назад')
async def return_to_category_menu(message:Message):
    '''Назад к выбору продукта по категории'''
    await bot.delete_message(message.chat.id, message.message_id - 1)
    await make_order(message)


@dp.callback_query(F.data.regexp(r'action [+-]'))
async def constructor_change(call:CallbackQuery):
    '''Логика конструктора'''
    chat_id = call.from_user.id
    message_id = call.message.message_id
    action = call.data.split()[-1]
    product_name = call.message.caption.split('\n')[0]
    user_cart = db_get_user_cart(chat_id)
    product = db_get_product_by_name(product_name)
    product_price = product.price

    match action:
        case '+':
            user_cart.total_products += 1
            product_price = product_price * user_cart.total_products
            db_update_to_cart(price=product_price,
                              quantity=user_cart.total_products,
                              cart_id=user_cart.id)
        case '-':
            if user_cart.total_products < 2 :
                await call.answer('Меньше одного нельзя')
            else:
                user_cart.total_products -= 1
            product_price = product_price * user_cart.total_products
            db_update_to_cart(price=product_price,
                              quantity=user_cart.total_products,
                              cart_id=user_cart.id)

    text = text_for_caption(name=product_name,
                            description=product.description,
                            price=product_price)

    try:
        await bot.edit_message_media(chat_id=chat_id,
                                     message_id=message_id,
                                     media=InputMediaPhoto(media=FSInputFile(path=product.image),
                                                           caption=text),
                                    reply_markup=generate_constructor_button(quantity=user_cart.total_products))
    except TelegramBadRequest:
        pass


@dp.callback_query(F.data == 'put into cart')
async def put_into_cart(call: CallbackQuery):
    '''Добавление товара в корзину'''
    chat_id = call.from_user.id
    product_name = call.message.caption.split('\n')[0]
    cart = db_get_user_cart(chat_id)
    try:
        await bot.delete_message(chat_id=chat_id,
                                 message_id=call.message.message_id)
    except TelegramBadRequest as e:
        if "message to delete not found" in e.message:
            pass  # сообщение уже удалено — просто игнорируем
        else:
            raise  # если ошибка другая — пробрасываем дальше, чтобы не скрыть баг

    if db_ins_or_update_finally_cart(cart_id=cart.id,
                                     product_name=product_name,
                                     total_products=cart.total_products,
                                     total_price=cart.total_price):
        await bot.send_message(chat_id=chat_id,
                               text='Продукт успешно добавлен')
    else:
        await bot.send_message(chat_id=chat_id,
                               text='Количество успешно изменено')
    await return_to_main_menu(call.message)


@dp.callback_query(F.data == 'Ваша корзина')
async def show_finally_cart(call:CallbackQuery):
    '''Показ содержимого корзины'''
    message_id = call.message.message_id
    chat_id = call.from_user.id
    await bot.delete_message(chat_id=chat_id,
                             message_id=call.message.message_id)

    context = counting_product_from_cart(chat_id, 'Ваша корзина')
    if context:
        count, text, *_ = context
        await bot.send_message(chat_id=chat_id,
                               text=text,
                               reply_markup=generate_delete_product(chat_id))

    else:
        await bot.send_message(chat_id=chat_id,
                               text='Ваша корзина пуста')
        await make_order(call.message)


@dp.callback_query(F.data.regexp(r'delete_\d+'))
async def delete_cart_product(call: CallbackQuery):
    '''Реауция на кнопку с иксом'''
    chat_id = call.from_user.id
    finally_id = int(call.data.split('_')[-1])
    db_delete_product(finally_id)
    await bot.answer_callback_query(callback_query_id=call.id,
                                    text='Продукт удален')
    await show_finally_cart(call)


@dp.callback_query(F.data == 'order_pay')
async def create_order(call:CallbackQuery):
    '''Оплата продукта'''
    chat_id = call.from_user.id
    message_id = call.message.message_id

    await bot.delete_message(chat_id=chat_id,
                             message_id=message_id)

    count, text, total_price, cart_id = counting_product_from_cart(chat_id=chat_id,
                                                                   user_text='Итоговый список для оплаты')
    text += '\nДоставка по городу 1000 р.'
    text = text.replace('<b>', '').replace('<b>', '')
    await bot.send_invoice(chat_id=chat_id,
                          title='Ваш заказ',
                          description=text,
                          payload='bot-defined invoice payload',
                          # provider_token=PAYME,
                          provider_token=PYMT,
                          # currency='UZS',
                          currency='RUB',
                          prices=[
                              LabeledPrice(label='Общая стоимость',
                                           amount=int(total_price * 100)),
                              LabeledPrice(label='Доставка',
                                           amount=100000)
                          ])
    await bot.send_message(chat_id=chat_id,
                           text='Заказ оплачен')
    await sending_report_to_manager(chat_id, text)
    clear_funally_cart(cart_id)


async def sending_report_to_manager(chat_id: int, text: str):
    '''Отправка сообщения в чат группу'''
    user = db_get_user_info(chat_id)
    text += f'\n\nИмя заказчика: {user.name}\nКонтакт: {user.phone}\n\n'

    await bot.send_message(chat_id=MANAGER,
                           text=text)


async def main():
    logging.basicConfig(level=logging.INFO)
    await dp.start_polling(bot)


if __name__ == '__main__':
    asyncio.run(main())