smart-bot-factory 0.3.10__tar.gz → 1.0.1__tar.gz

{smart_bot_factory-0.3.10 → smart_bot_factory-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.3.10
+Version: 1.0.1
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <eserov73@gmail.com>
 License: MIT

{smart_bot_factory-0.3.10 → smart_bot_factory-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "smart-bot-factory"
-version = "0.3.10"
+version = "1.0.1"
 description = "Библиотека для создания умных чат-ботов"
 authors = [
     {name = "Kopatych", email = "eserov73@gmail.com"}

{smart_bot_factory-0.3.10 → smart_bot_factory-1.0.1}/smart_bot_factory/admin/admin_events.py

@@ -116,24 +116,83 @@ async def process_event_name(message: Message, state: FSMContext):
 
     # Сохраняем название
     await state.update_data(event_name=event_name)
-    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),
+    # Создаем клавиатуру с выбором времени
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="🚀 Запустить сразу", callback_data="timing:immediate"),
+                InlineKeyboardButton(text="📅 Выбрать время", callback_data="timing:scheduled")
+            ]
+        ]
     )
-    calendar_markup = await calendar.start_calendar()
 
     await message.answer(
-        f"✅ Название события: **{event_name}**\n\n" "📅 Выберите дату отправки:",
-        reply_markup=calendar_markup,
-        parse_mode="Markdown",
+        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
 )
@@ -584,17 +643,23 @@ async def process_files_action(callback_query: CallbackQuery, state: FSMContext)
     # Переход к подтверждению
     await state.set_state(AdminStates.create_event_confirm)
 
-    # Формируем дату и время для отображения (московское время)
-    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)
+    # Формируем дату и время для отображения
+    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"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"📅 Время запуска: **{time_display}**\n"
         f"👥 Сегмент: **{data.get('segment_display')}**\n"
         f"📎 Файлов: **{len(files)}**\n\n"
         "Подтвердите создание события:"
@@ -727,15 +792,21 @@ async def show_event_preview(callback_query: CallbackQuery, state: FSMContext):
             )
 
     # 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)
+    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"📅 Дата и время: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"📅 Время запуска: **{time_display}**\n"
         f"👥 Сегмент: **{data.get('segment_display')}**\n"
         f"📎 Файлов: **{len(files)}**\n\n"
         "Подтвердите создание события:"
@@ -773,127 +844,247 @@ async def process_event_confirmation(callback_query: CallbackQuery, state: FSMCo
         )
         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")
 
-    # Формируем datetime для планирования
-    event_date = data.get("event_date")
-    event_time = data.get("event_time")
-
-    # Создаем naive datetime из введенного московского времени
-    naive_datetime = datetime.strptime(f"{event_date} {event_time}", "%Y-%m-%d %H:%M")
+    if is_immediate:
+        # Для немедленной отправки - сразу рассылаем сообщения
+        try:
+            # Показываем сообщение о начале рассылки
+            await callback_query.message.edit_text(
+                "📤 **Выполняется рассылка...**",
+                parse_mode="Markdown"
+            )
 
-    # Привязываем к московской временной зоне
-    moscow_datetime = MOSCOW_TZ.localize(naive_datetime)
+            # Получаем список пользователей для рассылки
+            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"])
+                            )
 
-    # Конвертируем в UTC для сохранения в БД
-    utc_datetime = moscow_datetime.astimezone(pytz.UTC)
+                    sent_count += 1
 
-    logger.info(
-        f"⏰ Время события: Москва={moscow_datetime.strftime('%d.%m.%Y %H:%M %Z')}, UTC={utc_datetime.strftime('%d.%m.%Y %H:%M %Z')}"
-    )
+                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)
+            )
 
-    # Сначала сохраняем событие в БД чтобы получить 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}")
+            # Показываем итоговое сообщение
+            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"
+            )
 
-        # Теперь загружаем файлы в Storage
-        import os
+        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)
+            )
 
-        files = data.get("files", [])
-        uploaded_files = []
+            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"
+            )
 
-        for file_info in files:
-            try:
-                # Читаем локальный файл
-                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,
-                )
+    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"]
 
-                # Сохраняем метаданные файла
-                uploaded_files.append(
-                    {
+            # Загружаем файлы в 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"
-                        ],  # Используем оригинальное имя из file_info
+                        "original_name": file_info["name"],
                         "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.error(f"❌ Ошибка загрузки файла {file_info['name']}: {e}")
-                # Если ошибка - удаляем все файлы события и само событие
-                try:
+                    logger.error(f"❌ Ошибка загрузки файла {file_info['name']}: {e}")
                     await supabase_client.delete_event_files(event_id)
-                    # TODO: добавить метод удаления события
-                except Exception:
-                    logger.error("Ошибка при удалении файлов события")
-                raise
-
-        logger.info(
-            f"✅ Загружено {len(uploaded_files)} файлов в Storage для события {event_id}"
-        )
+                    raise
 
-        # Обновляем событие с информацией о файлах
-        event_data = {
-            "segment": data.get("segment"),
-            "message": data.get("event_message"),
-            "files": uploaded_files,
-        }
-
-        # TODO: добавить метод обновления события
-        (
-            supabase_client.client.table("scheduled_events")
-            .update({"event_data": json.dumps(event_data, ensure_ascii=False)})
-            .eq("id", event_id)
-            .execute()
-        )
+            # Обновляем событие с информацией о файлах
+            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
+        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"📅 Запланировано на: **{moscow_datetime.strftime('%d.%m.%Y %H:%M')} (МСК)**\n"
+        f"📅 Время запуска: **{time_display}**\n"
         f"👥 Сегмент: **{data.get('segment_display')}**\n\n"
         f"💡 _Нажмите на название для копирования_",
         parse_mode="Markdown",

{smart_bot_factory-0.3.10 → smart_bot_factory-1.0.1}/smart_bot_factory/core/decorators.py

@@ -7,7 +7,7 @@ import logging
 import re
 from datetime import datetime, timedelta, timezone
 from functools import wraps
-from typing import Any, Callable, Dict, Union
+from typing import Any, Callable, Dict, Optional, Union
 
 logger = logging.getLogger(__name__)
 
@@ -2176,12 +2176,13 @@ async def check_event_already_processed(
         return False
 
 
-async def process_admin_event(event: Dict):
+async def process_admin_event(event: Dict, single_user_id: Optional[int] = None):
     """
     Обрабатывает одно админское событие - скачивает файлы из Storage и отправляет пользователям
 
     Args:
         event: Событие из БД с данными для отправки
+        single_user_id: ID пользователя для тестовой отправки. Если указан, сообщение будет отправлено только ему
     """
     import json
     import shutil
@@ -2265,17 +2266,20 @@ async def process_admin_event(event: Dict):
                 raise
 
         # 2. Получаем пользователей
-        users = await supabase_client.get_users_by_segment(segment)
-
-        if not users:
-            logger.warning(f"⚠️ Нет пользователей для сегмента '{segment}'")
-            return {
-                "success_count": 0,
-                "failed_count": 0,
-                "total_users": 0,
-                "segment": segment or "Все",
-                "warning": "Нет пользователей",
-            }
+        if single_user_id:
+            users = [{"telegram_id": single_user_id}]
+            logger.info(f"🔍 Тестовая отправка для пользователя {single_user_id}")
+        else:
+            users = await supabase_client.get_users_by_segment(segment)
+            if not users:
+                logger.warning(f"⚠️ Нет пользователей для сегмента '{segment}'")
+                return {
+                    "success_count": 0,
+                    "failed_count": 0,
+                    "total_users": 0,
+                    "segment": segment or "Все",
+                    "warning": "Нет пользователей",
+                }
 
         success_count = 0
         failed_count = 0