bot.py

import asyncio
import os
import sqlite3
from aiogram import Bot, Dispatcher, types, F
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.types import (
    ReplyKeyboardMarkup, KeyboardButton,
    InlineKeyboardMarkup, InlineKeyboardButton,
    ReplyKeyboardRemove
)
from PIL import Image, ImageDraw, ImageFont
import qrcode
from openpyxl import Workbook, load_workbook

# Конфиги
TOKEN = 'YOUR_TOKEN'
ADMIN_ID = your_id
EXCEL_FILE = 'tickets.xlsx'
DB_FILE = 'bot_database.db'
TICKET_TEMPLATE = 'ticket.png'
FONT_PATH = 'YOUR_FONT.ttf'

bot = Bot(token=TOKEN)
dp = Dispatcher()



# БАЗА ДАННЫХ И ЭКСЕЛЬ
def init_db():
    conn = sqlite3.connect(DB_FILE)
    cur = conn.cursor()
    cur.execute('''CREATE TABLE IF NOT EXISTS users
                   (user_id INTEGER PRIMARY KEY, full_name TEXT, grade TEXT, letter TEXT, username TEXT, status TEXT)''')
    conn.commit()
    conn.close()

    if not os.path.exists(EXCEL_FILE):
        wb = Workbook()
        ws = wb.active
        ws.append(["ID", "ФИ", "Класс", "Буква", "Посещение", "Username"])
        wb.save(EXCEL_FILE)

def add_to_excel(user_id, name, grade, letter, username):
    wb = load_workbook(EXCEL_FILE)
    ws = wb.active
    row_num = ws.max_row
    ws.append([row_num, name, grade, letter, " ", f"@{username}"])
    wb.save(EXCEL_FILE)
    return row_num

# СОСТОЯНИЯ
class Registration(StatesGroup):
    grade = State()
    letter = State()
    full_name = State()
    confirm = State()
    waiting_for_track = State()

# БЫСТРЫЕ ОТВЕТЫ КЛАВИАТУРЫ
def get_grade_kb():
    buttons = [[KeyboardButton(text="9"), KeyboardButton(text="10"), KeyboardButton(text="11")]]
    return ReplyKeyboardMarkup(keyboard=buttons, resize_keyboard=True)

# ПРОВЕРКА letter
def get_letter_kb(grade):
    btns = [KeyboardButton(text="А"), KeyboardButton(text="Б")]
    if grade == "9":
        btns.append(KeyboardButton(text="В"))
    return ReplyKeyboardMarkup(keyboard=[btns], resize_keyboard=True)

def get_confirm_kb():
    buttons = [[KeyboardButton(text="Да, отправить!"), KeyboardButton(text="Начать заново")]]
    return ReplyKeyboardMarkup(keyboard=buttons, resize_keyboard=True, one_time_keyboard=True)

# Здесь был баг в том, что быстрые ответы не пропадали ⬆️
# Предложение сввоего трека
def get_track_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(text="🎵 Предложить трек", callback_data="suggest_track")]
    ])

# ГЕНЕРАЦИЯ БИЛЕТА
def draw_wrapped_text(draw, text, x, y, font, max_width, fill):
    words = text.split()
    lines = []
    current_line = ""
    for word in words:
        test_line = current_line + word + " "
        if font.getlength(test_line) <= max_width:
            current_line = test_line
        else:
            lines.append(current_line.strip())
            current_line = word + " "
    lines.append(current_line.strip())
    current_y = y
    for line in lines:
        draw.text((x, current_y), line, font=font, fill=fill)
        bbox = font.getbbox(line)
        line_height = bbox[3] - bbox[1]
        current_y += line_height + 10
    return current_y

def create_ticket(name, grade, letter, ticket_id):
    img = Image.open(TICKET_TEMPLATE)
    draw = ImageDraw.Draw(img)

    try:
        font_name = ImageFont.truetype(FONT_PATH, 75) # <- Размер шрифта
        font_class = ImageFont.truetype(FONT_PATH, 65) # <- Размер шрифта
    except Exception as e:
        print(f"Ошибка загрузки шрифта: {e}!!!!!11")
        font_name = font_class = ImageFont.load_default()

    last_y = draw_wrapped_text(draw, name, 70, 340, font_name, 960, fill="yellow") # <- ФИ ученика
    class_text = f"{grade}{letter} класс"  # <- Фор экзампл: "10Б класс"
    draw.text((70, last_y + 10), class_text, font=font_class, fill="white")

    # Генерация QR КОДА
    qr_data = f"ID: {ticket_id:03d}" # Закодированная инфа (Пр.: ID: 003)
    # КОНФИГУРАЦИЯ QR
    qr = qrcode.QRCode(box_size=10, border=2)
    qr.add_data(qr_data)
    qr.make(fit=True)
    qr_img = qr.make_image(fill_color="black", back_color="white")
    qr_size = 250
    qr_img = qr_img.resize((qr_size, qr_size))
    qr_x = 825 - (qr_size // 2)
    qr_y = 925 - (qr_size // 2)
    img.paste(qr_img, (qr_x, qr_y))

    ticket_path = f"ticket_{ticket_id}.png"
    img.save(ticket_path)
    return ticket_path



# ХЕНДЛЕРЫ
    #ПРОВЕРКА ПОЛЬЗОВАТЕЛЯ (Нельзя отправлять несколько заявок с 1 акка!)
@dp.message(Command("start"))
async def start_cmd(message: types.Message, state: FSMContext):
    await state.clear()
    conn = sqlite3.connect(DB_FILE)
    cur = conn.cursor()
    cur.execute("SELECT * FROM users WHERE user_id = ?", (message.from_user.id,))
    if cur.fetchone():
        await message.answer("Вы уже отправляли заявку!")
        return conn.close()
    conn.close()
    # 1
    if os.path.exists("welcome.png"):
        await message.answer_photo(photo=types.FSInputFile("welcome.png"), caption="Привет! Давай оформим твой билет.")
    else:
        await message.answer("Привет! Давай оформим твой билет на дискотеку.")

    await message.answer("Из какого ты класса?", reply_markup=get_grade_kb())
    await state.set_state(Registration.grade)

    #2
@dp.message(Registration.grade)
async def process_grade(message: types.Message, state: FSMContext):
    if message.text not in ["9", "10", "11"]:
        await message.answer("Пожалуйста, выбери класс с помощью кнопок.")
        return
    await state.update_data(grade=message.text)

    await message.answer("Назови свою букву класса", reply_markup=get_letter_kb(message.text))
    await state.set_state(Registration.letter)

    #3
@dp.message(Registration.letter)
async def process_letter(message: types.Message, state: FSMContext):
    data = await state.get_data()
    grade = data.get('grade')
    allowed_letters = ["А", "Б", "В"] if grade == "9" else ["А", "Б"]

    if message.text not in allowed_letters:
        await message.answer(f"Пожалуйста, выбери букву из списка: {', '.join(allowed_letters)}")
        return
    await state.update_data(letter=message.text)
    #4
    await message.answer("Напиши свое имя и фамилию (Пример: Иван Иванов)", reply_markup=ReplyKeyboardRemove())
    await state.set_state(Registration.full_name)

@dp.message(Registration.full_name)
async def process_name(message: types.Message, state: FSMContext):
    if len(message.text) > 75:
        await message.answer(f"Слишком длинное имя. Пожалуйста, сократи до 75 символов.")
        return

    #5 - ФИНАЛ сообщение
    await state.update_data(full_name=message.text)
    data = await state.get_data()
    text = (f"Всё готово! Вот ваша анкета:\n"
            f"ФИ: {data['full_name']}\n"
            f"Класс: {data['grade']}{data['letter']}\n\n"
            f"При нажатии на кнопку \"Да, отправить!\", вы соглашаетесь с правилами проведения мероприятия: "
            f"ВАША_ССЫЛКА\n\n"
            f"Все верно?")
    await message.answer(text, reply_markup=get_confirm_kb())
    await state.set_state(Registration.confirm)

@dp.message(Registration.confirm, F.text == "Да, отправить!")
async def send_to_admin(message: types.Message, state: FSMContext):
    data = await state.get_data()
    user_id = message.from_user.id
    username = message.from_user.username or str(user_id)
    conn = sqlite3.connect(DB_FILE) # <- SQLite база данных
    cur = conn.cursor()
    try:
        cur.execute("INSERT INTO users VALUES (?, ?, ?, ?, ?, ?)",
                    (user_id, data['full_name'], data['grade'], data['letter'], username, "pending"))
        conn.commit()
    except:
        pass
    conn.close()

    # Быстрые кнопки для админа
    kb_admin = InlineKeyboardMarkup(inline_keyboard=[
        [InlineKeyboardButton(text="Принять ✅", callback_data=f"accept_{user_id}"),
         InlineKeyboardButton(text="Отказать ❌", callback_data=f"reject_{user_id}")]
    ])

    # Отправка message админу
    await bot.send_message(
        ADMIN_ID,
        f"Пользователь @{username} хочет билет\nФИ: {data['full_name']}\nКласс: {data['grade']}{data['letter']}",
        reply_markup=kb_admin
    )

    await message.answer("Ваша заявка на рассмотрении.", reply_markup=ReplyKeyboardRemove())

    #5.1 (доп. сообщение)
    await message.answer(
        "Хочешь предложить свой трек на дискотеку? Нажми на кнопку ниже.",
        reply_markup=get_track_kb()
    )
    await state.clear()

    # Если отказ, то сбрасываем анкету, меняем state
@dp.message(Registration.confirm, F.text == "Начать заново")
async def restart(message: types.Message, state: FSMContext):
    await message.answer("Сбрасываю анкету...", reply_markup=ReplyKeyboardRemove())
    await start_cmd(message, state)



# ОТДЕЛЬНАЯ ЛОГИКА ДЛЯ ПРЕДЛОЖЕННЫХ ТРЕКОВ

@dp.callback_query(F.data == "suggest_track")
async def track_request(callback: types.CallbackQuery, state: FSMContext):
    await callback.message.answer(
        "Введите название вашей композиции (можно несколько)\n"
        "Пример: ___"
    )
    await state.set_state(Registration.waiting_for_track)
    await callback.answer()

@dp.message(Registration.waiting_for_track)
async def process_track_suggestion(message: types.Message, state: FSMContext):
    track_name = message.text
    await bot.send_message(
        ADMIN_ID,
        f"🎵 ПРЕДЛОЖЕНИЕ ТРЕКА от @{message.from_user.username or message.from_user.id}:\n{track_name}"
    )
    await message.answer("Спасибо! Мы передали твое предложение организаторам. Если песня подходит, она обязательно прозвучит!")
    await state.clear()



# ДЕЙСТВИЯ АДМИНА
# 1. Если accept
@dp.callback_query(F.data.startswith("accept_"))
async def accept_user(callback: types.CallbackQuery):
    user_id = int(callback.data.split("_")[1])
    conn = sqlite3.connect(DB_FILE)
    cur = conn.cursor()
    cur.execute("SELECT full_name, grade, letter, username FROM users WHERE user_id = ?", (user_id,))
    user_data = cur.fetchone()

    if user_data:
        name, grade, letter, username = user_data
        ticket_id = add_to_excel(user_id, name, grade, letter, username)
        ticket_file = create_ticket(name, grade, letter, ticket_id)

        try:
            await bot.send_photo(
                user_id,
                photo=types.FSInputFile(ticket_file),
                caption=f"Поздравляем! Твой билет одобрен. Предъяви его на входе."
            )
        except Exception as e:
            print(f"Не удалось отправить билет: {e}")

        if os.path.exists(ticket_file):
            os.remove(ticket_file)

        await callback.message.edit_text(callback.message.text + "\n\n✅ ОДОБРЕНО")
    conn.close()

# 2. Если reject
@dp.callback_query(F.data.startswith("reject_"))
async def reject_user(callback: types.CallbackQuery):
    user_id = int(callback.data.split("_")[1])
    try:
        await bot.send_message(user_id, "К сожалению, ваша заявка отклонена организаторами.")
    except:
        pass

    conn = sqlite3.connect(DB_FILE)
    cur = conn.cursor()
    cur.execute("DELETE FROM users WHERE user_id = ?", (user_id,))
    conn.commit()
    conn.close()
    await callback.message.edit_text(callback.message.text + "\n\n❌ ОТКЛОНЕНО")

# Для логов в терминале
async def main():
    init_db()
    print("Бот запущен...")
    await dp.start_polling(bot)

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("Бот выключен")