app/handlers/admin_route.py

from aiogram.types import Message, CallbackQuery
from aiogram import F, Router
from aiogram.fsm.context import FSMContext

import app.keyboards.admin_keyboards as kb
import app.database.requests as rq
from app.states import AdminAddService, AdminAddLeadmagnet, AdminAddTest, AdminStates

admin_router = Router()


@admin_router.message((F.text == 'Вход для админов'))
async def admin_enter(message: Message):
    await message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)


@admin_router.message(F.text == 'Отредактировать каталог услуг')
async def catalog_editor_start(message: Message):
    await message.answer('Сейчас у нас представлены следующие услуги. Нажмите на услугу, чтобы отредактировать ее ',
                         reply_markup=await kb.admin_keyboard_service_catalog())


@admin_router.callback_query(F.data.startswith('change_service_'))
async def edit_service(callback: CallbackQuery):
    await callback.answer('')
    service = await rq.get_service_info(callback.data.split('_')[2])
    await callback.message.answer(f'Услуга {service.service_name} \n\n'
                                  f'Описание: {service.service_description}\n'
                                  f'Цена: {service.service_price} рублей \n\n'
                                  f'Что Вы хотите изменить?',
                                  reply_markup=await kb.admin_change_service(service.service_name))


@admin_router.callback_query(F.data == 'admin_to_main')
async def return_to_main(callback: CallbackQuery):
    await callback.answer('Возвращаемся в меню')
    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)


@admin_router.callback_query(F.data == 'add_service')
async def add_service(callback: CallbackQuery, state: FSMContext):
    await callback.answer('Добавляем услугу')
    await state.set_state(AdminAddService.admin_add_name)
    await callback.message.answer('Введите название новой услуги')


@admin_router.message(AdminAddService.admin_add_name)
async def add_name(message: Message, state: FSMContext):
    await state.update_data(name=message.text)
    await state.set_state(AdminAddService.admin_add_desc)
    await message.answer('Введите описание новой услуги')


@admin_router.message(AdminAddService.admin_add_desc)
async def add_desc(message: Message, state: FSMContext):
    await state.update_data(desc=message.text)
    await state.set_state(AdminAddService.admin_add_price)
    await message.answer('Введите цену услуги в рублях')


@admin_router.message(AdminAddService.admin_add_price)
async def add_price(message: Message, state: FSMContext):
    await state.update_data(price=message.text)
    data = await state.get_data()
    await rq.add_service(data['name'], data['desc'], data['price'])
    await message.answer('Услуга сохранена! Теперь можно изменить ее, выбрав услугу в меню и отредактировав',
                         reply_markup=kb.admin_back)
    await state.clear()


@admin_router.callback_query(F.data.startswith('editservice_'))
async def begin_service_edit(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.set_state(AdminStates.admin_edit_service)
    await state.update_data(service=callback.data.split('_')[2])
    await state.update_data(parameter_changed=callback.data.split("_")[1])
    replace_dict = {'name': 'ое название', 'desc': 'ое описание', 'price': 'ую цену'}
    await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} услуги')


@admin_router.message(AdminStates.admin_edit_service)
async def finish_service_edit(message: Message, state: FSMContext):
    await state.update_data(change=message.text)
    data = await state.get_data()
    await rq.edit_service(data['service'], data['parameter_changed'], data['change'])
    await state.clear()
    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)


@admin_router.callback_query(F.data.startswith('deleteservice_'))
async def confirm_service_deletion(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.set_state(AdminStates.admin_delete_service)
    await state.update_data(name=callback.data.split("_")[1])
    await callback.message.answer(f'Вы уверены, что хотите удалить услугу {callback.data.split("_")[1]}?',
                            reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminStates.admin_delete_service)
async def delete_or_not_delete(message: Message, state: FSMContext):
    if message.text == 'Нет':
        await state.clear()
        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)

    if message.text == 'Да':
        data = await state.get_data()
        await rq.delete_service(data['name'])
        await state.clear()
        await message.answer('Услуга была успешно удалена! Можно вернуться в меню', reply_markup=kb.admin_back)


@admin_router.message(F.text == 'Отредактировать кодовые слова')
async def view_leadmagnets(message: Message):
    await message.answer('Вот текущие лидмагниты. Нажмите на подходящий лидмагнит, чтобы изменить его.',
                         reply_markup=await kb.admin_keyboard_leadmagnets())


@admin_router.callback_query(F.data == 'add_leadmanget')
async def add_leadmagnet(callback: CallbackQuery, state: FSMContext):
    await callback.answer('Добавляем лидмагнит')
    await state.set_state(AdminAddLeadmagnet.admin_set_trigger)
    await callback.message.answer('Введите кодовое слово (пожалуйста, не используйте "_" в названии!)')


@admin_router.message(AdminAddLeadmagnet.admin_set_trigger)
async def add_trigger(message: Message, state: FSMContext):
    await state.update_data(trigger=message.text)
    await state.set_state(AdminAddLeadmagnet.admin_set_content)
    await message.answer('Введите содержание лидмагнита '
                         '(сообщение, которое получит пользователь после отправки кодового слова)')


@admin_router.message(AdminAddLeadmagnet.admin_set_content)
async def add_content(message: Message, state: FSMContext):
    await state.update_data(content=message.text)
    await state.set_state(AdminAddLeadmagnet.admin_set_status)
    await message.answer('Хотите ли Вы сделать данный лидмагнит активным? Активные лидмагниты будут тут же доступны для '
                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminAddLeadmagnet.admin_set_status)
async def set_leadmagnet_status(message: Message, state: FSMContext):
    await state.update_data(status=message.text)
    data = await state.get_data()
    await rq.add_leadmagnet(data['trigger'], data['content'], data['status'])
    await message.answer('Лидмагнит сохранен! Теперь можно отредактировать его, выбрав его в меню',
                         reply_markup=kb.admin_back)
    await state.clear()


@admin_router.callback_query(F.data.startswith('change_leadmagnet_'))
async def edit_leadmagnet(callback: CallbackQuery):
    await callback.answer('')
    leadmagnet = await rq.get_leadmagnet_info(callback.data.split('_')[2])
    await callback.message.answer(f'Триггер: {leadmagnet.trigger} \n\n'
                                  f'Содержание: {leadmagnet.content}\n'
                                  f'Активен? {leadmagnet.active_status}\n\n'
                                  f'Что Вы хотите изменить?',
                                  reply_markup=await kb.admin_change_leadmagnet(leadmagnet.trigger))


@admin_router.callback_query(F.data.startswith('editleadmagnet_'))
async def begin_leadmagnet_edit(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.set_state(AdminStates.admin_edit_leadmagnet)
    await state.update_data(leadmagnet=callback.data.split('_')[2])
    await state.update_data(parameter_changed=callback.data.split("_")[1])
    replace_dict = {'trigger': 'ый триггер', 'content': 'ое содержание'}
    if callback.data.split("_")[1] != 'status':
        await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} лидмагнита')
    elif callback.data.split("_")[1] == 'status':
        await callback.message.answer(f'Должен ли лидмагнит быть активным?', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminStates.admin_edit_leadmagnet)
async def finish_leadmagnet_edit(message: Message, state: FSMContext):
    await state.update_data(change=message.text)
    data = await state.get_data()
    await rq.edit_leadmagnet(data['leadmagnet'], data['parameter_changed'], data['change'])
    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)


@admin_router.callback_query(F.data.startswith('deleteleadmagnet_'))
async def confirm_leadmagnet_deletion(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.set_state(AdminStates.admin_delete_leadmagnet)
    await state.update_data(leadmagnet=callback.data.split("_")[1])
    await callback.message.answer(f'Вы уверены, что хотите удалить лидмагнит {callback.data.split("_")[1]}?',
                            reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminStates.admin_delete_leadmagnet)
async def delete_or_not_delete(message: Message, state: FSMContext):
    if message.text == 'Нет':
        await state.clear()
        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)

    if message.text == 'Да':
        data = await state.get_data()
        await rq.delete_leadmagnet(data['leadmagnet'])
        await state.clear()
        await message.answer('Лидмагнит был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)


@admin_router.message(F.text == 'Отредактировать тесты')
async def test_editor_start(message: Message):
    await message.answer('Сейчас у нас имеются следующие тесты. Нажмите на тест, чтобы отредактировать его ',
                         reply_markup=await kb.admin_keyboard_tests())


@admin_router.callback_query(F.data == 'add_test')
async def add_test(callback: CallbackQuery, state: FSMContext):
    await callback.answer('Добавляем тест')
    await state.set_state(AdminAddTest.admin_set_title)
    await callback.message.answer('Введите название теста (пожалуйста, не используйте "_" в названии!)')


@admin_router.message(AdminAddTest.admin_set_title)
async def add_test_name(message: Message, state: FSMContext):
    await state.update_data(name=message.text)
    await state.set_state(AdminAddTest.admin_set_desc)
    await message.answer('Введите краткое описание теста')


@admin_router.message(AdminAddTest.admin_set_desc)
async def add_test_desc(message: Message, state: FSMContext):
    await state.update_data(desc=message.text)
    await state.set_state(AdminAddTest.admin_set_status)
    await message.answer('Хотите ли Вы сделать данный тест активным? Активные тесты будут тут же доступны для '
                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminAddTest.admin_set_status)
async def add_test_status(message: Message, state: FSMContext):
    await state.update_data(status=message.text)
    await state.set_state(AdminAddTest.admin_set_type)
    await message.answer('Введите тип теста: с баллами или без баллов. Тесты с баллами предполагают вывод разных '
                         'итогов теста в зависимости от количества набранных баллов, тесты без баллов предполагают '
                         'одно и то же сообщение по итогам прохождения', reply_markup=kb.test_type_keyboard)


@admin_router.message(AdminAddTest.admin_set_type)
async def add_test_type(message: Message, state: FSMContext):
    await state.update_data(type=message.text)
    if message.text == 'С баллами':
        await state.update_data(completion_message=None)
        data = await state.get_data()
        await rq.add_test_wo_points(data['name'], data['type'], data['desc'], data['status'],
                                    data['completion_message'])
        await state.set_state(AdminAddTest.admin_set_completion_result_set)
        await message.answer('Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
                             'достижения в следующем формате: \n'
                             '22-24 \n'
                             'Вы получили результат 1!')
    if message.text == 'Без баллов':
        await state.set_state(AdminAddTest.admin_set_completion_result)
        await message.answer('Введите сообщение, показывающееся в конце теста')


@admin_router.message(AdminAddTest.admin_set_completion_result)
async def add_test_completion_wo(message: Message, state: FSMContext):
    await state.update_data(completion_message=message.text)
    data = await state.get_data()
    await rq.add_test_wo_points(data['name'], data['type'], data['desc'], data['status'], data['completion_message'])
    await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
    await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. Например: \n\n'
                         'В каком году Юрий Гагарин полетел в космос?\n>>>\n'
                         '1963 год \n'
                         '1961 год \n'
                         '1968 год')


@admin_router.message(AdminAddTest.admin_add_question_vars_wo_points)
async def add_question_wo(message: Message, state: FSMContext):
    data = await state.get_data()
    await rq.add_question_vars_wo_points(data['name'], message.text)
    await state.set_state(AdminAddTest.admin_end_questions)
    await message.answer('Хотите ли вы добавить еще один вопрос?', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminAddTest.admin_end_questions)
async def do_we_continue_q(message: Message, state: FSMContext):
    if message.text == 'Да':
        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
        await message.answer('Введите вопрос, придерживаясь такого же форматирования, как раньше')
    elif message.text == 'Нет':
        await state.clear()
        await message.answer('Спасибо! Ваш тест сохранен! Можно вернуться в меню!', reply_markup=kb.admin_back)


@admin_router.message(AdminAddTest.admin_set_completion_result_set)
async def add_test_completion_w(message: Message, state: FSMContext):
    data = await state.get_data()
    await rq.add_test_result_w_points(data['name'], message.text)
    await state.set_state(AdminAddTest.admin_end_results)
    await message.answer('Хотите ли вы добавить еще вариант?', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminAddTest.admin_end_results)
async def add_test_completion_choice(message: Message, state: FSMContext):
    if message.text == 'Да':
        await state.set_state(AdminAddTest.admin_set_completion_result_set)
        await message.answer(
            'Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
            'достижения в следующем формате: \n'
            '22-24 \n'
            'Вы получили результат 1!')
    if message.text == 'Нет':
        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
        await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. После каждого ответа '
                             'указывайте количество баллов, начисляемых за этот вариант, через .... Например: \n\n'
                         'В каком году Юрий Гагарин полетел в космос?\n>>>\n'
                         '1963 год...0 \n'
                         '1961 год...2 \n'
                         '1968 год...0')


@admin_router.callback_query(F.data.startswith('change_test_'))
async def view_test(callback: CallbackQuery):
    await callback.answer('')
    test_data = await rq.get_test(callback.data.split('_')[2])
    results_string = ''
    if not test_data['results']:
        results_string += 'Отдельных результатов теста нет'
    else:
        for i in range(len(test_data['results'])):
            results_string += f'Результат теста для количества очков {test_data["results"][i].pointrange}: \n' \
                             f'{test_data["results"][i].result_text} \n'
    questions_string = ''
    if not test_data['questions']:
        questions_string += 'У этого теста нет вопросов'
    else:
        for i in range(len(test_data['questions'])):
            questions_string += f'Вопрос {i+1}: {test_data["questions"][i].question_content} \n' \
                              f'Варианты ответа: {test_data["questions"][i].question_variants} \n'
    await callback.message.answer(f'Название теста: {test_data["test"].test_name}, \n'
                                  f'Тип теста: {test_data["test"].test_type}, \n'
                                  f'Описание теста: {test_data["test"].test_description} \n'
                                  f'Статус активности теста: {test_data["test"].active_status} \n'
                                  f'Сообщение о завершении теста: {test_data["test"].completion_message} \n'
                                  f'Возможные результаты теста: \n{results_string} \n\n'
                                  f'Вопросы теста: \n{questions_string} \n\n'
                                  f'На данный момент подробное редактирование тестов не поддерживается. Если Вы хотите '
                                  f'изменить статус активности теста, нажмите на соответствующую кнопку внизу. Если Вы '
                                  f'хотите внести в тест содержательные изменения, мы рекомендуем удалить тест и '
                                  f'внести его заново!',
                                  reply_markup= await kb.admin_change_test(test_data['test'].test_name))


@admin_router.callback_query(F.data.startswith('edittest_status_'))
async def change_status(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.update_data(name=callback.data.split('_')[2])
    await state.set_state(AdminStates.admin_edit_test_status)
    await callback.message.answer(f'Должен ли тест быть активным?', reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminStates.admin_edit_test_status)
async def set_new_status(message: Message, state: FSMContext):
    data = await state.get_data()
    await rq.change_test_status(data['name'], message.text)
    await message.answer('Изменения были сохранены! Теперь можно вернуться в меню!',
                         reply_markup=kb.admin_back)
    await state.clear()


@admin_router.callback_query(F.data.startswith('deletetest_'))
async def confirm_test_deletion(callback: CallbackQuery, state: FSMContext):
    await callback.answer('')
    await state.set_state(AdminStates.admin_delete_test)
    await state.update_data(name=callback.data.split("_")[1])
    await callback.message.answer(f'Вы уверены, что хотите удалить тест {callback.data.split("_")[1]}?',
                            reply_markup=kb.yes_no_keyboard)


@admin_router.message(AdminStates.admin_delete_test)
async def delete_or_not_delete_test(message: Message, state: FSMContext):
    if message.text == 'Нет':
        await state.clear()
        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)

    if message.text == 'Да':
        data = await state.get_data()
        await rq.delete_test(data['name'])
        await state.clear()
        await message.answer('Тест был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)


@admin_router.message(F.text == 'Вернуться в пользовательский интерфейс')
async def return_as_user(message: Message):
    await message.answer('Спасибо! Удачного Вам дня! Отправьте в чат /start, чтобы вернуться в пользовательский режим '
                         'редактирования!')