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

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

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

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

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

{smart_bot_factory-1.0.0 → 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-1.0.0 → smart_bot_factory-1.0.1}/smart_bot_factory/core/message_sender.py

@@ -5,11 +5,15 @@
 import logging
 import time
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
-from aiogram.types import InlineKeyboardMarkup
+from aiogram.types import InlineKeyboardMarkup, FSInputFile
 import pytz
 
+from project_root_finder import root
+
+PROJECT_ROOT = root
+
 logger = logging.getLogger(__name__)
 
 
@@ -194,16 +198,18 @@ async def send_message_by_ai(
 
 
 async def send_message_by_human(
-    user_id: int, message_text: str, session_id: Optional[str] = None, parse_mode: str = "Markdown", reply_markup: Optional[InlineKeyboardMarkup] = None
+    user_id: int, message_text: str, session_id: Optional[str] = None, parse_mode: str = "Markdown", reply_markup: Optional[InlineKeyboardMarkup] = None, photo: Optional[str] = None
 ) -> Dict[str, Any]:
     """
-    Отправляет сообщение пользователю от имени человека (готовый текст)
+    Отправляет сообщение пользователю от имени человека (готовый текст или фото с подписью).
 
     Args:
         user_id: ID пользователя в Telegram
-        message_text: Готовый текст сообщения
+        message_text: Готовый текст сообщения или подпись к фото
         session_id: ID сессии (опционально, для сохранения в БД)
-
+        parse_mode: Тип форматирования текста
+        reply_markup: Клавиатура/markup (опционально)
+        photo: (str) путь к локальному файлу относительно корня проекта
     Returns:
         Результат отправки
     """
@@ -214,8 +220,29 @@ async def send_message_by_human(
         bot = get_global_var("bot")
         supabase_client = get_global_var("supabase_client")
 
-        # Отправляем сообщение пользователю
-        message = await bot.send_message(chat_id=user_id, text=message_text, parse_mode=parse_mode, reply_markup=reply_markup)
+        msg_type = "text"
+        message = None
+
+        if photo:
+            from pathlib import Path
+            photo_path = PROJECT_ROOT / photo
+            if not photo_path.exists():
+                raise FileNotFoundError(f"Файл с фото не найден: {photo}")
+            message = await bot.send_photo(
+                chat_id=user_id,
+                photo=FSInputFile(str(photo_path)),
+                caption=message_text,
+                parse_mode=parse_mode,
+                reply_markup=reply_markup
+            )
+            msg_type = "photo"
+        else:
+            message = await bot.send_message(
+                chat_id=user_id,
+                text=message_text,
+                parse_mode=parse_mode,
+                reply_markup=reply_markup,
+            )
 
         # Если указана сессия, сохраняем сообщение в БД
         if session_id:
@@ -223,10 +250,10 @@ async def send_message_by_human(
                 session_id=session_id,
                 role="assistant",
                 content=message_text,
-                message_type="text",
-                metadata={"sent_by_human": True},
+                message_type=msg_type,
+                metadata={"sent_by_human": True, "has_photo": bool(photo)},
             )
-            logger.info("💾 Сообщение от человека сохранено в БД")
+            logger.info(f"💾 Сообщение от человека сохранено в БД (photo={bool(photo)})")
 
         return {
             "status": "success",
@@ -234,6 +261,7 @@ async def send_message_by_human(
             "message_id": message.message_id,
             "message_text": message_text,
             "saved_to_db": bool(session_id),
+            "has_photo": bool(photo)
         }
 
     except Exception as e:
@@ -242,54 +270,43 @@ async def send_message_by_human(
 
 
 async def send_message_to_users_by_stage(
-    stage: str, message_text: str, bot_id: str
+    stage: str, message_text: str, bot_id: str, photo: Optional[str] = None
 ) -> Dict[str, Any]:
     """
-    Отправляет сообщение всем пользователям, находящимся на определенной стадии
+    Отправляет сообщение (или фото с подписью) всем пользователям, находящимся на определенной стадии
 
     Args:
         stage: Стадия диалога (например, 'introduction', 'qualification', 'closing')
-        message_text: Текст сообщения для отправки
+        message_text: Текст сообщения для отправки / подпись к фото
         bot_id: ID бота (если не указан, используется текущий бот)
-
+        photo: путь к файлу с фото (относительно корня проекта, опционально)
     Returns:
         Результат отправки с количеством отправленных сообщений
     """
     try:
-        # Импортируем необходимые компоненты
         from ..handlers.handlers import get_global_var
+        from pathlib import Path
 
         bot = get_global_var("bot")
         supabase_client = get_global_var("supabase_client")
         current_bot_id = (
             get_global_var("config").BOT_ID if get_global_var("config") else bot_id
         )
-
         if not current_bot_id:
             return {"status": "error", "error": "Не удалось определить bot_id"}
-
         logger.info(
             f"🔍 Ищем пользователей на стадии '{stage}' для бота '{current_bot_id}'"
         )
-
-        # Получаем последние сессии для каждого пользователя с нужной стадией
-        # Сначала получаем все активные сессии с нужной стадией
         sessions_query = (
             supabase_client.client.table("sales_chat_sessions")
             .select("user_id, id, current_stage, created_at")
             .eq("status", "active")
             .eq("current_stage", stage)
         )
-
-        # Фильтруем по bot_id если указан
         if current_bot_id:
             sessions_query = sessions_query.eq("bot_id", current_bot_id)
-
-        # Сортируем по дате создания (последние сначала)
         sessions_query = sessions_query.order("created_at", desc=True)
-
         sessions_data = sessions_query.execute()
-
         if not sessions_data.data:
             logger.info(f"📭 Пользователи на стадии '{stage}' не найдены")
             return {
@@ -299,56 +316,48 @@ async def send_message_to_users_by_stage(
                 "messages_sent": 0,
                 "errors": [],
             }
-
-        # Выбираем уникальные user_id (берем только последнюю сессию для каждого пользователя)
         unique_users = {}
         for session in sessions_data.data:
             user_id = session["user_id"]
-            # Если пользователь еще не добавлен, добавляем его (так как сессии отсортированы по дате, первая будет самой последней)
             if user_id not in unique_users:
                 unique_users[user_id] = {
                     "session_id": session["id"],
                     "current_stage": session["current_stage"],
                 }
-
         logger.info(
             f"👥 Найдено {len(unique_users)} уникальных пользователей на стадии '{stage}'"
         )
-
-        # Отправляем сообщения
         messages_sent = 0
         errors = []
-
+        photo_path = None
+        if photo:
+            photo_path = PROJECT_ROOT / photo
+            if not photo_path.exists():
+                raise FileNotFoundError(f"Файл с фото не найден: {photo}")
         for user_id, user_data in unique_users.items():
             session_id = user_data["session_id"]
-
             try:
-                # Отправляем сообщение пользователю
-                await bot.send_message(chat_id=user_id, text=message_text)
-
-                # Сохраняем сообщение в БД
+                if photo_path:
+                    msg = await bot.send_photo(chat_id=user_id, photo=FSInputFile(str(photo_path)), caption=message_text)
+                    msg_type = "photo"
+                else:
+                    msg = await bot.send_message(chat_id=user_id, text=message_text)
+                    msg_type = "text"
                 await supabase_client.add_message(
                     session_id=session_id,
                     role="assistant",
                     content=message_text,
-                    message_type="text",
-                    metadata={
-                        "sent_by_stage_broadcast": True,
-                        "target_stage": stage,
-                        "broadcast_timestamp": datetime.now().isoformat(),
-                    },
+                    message_type=msg_type,
+                    metadata={"sent_by_stage_broadcast": True, "target_stage": stage, "broadcast_timestamp": datetime.now().isoformat(), "has_photo": bool(photo)},
                 )
-
                 messages_sent += 1
                 logger.info(
                     f"✅ Сообщение отправлено пользователю {user_id} (стадия: {stage})"
                 )
-
             except Exception as e:
                 error_msg = f"Ошибка отправки пользователю {user_id}: {str(e)}"
                 errors.append(error_msg)
                 logger.error(f"❌ {error_msg}")
-
         result = {
             "status": "success",
             "stage": stage,
@@ -356,13 +365,10 @@ async def send_message_to_users_by_stage(
             "messages_sent": messages_sent,
             "errors": errors,
         }
-
         logger.info(
             f"📊 Результат рассылки по стадии '{stage}': {messages_sent}/{len(unique_users)} сообщений отправлено"
         )
-
         return result
-
     except Exception as e:
         logger.error(f"❌ Ошибка в send_message_to_users_by_stage: {e}")
         return {"status": "error", "error": str(e), "stage": stage}

{smart_bot_factory-1.0.0 → smart_bot_factory-1.0.1}/uv.lock

@@ -1670,7 +1670,7 @@ wheels = [
 
 [[package]]
 name = "smart-bot-factory"
-version = "0.3.11.dev2"
+version = "1.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },