Telegram-bot-old/handlers/support.py

from aiogram import Router, types
from aiogram.filters import Command
import logging
from instences.config import BASE_URL_FASTAPI
import aiohttp
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from keyboard.keyboards import (
    faq_keyboard,
    sup_keyboard,
    ticket_list_keyboard,
    ticket_keyboard,
)

logger = logging.getLogger(__name__)
router = Router()


class TicketState(StatesGroup):
    subject = State()
    message = State()


async def call_api(method, endpoint, data=None):
    """
    Выполняет HTTP-запрос к FastAPI.
    """
    url = f"{BASE_URL_FASTAPI}{endpoint}"
    logger.info(f"Инициализация запроса: {method} {url} с данными {data}")

    try:
        async with aiohttp.ClientSession() as session:
            async with session.request(method, url, json=data) as response:
                logger.info(
                    f"Получен ответ от {url}: статус {response.status}")

                if response.status in {200, 201}:
                    result = await response.json()
                    logger.debug(f"Ответ JSON: {result}")
                    return result
                if response.status == 404:
                    logger.debug(f"Код {response.status}, возвращаю ничего")
                    return None
                logger.error(
                    f"Ошибка в запросе: статус {response.status}, причина {response.reason}"
                )
                return "ERROR"
    except Exception as e:
        logger.exception(f"Исключение при выполнении запроса к {url}: {e}")
        return "ERROR"


@router.callback_query(lambda callback: callback.data == "faq")
async def faq_callback_handler(callback: types.CallbackQuery):
    """
    Обработчик callback_query с data="faq".
    """
    await callback.message.edit_text(
        "FAQ YOU",
        reply_markup=faq_keyboard(),
    )
    await callback.answer()


@router.message(Command("support"))
async def supp(message: types.Message):
    """
    Меню сапп системы (через команду).
    """
    await message.answer(
        "Добро пожаловать в саппорт систему!",
        reply_markup=sup_keyboard(),
    )


@router.callback_query(lambda callback: callback.data == "main_sup")
async def supp_callback(callback: types.CallbackQuery):
    """
    Меню сапп системы (callback-версия).
    """
    await callback.message.edit_text(
        "Добро пожаловать в саппорт систему!",
        reply_markup=sup_keyboard(),
    )
    await callback.answer()


@router.callback_query(lambda callback: callback.data == "my_tickets")
async def list_tickets_callback(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_data = await call_api("GET", f"/user/{user_id}")
    if not user_data:
        user_data = await call_api(
            "POST",
            "/user/create",
            {"telegram_id": f"{user_id}"},
        )

    tickets = await call_api(
        "GET",
        f"/support/tickets?user_id={user_data['id']}",
    )

    if tickets == "ERROR" or not tickets:
        await callback.message.edit_text(
            "У вас нет тикетов.",
            reply_markup=sup_keyboard(),
        )
        await callback.answer()
        return

    await callback.message.edit_text(
        "Ваши тикеты:",
        reply_markup=ticket_list_keyboard(tickets),
    )
    await callback.answer()


@router.callback_query(lambda callback: callback.data == "make_ticket")
async def start_ticket_creation(callback: types.CallbackQuery, state: FSMContext):
    """
    Начинает процесс создания тикета.
    """
    await callback.message.answer(
        "Введите тему тикета (или нажмите 'Отмена', чтобы выйти):",
        reply_markup=ticket_keyboard(),
    )
    await state.set_state(TicketState.subject)
    await callback.answer()


@router.message()
async def handle_ticket_input(message: types.Message, state: FSMContext):
    """
    Обрабатывает ввод данных для тикета.
    """
    current_state = await state.get_state()
    if current_state == TicketState.subject:
        await state.update_data(subject=message.text)
        await message.answer(
            "Введите описание проблемы:",
            reply_markup=ticket_keyboard(),
        )
        await state.set_state(TicketState.message)

    elif current_state == TicketState.message:
        user_data = await state.get_data()
        subject = user_data.get("subject")
        message_text = message.text
        await create_ticket(message, subject, message_text, state)
        await state.clear()


async def create_ticket(
    message: types.Message,
    subject: str,
    message_text: str,
    state: FSMContext,
):
    """
    Отправляет запрос на создание тикета через FastAPI.
    """
    user_id = message.from_user.id

    try:
        logger.info(
            f"Создание тикета для пользователя {user_id}: "
            f"Тема - {subject}, Сообщение - {message_text}"
        )

        user_data = await call_api("GET", f"/user/{user_id}")
        if not user_data:
            await message.answer("Вы еще не зарегистрированы.")
            return

        ticket_data = await call_api(
            "POST",
            f"/support/tickets?user_id={user_data['id']}",
            data={"subject": subject, "message": message_text},
        )

        if ticket_data != "ERROR":
            await message.answer(
                "✅ Тикет успешно создан!\n"
                f"📌 Тема: {ticket_data['subject']}\n"
                f"📊 Статус: {ticket_data['status']}\n"
                f"📅 Дата создания: {ticket_data['created_at']}"
            )
        else:
            await message.answer("❌ Ошибка создания тикета. Попробуйте позже.")

    except Exception as e:
        logger.exception(
            f"Ошибка при создании тикета для пользователя {user_id}: {e}"
        )
        await message.answer("❌ Произошла ошибка при создании тикета.")


@router.callback_query(lambda callback: callback.data == "cancel_ticket")
async def cancel_ticket_creation(callback: types.CallbackQuery, state: FSMContext):
    """
    Отмена создания тикета.
    """
    await state.clear()
    await callback.message.answer(
        "Создание тикета отменено.",
        reply_markup=types.ReplyKeyboardRemove(),
    )
    await callback.answer()