smart-bot-factory 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

smart_bot_factory/admin/admin_events.py

@@ -1,14 +1,51 @@
 # Обработчики для создания админских событий
 
 import logging
-from datetime import datetime, time, timezone
+import os
+import shutil
+from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from aiogram import Router, F
 from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
 from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram_media_group import media_group_handler
 from ..aiogram_calendar import SimpleCalendar, SimpleCalendarCallback
 import pytz
+import uuid
+import json
+
+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__)
 
@@ -37,9 +74,10 @@ async def create_event_start(message: Message, state: FSMContext):
     await state.set_state(AdminStates.create_event_name)
     
     await message.answer(
-        "📝 **Создание нового события**\n\n"
-        "Введите название события:\n"
-        "_(Название поможет вам идентифицировать событие для редактирования или удаления)_",
+        "📝 **Введите название события**\n\n"
+        "💡 _По этому названию вы сможете:\n"
+        "• Найти событие в списке\n"
+        "• Отменить его при необходимости_",
         parse_mode='Markdown'
     )
 
@@ -194,174 +232,196 @@ async def process_event_segment(callback_query: CallbackQuery, state: FSMContext
         "📄 _Если нужно добавить **PDF или другие документы**, вы сможете это сделать на следующем шаге_",
         parse_mode='Markdown'
     )
-
-@admin_events_router.message(AdminStates.create_event_message)
-async def process_event_message(message: Message, state: FSMContext):
-    """Обработка сообщения для пользователей"""
-    event_message = message.text or message.caption or ""
     
-    if not event_message.strip():
-        await message.answer("❌ Сообщение не может быть пустым. Попробуйте еще раз:")
+@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
     
-    # Сохраняем сообщение и media_group_id если есть
-    data_to_update = {'event_message': event_message}
-    
-    # Если это часть альбома (media group), сохраняем ID группы
-    if message.media_group_id:
-        data_to_update['media_group_id'] = message.media_group_id
-        data_to_update['waiting_for_album'] = True
-        logger.info(f"Обнаружен альбом с ID: {message.media_group_id}")
+    # Берем текст из первого сообщения с подписью
+    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(**data_to_update)
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
     
-    # Если есть фото в сообщении, сохраняем его
-    files = []
-    if message.photo:
-        import os
-        from ..handlers.handlers import get_global_var
-        bot = get_global_var('bot')
-        
-        # Создаем временную папку если её нет
-        temp_dir = "temp_event_files"
-        os.makedirs(temp_dir, exist_ok=True)
-        
-        # Скачиваем фото
-        photo = message.photo[-1]  # Берем самое большое фото
-        file = await bot.get_file(photo.file_id)
-        file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
-        await bot.download_file(file.file_path, file_path)
-        
-        files.append({
-            'type': 'photo',
-            'file_path': file_path,
-            'name': f"{photo.file_id}.jpg",
-            'stage': 'with_message',
-            'has_caption': bool(message.caption)  # Первое фото с текстом
-        })
-        logger.info(f"Фото сохранено: {file_path} (with_message)")
-    
-    await state.update_data(files=files)
+    # Показываем сообщение о начале загрузки
+    await messages[0].answer(
+        "📸 **Загружаю файлы...**\n\n"
+        "💡 _Дождитесь загрузки всех файлов из альбома_",
+        parse_mode='Markdown'
+    )
     
-    # Если это НЕ альбом, переходим к добавлению файлов
-    if not message.media_group_id:
-        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'
-        )
-    # Если альбом - ничего не делаем, остальные фото обработаются отдельным handler
-
-@admin_events_router.message(AdminStates.create_event_message, F.photo)
-async def process_album_photos(message: Message, state: FSMContext):
-    """Обработка остальных фото из альбома"""
-    import os
+    # Сохраняем все файлы
     from ..handlers.handlers import get_global_var
+    bot = get_global_var('bot')
+    ensure_temp_dir()
     
     data = await state.get_data()
+    files = data.get('files', [])
     
-    # Проверяем что это альбом и мы ждем остальные фото
-    if not data.get('waiting_for_album'):
-        return
+    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
     
-    # Проверяем что это тот же альбом
-    if message.media_group_id != data.get('media_group_id'):
-        return
+    # Сохраняем файлы
+    await state.update_data(files=files)
     
-    bot = get_global_var('bot')
-    files = data.get('files', [])
+    # Переходим к следующему этапу
+    await state.set_state(AdminStates.create_event_files)
     
-    # Создаем временную папку если её нет
-    temp_dir = "temp_event_files"
-    os.makedirs(temp_dir, exist_ok=True)
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="➡️ Продолжить без файлов", callback_data="files:skip")]
+    ])
     
-    # Скачиваем фото
-    photo = message.photo[-1]
-    file = await bot.get_file(photo.file_id)
-    file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
-    await bot.download_file(file.file_path, file_path)
+    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
     
-    files.append({
-        'type': 'photo',
-        'file_path': file_path,
-        'name': f"{photo.file_id}.jpg",
-        'stage': 'with_message',
-        'has_caption': False  # Остальные фото без текста
-    })
+    event_message = message.text or message.caption or ""
     
-    await state.update_data(files=files)
-    logger.info(f"Фото из альбома сохранено: {file_path} (with_message, всего: {len(files)})")
+    # Проверяем текст
+    if not event_message.strip():
+        await message.answer("❌ Сообщение не может быть пустым. Попробуйте еще раз:")
+        return
     
-    # Автоматически переходим к следующему этапу через 2 секунды после последнего фото
-    import asyncio
-    await asyncio.sleep(2)
+    # Сохраняем сообщение
+    await state.update_data(event_message=event_message)
     
-    # Проверяем что все еще ждем альбом (не было новых фото)
+    # Если есть медиа, сохраняем его
     data = await state.get_data()
-    if data.get('waiting_for_album') and data.get('media_group_id') == message.media_group_id:
-        # Все фото получены, переходим к добавлению доп файлов
-        await state.update_data(waiting_for_album=False)
-        await state.set_state(AdminStates.create_event_files)
+    files = data.get('files', [])
+    
+    if message.photo or message.video:
+        import os
+        from ..handlers.handlers import get_global_var
+        bot = get_global_var('bot')
         
-        files_count = len(data.get('files', []))
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="➡️ Продолжить", callback_data="files:skip")]
-        ])
+        # Создаем временную папку
+        ensure_temp_dir()
         
-        await message.answer(
-            f"✅ **Сообщение и {files_count} фото сохранены!**\n\n"
-            "📎 **Дополнительные файлы**\n\n"
-            "Теперь вы можете отправить:\n"
-            "📄 PDF документы\n"
-            "📁 Файлы любых форматов\n"
-            "🎥 Дополнительные видео\n\n"
-            "💡 _Можно отправить несколько файлов по очереди_\n\n"
-            "Или нажмите кнопку, если дополнительных файлов нет:",
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-
-@admin_events_router.callback_query(F.data == "album:done", AdminStates.create_event_message)
-async def finish_album_collection(callback_query: CallbackQuery, state: FSMContext):
-    """Завершение сбора фото из альбома"""
-    await state.update_data(waiting_for_album=False)
-    await state.set_state(AdminStates.create_event_files)
+        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)")
     
-    data = await state.get_data()
-    files_count = len(data.get('files', []))
+    await state.update_data(files=files)
+    
+    # Переходим к добавлению файлов
+    await state.set_state(AdminStates.create_event_files)
     
     keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="➡️ Продолжить", callback_data="files:skip")]
+        [InlineKeyboardButton(text="➡️ Продолжить без файлов", callback_data="files:skip")]
     ])
     
-    await callback_query.message.edit_text(
-        f"✅ **Сообщение и {files_count} фото сохранены!**\n\n"
+    await message.answer(
+        "✅ **Сообщение сохранено!**\n\n"
         "📎 **Дополнительные файлы**\n\n"
         "Теперь вы можете отправить:\n"
         "📄 PDF документы\n"
         "📁 Файлы любых форматов\n"
-        "🎥 Дополнительные видео\n\n"
-        "💡 _Эти файлы будут отправлены после сообщения_\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):
     """Обработка файлов для события"""
@@ -372,14 +432,13 @@ async def process_event_files(message: Message, state: FSMContext):
     files = data.get('files', [])
     bot = get_global_var('bot')
     
-    # Создаем временную папку если её нет
-    temp_dir = "temp_event_files"
-    os.makedirs(temp_dir, exist_ok=True)
+    # Создаем временную папку
+    ensure_temp_dir()
     
     # Скачиваем и добавляем файл в список
     if message.document:
         file = await bot.get_file(message.document.file_id)
-        file_path = os.path.join(temp_dir, f"{message.document.file_id}_{message.document.file_name}")
+        file_path = os.path.join(TEMP_DIR, message.document.file_name)
         await bot.download_file(file.file_path, file_path)
         
         files.append({
@@ -393,26 +452,28 @@ async def process_event_files(message: Message, state: FSMContext):
     elif message.photo:
         photo = message.photo[-1]
         file = await bot.get_file(photo.file_id)
-        file_path = os.path.join(temp_dir, f"{photo.file_id}.jpg")
+        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': f"{photo.file_id}.jpg",
+            '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_path = os.path.join(temp_dir, f"{message.video.file_id}.mp4")
+        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': f"{message.video.file_id}.mp4",
+            'name': file_name,
             'stage': 'after_message'
         })
         logger.info(f"Видео сохранено: {file_path} (after_message)")
@@ -438,9 +499,13 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
     data = await state.get_data()
     files = data.get('files', [])
     
-    if action == "skip":
+    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)
@@ -451,37 +516,109 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
     naive_datetime = datetime.strptime(f"{event_date} {event_time}", '%Y-%m-%d %H:%M')
     moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
     
-    # Сначала отправляем превью сообщения
+    # Отправляем сообщение с подтверждением
+    summary = (
+        f"📋 **Подтверждение создания события**\n\n"
+        f"📝 Название: **{data.get('event_name')}**\n"
+        f"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\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
         
-        for file_info in files_with_msg:
-            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
+        # Сортируем файлы по порядку
+        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:
-            await callback_query.message.answer_media_group(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(
@@ -504,14 +641,18 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
                 FSInputFile(file_info['file_path'])
             )
     
-    # 3. Отправляем сообщение с подтверждением
+    # 3. Отправляем сообщение с подтверждением (такое же как было)
+    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)
+    
     summary = (
         f"📋 **Подтверждение создания события**\n\n"
         f"📝 Название: **{data.get('event_name')}**\n"
         f"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
         f"👥 Сегмент: **{data.get('segment_display')}**\n"
         f"📎 Файлов: **{len(files)}**\n\n"
-        f"⬆️ _Сообщение выше будет отправлено {data.get('segment_display', 'всем пользователям')}_\n\n"
         "Подтвердите создание события:"
     )
     
@@ -519,10 +660,13 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
         [
             InlineKeyboardButton(text="✅ Создать", callback_data="confirm:yes"),
             InlineKeyboardButton(text="❌ Отменить", callback_data="confirm:no")
+        ],
+        [
+            InlineKeyboardButton(text="👁 Предпросмотр", callback_data="preview:show")
         ]
     ])
     
-    await callback_query.message.edit_text(
+    await callback_query.message.answer(
         summary,
         reply_markup=keyboard,
         parse_mode='Markdown'
@@ -534,6 +678,9 @@ async def process_event_confirmation(callback_query: CallbackQuery, state: FSMCo
     action = callback_query.data.split(":", 1)[1]
     
     if action == "no":
+        # Очищаем временные файлы
+        await cleanup_temp_files(state)
+        # Очищаем состояние
         await state.clear()
         await callback_query.message.edit_text(
             "❌ Создание события отменено",
@@ -562,88 +709,101 @@ async def process_event_confirmation(callback_query: CallbackQuery, state: FSMCo
     
     logger.info(f"⏰ Время события: Москва={moscow_datetime.strftime('%d.%m.%Y %H:%M %Z')}, UTC={utc_datetime.strftime('%d.%m.%Y %H:%M %Z')}")
     
-    # Загружаем файлы в Supabase Storage
-    import os
-    event_name = data.get('event_name')
-    files = data.get('files', [])
-    uploaded_files = []
-    
+    # Сначала сохраняем событие в БД чтобы получить ID
     try:
+        # Создаем событие без файлов
+        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']
+        logger.info(f"✅ Создано событие с ID {event_id}")
+        
+        # Теперь загружаем файлы в Storage
+        import os
+        files = data.get('files', [])
+        uploaded_files = []
+        
         for file_info in files:
-            # Читаем локальный файл
-            with open(file_info['file_path'], 'rb') as f:
-                file_bytes = f.read()
-            
-            # Загружаем в Storage
-            storage_info = await supabase_client.upload_event_file(
-                event_name=event_name,
-                file_data=file_bytes,
-                file_name=file_info['name']
-            )
-            
-            # Сохраняем только метаданные (БЕЗ file_id и локального пути)
-            uploaded_files.append({
-                'type': file_info['type'],
-                'name': file_info['name'],
-                'storage_path': storage_info['storage_path'],
-                'stage': file_info['stage'],
-                'has_caption': file_info.get('has_caption', False)
-            })
-            
-            # Удаляем временный локальный файл
             try:
-                os.remove(file_info['file_path'])
-                logger.info(f"🗑️ Удален временный файл: {file_info['file_path']}")
+                # Читаем локальный файл
+                with open(file_info['file_path'], 'rb') as f:
+                    file_bytes = f.read()
+                
+                # Генерируем уникальный ID для файла
+                file_id = generate_file_id()
+                
+                # Загружаем в Storage
+                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'],  # Используем оригинальное имя из file_info
+                    'stage': file_info['stage'],
+                    'has_caption': file_info.get('has_caption', False),
+                    'order': file_info.get('order', 0)
+                })
+                
+                # Удаляем временный локальный файл
+                try:
+                    os.remove(file_info['file_path'])
+                    logger.info(f"🗑️ Удален временный файл: {file_info['file_path']}")
+                except Exception as e:
+                    logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+            
             except Exception as e:
-                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+                logger.error(f"❌ Ошибка загрузки файла {file_info['name']}: {e}")
+                # Если ошибка - удаляем все файлы события и само событие
+                try:
+                    await supabase_client.delete_event_files(event_id)
+                    # TODO: добавить метод удаления события
+                except:
+                    pass
+                raise
+        
+        logger.info(f"✅ Загружено {len(uploaded_files)} файлов в Storage для события {event_id}")
         
-        logger.info(f"✅ Загружено {len(uploaded_files)} файлов в Storage для события '{event_name}'")
+        # Обновляем событие с информацией о файлах
+        event_data = {
+            'segment': data.get('segment'),
+            'message': data.get('event_message'),
+            'files': uploaded_files
+        }
+        
+        # TODO: добавить метод обновления события
+        response = 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"❌ Ошибка загрузки файлов в Storage: {e}")
-        # Если ошибка - пытаемся удалить уже загруженные файлы
-        try:
-            await supabase_client.delete_event_files(event_name)
-        except:
-            pass
+        logger.error(f"❌ Ошибка создания события: {e}")
         raise
     
-    # Подготавливаем данные события с метаданными файлов
-    event_data = {
-        'segment': data.get('segment'),
-        'message': data.get('event_message'),
-        'files': uploaded_files  # ← Сохраняем только метаданные
-    }
+    # Показываем сообщение об успехе
+    await callback_query.message.edit_text(
+        f"✅ **Событие успешно создано!**\n\n"
+        f"📝 Название: `{data.get('event_name')}`\n"
+        f"📅 Запланировано на: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
+        f"💡 _Нажмите на название для копирования_",
+        parse_mode='Markdown'
+    )
     
-    try:
-        # Сохраняем в БД (в UTC)
-        event_id = await supabase_client.save_admin_event(
-            event_name=event_name,
-            event_data=event_data,
-            scheduled_datetime=utc_datetime
-        )
-        
-        await callback_query.message.edit_text(
-            f"✅ **Событие успешно создано!**\n\n"
-            f"📝 Название: `{data.get('event_name')}`\n"
-            f"📅 Запланировано на: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
-            f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
-            f"💡 _Нажмите на название для копирования_",
-            parse_mode='Markdown'
-        )
-        
-        # Очищаем состояние
-        await state.clear()
-        await state.set_state(AdminStates.admin_mode)
-        
-    except Exception as e:
-        logger.error(f"Ошибка создания события: {e}")
-        await callback_query.message.edit_text(
-            f"❌ Ошибка создания события:\n`{str(e)}`",
-            parse_mode='Markdown'
-        )
-        await state.clear()
-        await state.set_state(AdminStates.admin_mode)
+    # Очищаем временные файлы и состояние
+    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):
@@ -728,19 +888,34 @@ async def delete_event_command(message: Message, state: FSMContext):
     event_name = parts[1].strip()
     
     try:
-        # Удаляем по названию (только pending события)
-        response = supabase_client.client.table('scheduled_events').update({
-            'status': 'cancelled'
-        }).eq('event_type', event_name).eq(
+        # Сначала получаем событие чтобы узнать его 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}` успешно отменено",
+                f"✅ Событие `{event_name}` успешно отменено\n"
+                f"_(файлы удалены из Storage)_",
                 parse_mode='Markdown'
             )
-            logger.info(f"Отменено событие с названием '{event_name}'")
+            logger.info(f"Отменено событие '{event_name}' (ID: {event_id})")
         else:
             await message.answer(
                 f"❌ Активное событие с названием `{event_name}` не найдено\n\n"