smart-bot-factory 1.1.1__py3-none-any.whl

smart_bot_factory/admin/admin_events.py

@@ -0,0 +1,1223 @@
+# Обработчики для создания админских событий
+
+import json
+import logging
+import os
+import shutil
+import uuid
+from datetime import datetime
+
+import pytz
+from aiogram import F, Router
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.types import (CallbackQuery, InlineKeyboardButton,
+                           InlineKeyboardMarkup, Message)
+from aiogram_media_group import media_group_handler
+from dateutil.relativedelta import relativedelta
+
+from ..aiogram_calendar import SimpleCalendar, SimpleCalendarCallback
+from ..core.states import AdminStates
+
+TEMP_DIR = "temp_event_files"
+
+
+def generate_file_id() -> str:
+    """Генерирует уникальный ID для файла"""
+    return f"file_{uuid.uuid4().hex}"
+
+
+def ensure_temp_dir():
+    """Создает временную папку если её нет"""
+    if not os.path.exists(TEMP_DIR):
+        os.makedirs(TEMP_DIR)
+        logger.info(f"📁 Создана временная папка {TEMP_DIR}")
+
+
+async def cleanup_temp_files(state: FSMContext = None):
+    """Очистка временных файлов события"""
+    # Удаляем все файлы из временной папки
+    if os.path.exists(TEMP_DIR):
+        try:
+            shutil.rmtree(TEMP_DIR)
+            logger.info(f"🗑️ Удалена папка {TEMP_DIR}")
+        except Exception as e:
+            logger.error(f"❌ Ошибка при удалении {TEMP_DIR}: {e}")
+
+    # Очищаем информацию о файлах в состоянии
+    if state:
+        try:
+            data = await state.get_data()
+            if "files" in data:
+                data["files"] = []
+                await state.set_data(data)
+        except Exception as e:
+            logger.error(f"❌ Ошибка при очистке состояния: {e}")
+
+
+logger = logging.getLogger(__name__)
+
+# Московская временная зона
+MOSCOW_TZ = pytz.timezone("Europe/Moscow")
+
+# Создаем роутер для админских событий
+admin_events_router = Router()
+
+
+def setup_admin_events_handlers(dp):
+    """Настройка обработчиков админских событий"""
+    dp.include_router(admin_events_router)
+
+
+@admin_events_router.message(Command(commands=["создать_событие", "create_event"]))
+async def create_event_start(message: Message, state: FSMContext):
+    """Начало создания события"""
+    from ..handlers.handlers import get_global_var
+
+    admin_manager = get_global_var("admin_manager")
+
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+
+    await state.set_state(AdminStates.create_event_name)
+
+    await message.answer(
+        "📝 **Введите название события**\n\n"
+        "💡 _По этому названию вы сможете:\n"
+        "• Найти событие в списке\n"
+        "• Отменить его при необходимости_",
+        parse_mode="Markdown",
+    )
+
+
+@admin_events_router.message(AdminStates.create_event_name)
+async def process_event_name(message: Message, state: FSMContext):
+    """Обработка названия события"""
+    from ..handlers.handlers import get_global_var
+
+    event_name = message.text.strip()
+
+    if not event_name:
+        await message.answer("❌ Название не может быть пустым. Попробуйте еще раз:")
+        return
+
+    # Проверяем уникальность названия (только среди активных событий)
+    supabase_client = get_global_var("supabase_client")
+    name_exists = await supabase_client.check_event_name_exists(event_name)
+
+    if name_exists:
+        await message.answer(
+            f"⚠️ **Событие с названием «{event_name}» уже существует и находится в статусе ожидания!**\n\n"
+            f"Пожалуйста, выберите другое название или дождитесь выполнения/отмены существующего события.\n\n"
+            f"💡 _Вы можете использовать это же название после завершения или отмены текущего события._",
+            parse_mode="Markdown",
+        )
+        return
+
+    # Сохраняем название
+    await state.update_data(event_name=event_name)
+
+    # Создаем клавиатуру с выбором времени
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="🚀 Запустить сразу", callback_data="timing:immediate"),
+                InlineKeyboardButton(text="📅 Выбрать время", callback_data="timing:scheduled")
+            ]
+        ]
+    )
+
+    await message.answer(
+        f"✅ Название события: **{event_name}**\n\n"
+        "🕒 Когда запустить событие?",
+        reply_markup=keyboard,
+        parse_mode="Markdown"
+    )
+
+
+@admin_events_router.callback_query(F.data.startswith("timing:"))
+async def process_event_timing(callback_query: CallbackQuery, state: FSMContext):
+    """Обработка выбора времени запуска события"""
+    action = callback_query.data.split(":", 1)[1]
+
+    if action == "immediate":
+        # Устанавливаем текущее время
+        now = datetime.now(MOSCOW_TZ)
+        await state.update_data(
+            event_date=now.strftime("%Y-%m-%d"),
+            event_time=now.strftime("%H:%M"),
+            is_immediate=True
+        )
+        # Переходим к выбору сегмента
+        await state.set_state(AdminStates.create_event_segment)
+
+        # Получаем все доступные сегменты
+        from ..handlers.handlers import get_global_var
+        supabase_client = get_global_var("supabase_client")
+        segments = await supabase_client.get_all_segments()
+
+        # Создаем клавиатуру с сегментами
+        keyboard = []
+        keyboard.append([InlineKeyboardButton(text="📢 Отправить всем", callback_data="segment:all")])
+        if segments:
+            for i in range(0, len(segments), 2):
+                row = [InlineKeyboardButton(text=f"👥 {segments[i]}", callback_data=f"segment:{segments[i]}")]
+                if i + 1 < len(segments):
+                    row.append(InlineKeyboardButton(text=f"👥 {segments[i+1]}", callback_data=f"segment:{segments[i+1]}"))
+                keyboard.append(row)
+
+        markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
+        await callback_query.message.edit_text(
+            f"✅ Время: **Сейчас**\n\n"
+            f"👥 Выберите сегмент пользователей для отправки:\n"
+            f"_(Найдено сегментов: {len(segments)})_",
+            reply_markup=markup,
+            parse_mode="Markdown"
+        )
+
+    else:  # scheduled
+        await state.set_state(AdminStates.create_event_date)
+        # Показываем календарь для выбора даты
+        calendar = SimpleCalendar(locale="ru", today_btn="Сегодня", cancel_btn="Отмена")
+        # Ограничиваем выбор датами от вчера до +12 месяцев (чтобы сегодня был доступен)
+        calendar.set_dates_range(
+            datetime.now() + relativedelta(days=-1),
+            datetime.now() + relativedelta(months=+12),
+        )
+        calendar_markup = await calendar.start_calendar()
+
+        await callback_query.message.edit_text(
+            "📅 Выберите дату отправки:",
+            reply_markup=calendar_markup,
+            parse_mode="Markdown"
+        )
+
+
+@admin_events_router.callback_query(
+    SimpleCalendarCallback.filter(), AdminStates.create_event_date
+)
+async def process_event_date(
+    callback_query: CallbackQuery, callback_data: dict, state: FSMContext
+):
+    """Обработка выбора даты"""
+    calendar = SimpleCalendar(locale="ru", cancel_btn="Отмена", today_btn="Сегодня")
+
+    # Ограничиваем выбор датами от вчера до +12 месяцев (чтобы сегодня был доступен)
+    calendar.set_dates_range(
+        datetime.now() + relativedelta(days=-1),
+        datetime.now() + relativedelta(months=+12),
+    )
+    selected, date = await calendar.process_selection(callback_query, callback_data)
+
+    if selected == "cancel":
+        # Нажата кнопка "Отмена"
+        await state.clear()
+        await callback_query.message.edit_text(
+            "❌ Создание события отменено", parse_mode="Markdown"
+        )
+    elif selected:
+        # Дата выбрана успешно (True или обычный выбор)
+        await state.update_data(event_date=date.strftime("%Y-%m-%d"))
+        await state.set_state(AdminStates.create_event_time)
+
+        await callback_query.message.edit_text(
+            f"✅ Дата: **{date.strftime('%d.%m.%Y')}**\n\n"
+            "⏰ Введите время отправки в формате ЧЧ:ММ\n"
+            "_(Например: 14:30)_",
+            parse_mode="Markdown",
+        )
+    # Если selected is False/None - это навигация по календарю, ничего не делаем
+    # Календарь сам обновится при навигации
+
+
+@admin_events_router.message(AdminStates.create_event_time)
+async def process_event_time(message: Message, state: FSMContext):
+    """Обработка времени события"""
+    time_str = message.text.strip()
+
+    # Валидация формата времени
+    try:
+        datetime.strptime(time_str, "%H:%M").time()
+    except ValueError:
+        await message.answer(
+            "❌ Неверный формат времени. Используйте формат HH:MM\n"
+            "_(Например: 14:30)_",
+            parse_mode="Markdown",
+        )
+        return
+
+    # Сохраняем время
+    await state.update_data(event_time=time_str)
+    await state.set_state(AdminStates.create_event_segment)
+
+    # Получаем все доступные сегменты
+    from ..handlers.handlers import get_global_var
+
+    supabase_client = get_global_var("supabase_client")
+
+    segments = await supabase_client.get_all_segments()
+
+    # Создаем клавиатуру с сегментами
+    keyboard = []
+
+    # Большая кнопка "Отправить всем" на два столбца
+    keyboard.append(
+        [InlineKeyboardButton(text="📢 Отправить всем", callback_data="segment:all")]
+    )
+
+    # Кнопки сегментов (по 2 в ряд)
+    if segments:
+        for i in range(0, len(segments), 2):
+            row = []
+            row.append(
+                InlineKeyboardButton(
+                    text=f"👥 {segments[i]}", callback_data=f"segment:{segments[i]}"
+                )
+            )
+            if i + 1 < len(segments):
+                row.append(
+                    InlineKeyboardButton(
+                        text=f"👥 {segments[i+1]}",
+                        callback_data=f"segment:{segments[i+1]}",
+                    )
+                )
+            keyboard.append(row)
+
+    markup = InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+    await message.answer(
+        f"✅ Время: **{time_str}**\n\n"
+        f"👥 Выберите сегмент пользователей для отправки:\n"
+        f"_(Найдено сегментов: {len(segments)})_",
+        reply_markup=markup,
+        parse_mode="Markdown",
+    )
+
+
+@admin_events_router.callback_query(
+    F.data.startswith("segment:"), AdminStates.create_event_segment
+)
+async def process_event_segment(callback_query: CallbackQuery, state: FSMContext):
+    """Обработка выбора сегмента"""
+    segment_data = callback_query.data.split(":", 1)[1]
+
+    # segment_data = "all" или название сегмента
+    segment_name = None if segment_data == "all" else segment_data
+    segment_display = "Все пользователи" if segment_data == "all" else segment_data
+
+    # Сохраняем сегмент
+    await state.update_data(segment=segment_name, segment_display=segment_display)
+    await state.set_state(AdminStates.create_event_message)
+
+    await callback_query.message.edit_text(
+        f"✅ Сегмент: **{segment_display}**\n\n"
+        "💬 **Введите сообщение для пользователей**\n\n"
+        "📸 _Вы можете прикрепить к сообщению **фото или видео** — они будут отправлены пользователям в том же порядке_\n\n"
+        "📄 _Если нужно добавить **PDF или другие документы**, вы сможете это сделать на следующем шаге_",
+        parse_mode="Markdown",
+    )
+
+
+@admin_events_router.message(
+    AdminStates.create_event_message,
+    F.media_group_id,
+    F.content_type.in_({"photo", "video"}),
+)
+@media_group_handler
+async def handle_album(messages: list[Message], state: FSMContext):
+    """Обработка альбома фотографий/видео"""
+    if not messages:
+        return
+
+    # Берем текст из первого сообщения с подписью
+    event_message = next((msg.caption for msg in messages if msg.caption), None)
+    if not event_message:
+        await messages[0].answer(
+            "❌ **Добавьте подпись к альбому**\n\n"
+            "💡 _Отправьте альбом заново с текстом сообщения в подписи к любой фотографии_",
+            parse_mode="Markdown",
+        )
+        return
+
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
+
+    # Показываем сообщение о начале загрузки
+    await messages[0].answer(
+        "📸 **Загружаю файлы...**\n\n" "💡 _Дождитесь загрузки всех файлов из альбома_",
+        parse_mode="Markdown",
+    )
+
+    # Сохраняем все файлы
+    from ..handlers.handlers import get_global_var
+
+    bot = get_global_var("bot")
+    ensure_temp_dir()
+
+    data = await state.get_data()
+    files = data.get("files", [])
+
+    for i, message in enumerate(messages, 1):
+        try:
+            if message.photo:
+                photo = message.photo[-1]
+                file = await bot.get_file(photo.file_id)
+                file_name = f"photo_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{i}.jpg"
+                file_path = os.path.join(TEMP_DIR, file_name)
+                await bot.download_file(file.file_path, file_path)
+
+                files.append(
+                    {
+                        "type": "photo",
+                        "file_path": file_path,
+                        "name": file_name,
+                        "stage": "with_message",
+                        "has_caption": bool(message.caption),
+                        "order": i,  # Сохраняем порядок в альбоме
+                    }
+                )
+
+            elif message.video:
+                file = await bot.get_file(message.video.file_id)
+                file_name = message.video.file_name or f"{message.video.file_id}.mp4"
+                file_path = os.path.join(TEMP_DIR, file_name)
+                await bot.download_file(file.file_path, file_path)
+
+                files.append(
+                    {
+                        "type": "video",
+                        "file_path": file_path,
+                        "name": file_name,
+                        "stage": "with_message",
+                        "has_caption": bool(message.caption),
+                        "order": i,  # Сохраняем порядок в альбоме
+                    }
+                )
+
+            # Показываем прогресс каждые 5 файлов
+            if i % 5 == 0:
+                await messages[0].answer(
+                    f"📸 Загружено файлов: {i}/{len(messages)}", parse_mode="Markdown"
+                )
+
+        except Exception as e:
+            logger.error(f"❌ Ошибка загрузки файла {i}: {e}")
+            continue
+
+    # Сохраняем файлы
+    await state.update_data(files=files)
+
+    # Переходим к следующему этапу
+    await state.set_state(AdminStates.create_event_files)
+
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="➡️ Продолжить без файлов", callback_data="files:skip"
+                )
+            ]
+        ]
+    )
+
+    await messages[0].answer(
+        f"✅ **Сообщение и {len(files)} файлов сохранены!**\n\n"
+        "📎 **Дополнительные файлы**\n\n"
+        "Теперь вы можете отправить:\n"
+        "📄 PDF документы\n"
+        "📁 Файлы любых форматов\n"
+        "🎥 Дополнительные видео\n"
+        "🖼 Дополнительные фото\n\n"
+        "💡 _Можно отправить несколько файлов по очереди_\n\n"
+        "Или нажмите кнопку, если дополнительных файлов нет:",
+        reply_markup=keyboard,
+        parse_mode="Markdown",
+    )
+
+
+@admin_events_router.message(
+    AdminStates.create_event_message, F.text | F.photo | F.video
+)
+async def process_event_message(message: Message, state: FSMContext):
+    """Обработка одиночного сообщения с текстом/фото/видео"""
+    # Если это часть альбома - пропускаем, его обработает другой handler
+    if message.media_group_id:
+        return
+
+    event_message = message.text or message.caption or ""
+
+    # Проверяем текст
+    if not event_message.strip():
+        await message.answer("❌ Сообщение не может быть пустым. Попробуйте еще раз:")
+        return
+
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
+
+    # Если есть медиа, сохраняем его
+    data = await state.get_data()
+    files = data.get("files", [])
+
+    if message.photo or message.video:
+        import os
+
+        from ..handlers.handlers import get_global_var
+
+        bot = get_global_var("bot")
+
+        # Создаем временную папку
+        ensure_temp_dir()
+
+        if message.photo:
+            # Скачиваем фото
+            photo = message.photo[-1]  # Берем самое большое фото
+            file = await bot.get_file(photo.file_id)
+            file_name = f"photo_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+            file_path = os.path.join(TEMP_DIR, file_name)
+            await bot.download_file(file.file_path, file_path)
+
+            files.append(
+                {
+                    "type": "photo",
+                    "file_path": file_path,
+                    "name": file_name,
+                    "stage": "with_message",
+                    "has_caption": bool(message.caption),
+                }
+            )
+            logger.info(f"Фото сохранено: {file_path} (with_message)")
+
+        elif message.video:
+            # Скачиваем видео
+            file = await bot.get_file(message.video.file_id)
+            file_name = message.video.file_name or f"{message.video.file_id}.mp4"
+            file_path = os.path.join(TEMP_DIR, file_name)
+            await bot.download_file(file.file_path, file_path)
+
+            files.append(
+                {
+                    "type": "video",
+                    "file_path": file_path,
+                    "name": file_name,
+                    "stage": "with_message",
+                    "has_caption": bool(message.caption),
+                }
+            )
+            logger.info(f"Видео сохранено: {file_path} (with_message)")
+
+    await state.update_data(files=files)
+
+    # Переходим к добавлению файлов
+    await state.set_state(AdminStates.create_event_files)
+
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="➡️ Продолжить без файлов", callback_data="files:skip"
+                )
+            ]
+        ]
+    )
+
+    await message.answer(
+        "✅ **Сообщение сохранено!**\n\n"
+        "📎 **Дополнительные файлы**\n\n"
+        "Теперь вы можете отправить:\n"
+        "📄 PDF документы\n"
+        "📁 Файлы любых форматов\n"
+        "🎥 Дополнительные видео\n"
+        "🖼 Дополнительные фото\n\n"
+        "💡 _Можно отправить несколько файлов по очереди_\n\n"
+        "Или нажмите кнопку, если дополнительных файлов нет:",
+        reply_markup=keyboard,
+        parse_mode="Markdown",
+    )
+
+
+@admin_events_router.message(
+    AdminStates.create_event_files, F.document | F.photo | F.video
+)
+async def process_event_files(message: Message, state: FSMContext):
+    """Обработка файлов для события"""
+    import os
+
+    from ..handlers.handlers import get_global_var
+
+    data = await state.get_data()
+    files = data.get("files", [])
+    bot = get_global_var("bot")
+
+    # Создаем временную папку
+    ensure_temp_dir()
+
+    # Скачиваем и добавляем файл в список
+    if message.document:
+        file = await bot.get_file(message.document.file_id)
+        file_path = os.path.join(TEMP_DIR, message.document.file_name)
+        await bot.download_file(file.file_path, file_path)
+
+        files.append(
+            {
+                "type": "document",
+                "file_path": file_path,
+                "name": message.document.file_name,
+                "stage": "after_message",
+            }
+        )
+        logger.info(f"Документ сохранен: {file_path} (after_message)")
+
+    elif message.photo:
+        photo = message.photo[-1]
+        file = await bot.get_file(photo.file_id)
+        file_name = f"photo_{datetime.now().strftime('%H%M%S')}.jpg"
+        file_path = os.path.join(TEMP_DIR, file_name)
+        await bot.download_file(file.file_path, file_path)
+
+        files.append(
+            {
+                "type": "photo",
+                "file_path": file_path,
+                "name": file_name,
+                "stage": "after_message",
+            }
+        )
+        logger.info(f"Фото сохранено: {file_path} (after_message)")
+
+    elif message.video:
+        file = await bot.get_file(message.video.file_id)
+        file_name = (
+            message.video.file_name or f"{message.video.file_id}.mp4"
+        )  # Используем оригинальное имя или file_id
+        file_path = os.path.join(TEMP_DIR, file_name)
+        await bot.download_file(file.file_path, file_path)
+
+        files.append(
+            {
+                "type": "video",
+                "file_path": file_path,
+                "name": file_name,
+                "stage": "after_message",
+            }
+        )
+        logger.info(f"Видео сохранено: {file_path} (after_message)")
+
+    await state.update_data(files=files)
+
+    # Кнопка для завершения добавления файлов
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="✅ Завершить добавление файлов", callback_data="files:done"
+                )
+            ]
+        ]
+    )
+
+    await message.answer(
+        f"✅ Файл добавлен (всего: {len(files)})\n\n"
+        "Отправьте еще файлы или нажмите кнопку для завершения:",
+        reply_markup=keyboard,
+    )
+
+
+@admin_events_router.callback_query(
+    F.data.startswith("files:"), AdminStates.create_event_files
+)
+async def process_files_action(callback_query: CallbackQuery, state: FSMContext):
+    """Обработка действий с файлами"""
+    action = callback_query.data.split(":", 1)[1]
+
+    data = await state.get_data()
+    files = data.get("files", [])
+
+    if action == "skip" and not files:
+        # Если файлов нет и нажали "Продолжить без файлов" - очищаем
+        files = []
+        await state.update_data(files=files)
+    elif action == "skip":
+        # Если файлы уже есть - оставляем их
+        logger.info(f"Продолжаем с {len(files)} существующими файлами")
+
+    # Переход к подтверждению
+    await state.set_state(AdminStates.create_event_confirm)
+
+    # Формируем дату и время для отображения
+    is_immediate = data.get("is_immediate", False)
+    
+    if is_immediate:
+        time_display = "Прямо сейчас 🔥"
+    else:
+        event_date = data.get("event_date")
+        event_time = data.get("event_time")
+        naive_datetime = datetime.strptime(f"{event_date} {event_time}", "%Y-%m-%d %H:%M")
+        moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
+        time_display = f"{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)"
+
+    # Отправляем сообщение с подтверждением
+    summary = (
+        f"📋 **Подтверждение создания события**\n\n"
+        f"📝 Название: **{data.get('event_name')}**\n"
+        f"📅 Время запуска: **{time_display}**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n"
+        f"📎 Файлов: **{len(files)}**\n\n"
+        "Подтвердите создание события:"
+    )
+
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="✅ Создать", callback_data="confirm:yes"),
+                InlineKeyboardButton(text="❌ Отменить", callback_data="confirm:no"),
+            ],
+            [InlineKeyboardButton(text="👁 Предпросмотр", callback_data="preview:show")],
+        ]
+    )
+
+    await callback_query.message.edit_text(
+        summary, reply_markup=keyboard, parse_mode="Markdown"
+    )
+
+
+@admin_events_router.callback_query(
+    F.data == "preview:show", AdminStates.create_event_confirm
+)
+async def show_event_preview(callback_query: CallbackQuery, state: FSMContext):
+    """Показываем предпросмотр сообщения"""
+    from aiogram.types import FSInputFile, InputMediaPhoto, InputMediaVideo
+
+    # Получаем данные
+    data = await state.get_data()
+    files = data.get("files", [])
+    logger.info(f"Предпросмотр: получено {len(files)} файлов из состояния")
+
+    # Удаляем сообщение с кнопкой предпросмотра
+    await callback_query.message.delete()
+
+    # Анализируем файлы
+    files_with_msg = [f for f in files if f.get("stage") == "with_message"]
+    files_after = [f for f in files if f.get("stage") == "after_message"]
+    logger.info(
+        f"Предпросмотр: {len(files_with_msg)} файлов с сообщением, {len(files_after)} дополнительных файлов"
+    )
+
+    # 1. Отправляем сообщение с прикрепленными файлами
+    if files_with_msg:
+        media_group = []
+        first_file = True
+
+        # Сортируем файлы по порядку
+        sorted_files = sorted(files_with_msg, key=lambda x: x.get("order", 0))
+
+        # Добавляем файлы в том порядке, в котором они были загружены
+        for file_info in sorted_files:
+            logger.info(
+                f"Добавляем в медиа-группу: {file_info['type']} файл {file_info['file_path']}"
+            )
+            try:
+                if file_info["type"] == "photo":
+                    media = InputMediaPhoto(
+                        media=FSInputFile(file_info["file_path"]),
+                        caption=data.get("event_message") if first_file else None,
+                        parse_mode="Markdown" if first_file else None,
+                    )
+                    media_group.append(media)
+                    first_file = False
+                elif file_info["type"] == "video":
+                    media = InputMediaVideo(
+                        media=FSInputFile(file_info["file_path"]),
+                        caption=data.get("event_message") if first_file else None,
+                        parse_mode="Markdown" if first_file else None,
+                    )
+                    media_group.append(media)
+                    first_file = False
+                logger.info("✅ Файл успешно добавлен в медиа-группу")
+            except Exception as e:
+                logger.error(f"❌ Ошибка добавления файла в медиа-группу: {e}")
+
+        if media_group:
+            try:
+                from ..handlers.handlers import get_global_var
+
+                bot = get_global_var("bot")
+                await bot.send_media_group(
+                    chat_id=callback_query.message.chat.id, media=media_group
+                )
+                logger.info(f"✅ Отправлена медиа-группа из {len(media_group)} файлов")
+            except Exception as e:
+                logger.error(f"❌ Ошибка отправки медиа-группы: {e}")
+                # Если не удалось отправить группой, отправляем по одному
+                first_file = True
+                for media in media_group:
+                    try:
+                        if isinstance(media, InputMediaPhoto):
+                            await callback_query.message.answer_photo(
+                                photo=media.media,
+                                caption=(
+                                    data.get("event_message") if first_file else None
+                                ),
+                                parse_mode="Markdown" if first_file else None,
+                            )
+                        elif isinstance(media, InputMediaVideo):
+                            await callback_query.message.answer_video(
+                                video=media.media,
+                                caption=(
+                                    data.get("event_message") if first_file else None
+                                ),
+                                parse_mode="Markdown" if first_file else None,
+                            )
+                        first_file = False
+                    except Exception as e2:
+                        logger.error(f"❌ Ошибка отправки отдельного файла: {e2}")
+    else:
+        # Только текст
+        await callback_query.message.answer(
+            data.get("event_message"), parse_mode="Markdown"
+        )
+
+    # 2. Отправляем дополнительные файлы
+    for file_info in files_after:
+        if file_info["type"] == "document":
+            await callback_query.message.answer_document(
+                FSInputFile(file_info["file_path"])
+            )
+        elif file_info["type"] == "photo":
+            await callback_query.message.answer_photo(
+                FSInputFile(file_info["file_path"])
+            )
+        elif file_info["type"] == "video":
+            await callback_query.message.answer_video(
+                FSInputFile(file_info["file_path"])
+            )
+
+    # 3. Отправляем сообщение с подтверждением (такое же как было)
+    is_immediate = data.get("is_immediate", False)
+    
+    if is_immediate:
+        time_display = "Прямо сейчас 🔥"
+    else:
+        event_date = data.get("event_date")
+        event_time = data.get("event_time")
+        naive_datetime = datetime.strptime(f"{event_date} {event_time}", "%Y-%m-%d %H:%M")
+        moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
+        time_display = f"{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)"
+
+    summary = (
+        f"📋 **Подтверждение создания события**\n\n"
+        f"📝 Название: **{data.get('event_name')}**\n"
+        f"📅 Время запуска: **{time_display}**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n"
+        f"📎 Файлов: **{len(files)}**\n\n"
+        "Подтвердите создание события:"
+    )
+
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="✅ Создать", callback_data="confirm:yes"),
+                InlineKeyboardButton(text="❌ Отменить", callback_data="confirm:no"),
+            ],
+            [InlineKeyboardButton(text="👁 Предпросмотр", callback_data="preview:show")],
+        ]
+    )
+
+    await callback_query.message.answer(
+        summary, reply_markup=keyboard, parse_mode="Markdown"
+    )
+
+
+@admin_events_router.callback_query(
+    F.data.startswith("confirm:"), AdminStates.create_event_confirm
+)
+async def process_event_confirmation(callback_query: CallbackQuery, state: FSMContext):
+    """Обработка подтверждения создания события"""
+    action = callback_query.data.split(":", 1)[1]
+
+    if action == "no":
+        # Очищаем временные файлы
+        await cleanup_temp_files(state)
+        # Очищаем состояние
+        await state.clear()
+        await callback_query.message.edit_text(
+            "❌ Создание события отменено", parse_mode="Markdown"
+        )
+        return
+
+    # Получаем данные события
+    data = await state.get_data()
+    is_immediate = data.get("is_immediate", False)
+    files = data.get("files", [])
+
+    from ..handlers.handlers import get_global_var
+    from aiogram.types import FSInputFile, InputMediaPhoto, InputMediaVideo
+    bot = get_global_var("bot")
+    supabase_client = get_global_var("supabase_client")
+
+    if is_immediate:
+        # Для немедленной отправки - сразу рассылаем сообщения
+        try:
+            # Показываем сообщение о начале рассылки
+            await callback_query.message.edit_text(
+                "📤 **Выполняется рассылка...**",
+                parse_mode="Markdown"
+            )
+
+            # Получаем список пользователей для рассылки
+            segment = data.get("segment")
+            users = await supabase_client.get_users_by_segment(segment)
+            total_users = len(users)
+            sent_count = 0
+            failed_count = 0
+            
+            # Преобразуем результат в нужный формат
+            user_ids = [user["telegram_id"] for user in users]  # используем telegram_id вместо user_id
+
+            # Группируем файлы по стадиям
+            files_with_msg = [f for f in files if f.get("stage") == "with_message"]
+            files_after = [f for f in files if f.get("stage") == "after_message"]
+
+            # Отправляем сообщения каждому пользователю
+            for user in users:
+                user_id = user["telegram_id"]
+                try:
+                    # 1. Отправляем основное сообщение с медиа (если есть)
+                    if files_with_msg:
+                        sorted_files = sorted(files_with_msg, key=lambda x: x.get("order", 0))
+
+                        # Если только один файл - отправляем как обычный файл с caption
+                        if len(sorted_files) == 1:
+                            file_info = sorted_files[0]
+                            if file_info["type"] == "photo":
+                                await bot.send_photo(
+                                    chat_id=user_id,
+                                    photo=FSInputFile(file_info["file_path"]),
+                                    caption=data.get("event_message"),
+                                    parse_mode="Markdown"
+                                )
+                            elif file_info["type"] == "video":
+                                await bot.send_video(
+                                    chat_id=user_id,
+                                    video=FSInputFile(file_info["file_path"]),
+                                    caption=data.get("event_message"),
+                                    parse_mode="Markdown"
+                                )
+                        else:
+                            # Если несколько файлов - используем media_group
+                            media_group = []
+                            first_file = True
+
+                            for file_info in sorted_files:
+                                if file_info["type"] == "photo":
+                                    media = InputMediaPhoto(
+                                        media=FSInputFile(file_info["file_path"]),
+                                        caption=data.get("event_message") if first_file else None,
+                                        parse_mode="Markdown" if first_file else None,
+                                    )
+                                    media_group.append(media)
+                                elif file_info["type"] == "video":
+                                    media = InputMediaVideo(
+                                        media=FSInputFile(file_info["file_path"]),
+                                        caption=data.get("event_message") if first_file else None,
+                                        parse_mode="Markdown" if first_file else None,
+                                    )
+                                    media_group.append(media)
+                                first_file = False
+
+                            if media_group:
+                                await bot.send_media_group(chat_id=user_id, media=media_group)
+                    else:
+                        # Только текст
+                        await bot.send_message(
+                            chat_id=user_id,
+                            text=data.get("event_message"),
+                            parse_mode="Markdown"
+                        )
+
+                    # 2. Отправляем дополнительные файлы
+                    for file_info in files_after:
+                        if file_info["type"] == "document":
+                            await bot.send_document(
+                                chat_id=user_id,
+                                document=FSInputFile(file_info["file_path"])
+                            )
+                        elif file_info["type"] == "photo":
+                            await bot.send_photo(
+                                chat_id=user_id,
+                                photo=FSInputFile(file_info["file_path"])
+                            )
+                        elif file_info["type"] == "video":
+                            await bot.send_video(
+                                chat_id=user_id,
+                                video=FSInputFile(file_info["file_path"])
+                            )
+
+                    sent_count += 1
+
+                except Exception as e:
+                    logger.error(f"❌ Ошибка отправки пользователю {user_id}: {e}")
+                    failed_count += 1
+
+            # Сохраняем событие в БД
+            event_status = "success" if failed_count == 0 else "partial_success"
+            await supabase_client.save_admin_event(
+                event_name=data.get("event_name"),
+                event_data={
+                    "segment": segment,
+                    "total_users": total_users,
+                    "sent_success": sent_count,
+                    "failed_count": failed_count,
+                    "type": "immediate_event",
+                    "admin_id": callback_query.from_user.id,
+                    "execution_status": event_status,
+                    "completed_at": datetime.now(pytz.UTC).isoformat()
+                },
+                scheduled_datetime=datetime.now(pytz.UTC)
+            )
+
+            # Показываем итоговое сообщение
+            status = "✅" if failed_count == 0 else "⚠️"
+            
+            await callback_query.message.edit_text(
+                f"{status} **Админское событие выполнено**\n\n"
+                f"📝 Название: **{data.get('event_name')}**\n"
+                f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
+                f"📊 Результат:\n"
+                f"• Доставлено: **{sent_count}**\n"
+                f"• Не доставлено: **{failed_count}**",
+                parse_mode="Markdown"
+            )
+
+        except Exception as e:
+            logger.error(f"❌ Ошибка массовой рассылки: {e}")
+            
+            # Сохраняем ошибку события в БД
+            await supabase_client.save_admin_event(
+                event_name=data.get("event_name"),
+                event_data={
+                    "segment": segment,
+                    "error": str(e),
+                    "type": "immediate_event",
+                    "admin_id": callback_query.from_user.id,
+                    "execution_status": "error",
+                    "completed_at": datetime.now(pytz.UTC).isoformat()
+                },
+                scheduled_datetime=datetime.now(pytz.UTC)
+            )
+
+            await callback_query.message.edit_text(
+                f"❌ **Ошибка выполнения админского события**\n\n"
+                f"📝 Название: **{data.get('event_name')}**\n"
+                f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
+                f"Произошла техническая ошибка. Попробуйте позже.",
+                parse_mode="Markdown"
+            )
+
+    else:
+        # Для отложенного события - стандартная логика
+        try:
+            # Формируем datetime для планирования
+            event_date = data.get("event_date")
+            event_time = data.get("event_time")
+            naive_datetime = datetime.strptime(f"{event_date} {event_time}", "%Y-%m-%d %H:%M")
+            moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
+            utc_datetime = moscow_datetime.astimezone(pytz.UTC)
+
+            # Создаем событие
+            event = await supabase_client.save_admin_event(
+                event_name=data.get("event_name"),
+                event_data={
+                    "segment": data.get("segment"),
+                    "message": data.get("event_message"),
+                    "files": [],
+                },
+                scheduled_datetime=utc_datetime,
+            )
+            event_id = event["id"]
+
+            # Загружаем файлы в Storage
+            uploaded_files = []
+            for file_info in files:
+                try:
+                    with open(file_info["file_path"], "rb") as f:
+                        file_bytes = f.read()
+                    file_id = generate_file_id()
+                    storage_info = await supabase_client.upload_event_file(
+                        event_id=event_id,
+                        file_data=file_bytes,
+                        original_name=file_info["name"],
+                        file_id=file_id,
+                    )
+                    uploaded_files.append({
+                        "type": file_info["type"],
+                        "storage_path": storage_info["storage_path"],
+                        "original_name": file_info["name"],
+                        "stage": file_info["stage"],
+                        "has_caption": file_info.get("has_caption", False),
+                        "order": file_info.get("order", 0),
+                    })
+                except Exception as e:
+                    logger.error(f"❌ Ошибка загрузки файла {file_info['name']}: {e}")
+                    await supabase_client.delete_event_files(event_id)
+                    raise
+
+            # Обновляем событие с информацией о файлах
+            event_data = {
+                "segment": data.get("segment"),
+                "message": data.get("event_message"),
+                "files": uploaded_files,
+            }
+            supabase_client.client.table("scheduled_events").update(
+                {"event_data": json.dumps(event_data, ensure_ascii=False)}
+            ).eq("id", event_id).execute()
+
+        except Exception as e:
+            logger.error(f"❌ Ошибка создания отложенного события: {e}")
+            raise
+    is_immediate = data.get("is_immediate", False)
+    
+    if is_immediate:
+        time_display = "🔥 Прямо сейчас"
+    else:
+        time_display = f"{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)"
+
+    await callback_query.message.edit_text(
+        f"✅ **Событие успешно создано!**\n\n"
+        f"📝 Название: `{data.get('event_name')}`\n"
+        f"📅 Время запуска: **{time_display}**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
+        f"💡 _Нажмите на название для копирования_",
+        parse_mode="Markdown",
+    )
+
+    # Очищаем временные файлы и состояние
+    await cleanup_temp_files(state)
+    await state.set_state(AdminStates.admin_mode)
+
+
+@admin_events_router.message(Command(commands=["список_событий", "list_events"]))
+async def list_events_command(message: Message, state: FSMContext):
+    """Просмотр всех запланированных событий"""
+    from ..handlers.handlers import get_global_var
+
+    admin_manager = get_global_var("admin_manager")
+    supabase_client = get_global_var("supabase_client")
+
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+
+    try:
+        # Получаем все pending события (незавершенные и неотмененные)
+        events = await supabase_client.get_admin_events(status="pending")
+
+        if not events:
+            await message.answer(
+                "📋 **Нет активных событий**\n\n"
+                "Используйте `/create_event` для создания нового события",
+                parse_mode="Markdown",
+            )
+            return
+
+        # Формируем список событий в красивом формате
+        text_parts = [f"📋 **Активные события** ({len(events)})\n"]
+
+        for idx, event in enumerate(events, 1):
+            event_name = event["event_type"]
+
+            # Конвертируем UTC в московское время для отображения
+            utc_time = datetime.fromisoformat(
+                event["scheduled_at"].replace("Z", "+00:00")
+            )
+            moscow_time = utc_time.astimezone(MOSCOW_TZ)
+
+            # Красивый формат с эмодзи и структурой
+            text_parts.append(
+                f"📌 **{idx}.** `{event_name}`\n"
+                f"    🕐 {moscow_time.strftime('%d.%m.%Y в %H:%M')} МСК\n"
+            )
+
+        text_parts.append(
+            "━━━━━━━━━━━━━━━━━━━━\n"
+            "💡 _Нажмите на название для копирования_\n"
+            "🗑️ Удалить: `/delete_event название`"
+        )
+
+        await message.answer("\n".join(text_parts), parse_mode="Markdown")
+
+    except Exception as e:
+        logger.error(f"Ошибка получения событий: {e}")
+        await message.answer(
+            f"❌ Ошибка получения событий:\n`{str(e)}`", parse_mode="Markdown"
+        )
+
+
+@admin_events_router.message(Command(commands=["удалить_событие", "delete_event"]))
+async def delete_event_command(message: Message, state: FSMContext):
+    """Удаление события по названию"""
+    from ..handlers.handlers import get_global_var
+
+    admin_manager = get_global_var("admin_manager")
+    supabase_client = get_global_var("supabase_client")
+
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+
+    # Парсим название из команды
+    parts = message.text.split(maxsplit=1)
+    if len(parts) < 2:
+        await message.answer(
+            "❌ Укажите название события:\n"
+            "`/delete_event название`\n\n"
+            "Используйте /list_events для просмотра списка событий",
+            parse_mode="Markdown",
+        )
+        return
+
+    event_name = parts[1].strip()
+
+    try:
+        # Сначала получаем событие чтобы узнать его ID
+        response = (
+            supabase_client.client.table("scheduled_events")
+            .select("id")
+            .eq("event_type", event_name)
+            .eq("event_category", "admin_event")
+            .eq("status", "pending")
+            .execute()
+        )
+
+        if response.data:
+            event_id = response.data[0]["id"]
+
+            # Удаляем файлы из Storage
+            try:
+                await supabase_client.delete_event_files(event_id)
+                logger.info(
+                    f"🗑️ Удалены файлы события '{event_name}' (ID: {event_id}) из Storage"
+                )
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления файлов события из Storage: {e}")
+
+            # Отмечаем событие как отмененное
+            supabase_client.client.table("scheduled_events").update(
+                {"status": "cancelled"}
+            ).eq("id", event_id).execute()
+
+            await message.answer(
+                f"✅ Событие `{event_name}` успешно отменено\n"
+                f"_(файлы удалены из Storage)_",
+                parse_mode="Markdown",
+            )
+            logger.info(f"Отменено событие '{event_name}' (ID: {event_id})")
+        else:
+            await message.answer(
+                f"❌ Активное событие с названием `{event_name}` не найдено\n\n"
+                f"Используйте /list_events для просмотра списка активных событий",
+                parse_mode="Markdown",
+            )
+
+    except Exception as e:
+        logger.error(f"Ошибка удаления события: {e}")
+        await message.answer(
+            f"❌ Ошибка удаления события:\n`{str(e)}`", parse_mode="Markdown"
+        )