smart-bot-factory 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

smart_bot_factory/admin/admin_manager.py

@@ -122,8 +122,8 @@ class AdminManager:
 
     async def notify_admins(self, message: str, exclude_admin: int = None):
         """Отправляет уведомление всем активным админам"""
-        from main import \
-            bot  # Импорт здесь чтобы избежать циклических импортов
+        from ..handlers.handlers import get_global_var
+        bot = get_global_var("bot")
 
         active_admins = await self.get_active_admins()
 

smart_bot_factory/core/bot_utils.py

@@ -245,25 +245,33 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         f"🔍 Старые scheduled_tasks: {list(scheduled_tasks.keys())}"
                     )
 
-                # Сначала пробуем как обычное событие
+                # Сначала пробуем как обычное событие или scheduled task
+                handler_info = None
+                handler_type = None
+                
                 if event_type in event_handlers:
+                    handler_info = event_handlers.get(event_type, {})
+                    handler_type = "event"
+                elif event_type in scheduled_tasks:
+                    handler_info = scheduled_tasks.get(event_type, {})
+                    handler_type = "task"
+                
+                if handler_info:
                     from ..core.decorators import execute_event_handler
 
-                    event_handler_info = event_handlers.get(event_type, {})
-                    once_only = event_handler_info.get("once_only", True)
-                    send_ai_response_flag = event_handler_info.get(
-                        "send_ai_response", True
-                    )
+                    once_only = handler_info.get("once_only", True)
+                    send_ai_response_flag = handler_info.get("send_ai_response", True)
+                    should_notify = handler_info.get("notify", False)  # Получаем notify из handler_info
 
                     logger.info(
-                        f"   🔍 Обработчик '{event_type}': once_only={once_only}, send_ai_response={send_ai_response_flag}"
+                        f"   🔍 {handler_type.title()} '{event_type}': once_only={once_only}, send_ai_response={send_ai_response_flag}, notify={should_notify}"
                     )
 
                     # Проверяем флаг send_ai_response ИЗ ДЕКОРАТОРА
                     if not send_ai_response_flag:
                         should_send_ai_response = False
                         logger.warning(
-                            f"   🔇🔇🔇 ОБРАБОТЧИК '{event_type}' ЗАПРЕТИЛ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇"
+                            f"   🔇🔇🔇 {handler_type.upper()} '{event_type}' ЗАПРЕТИЛ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇"
                         )
 
                     # Если once_only=True - проверяем в БД наличие выполненных событий
@@ -301,14 +309,21 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
 
                     # Немедленно выполняем событие
                     logger.info(
-                        f"   🎯 Немедленно выполняем user_event: '{event_type}'"
+                        f"   🎯 Немедленно выполняем {handler_type}: '{event_type}'"
                     )
 
                     try:
-                        # Выполняем событие
-                        result = await execute_event_handler(
-                            event_type, user_id, event_info
-                        )
+                        # Выполняем обработчик в зависимости от типа
+                        if handler_type == "event":
+                            result = await execute_event_handler(
+                                event_type, user_id, event_info
+                            )
+                        elif handler_type == "task":
+                            result = await execute_scheduled_task_from_event(
+                                user_id, event_type, event_info, session_id
+                            )
+                        else:
+                            raise ValueError(f"Неизвестный тип обработчика: {handler_type}")
 
                         # Проверяем наличие поля 'info' для дашборда
                         import json
@@ -353,14 +368,14 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         )
                         event_id = response.data[0]["id"]
 
-                        should_notify = event_handler_info.get("notify", False)
-
+                        # should_notify уже получен из handler_info выше
                         logger.info(
                             f"   ✅ Событие {event_id} выполнено и сохранено как completed"
                         )
 
                     except Exception as e:
                         logger.error(f"   ❌ Ошибка выполнения события: {e}")
+                        
                         # Сохраняем ошибку в БД
                         event_record = {
                             "event_type": event_type,
@@ -377,10 +392,15 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                         if supabase_client.bot_id:
                             event_record["bot_id"] = supabase_client.bot_id
 
-                        supabase_client.client.table("scheduled_events").insert(
-                            event_record
-                        ).execute()
-                        raise
+                        try:
+                            supabase_client.client.table("scheduled_events").insert(
+                                event_record
+                            ).execute()
+                            logger.info(f"   💾 Ошибка сохранена в БД")
+                        except Exception as db_error:
+                            logger.error(f"   ❌ Не удалось сохранить ошибку в БД: {db_error}")
+                        
+                        continue  # Переходим к следующему событию после сохранения ошибки
 
                 # Если не user_event, пробуем как запланированную задачу
                 elif event_type in scheduled_tasks:
@@ -469,12 +489,22 @@ async def process_events(session_id: str, events: list, user_id: int) -> bool:
                 logger.error(f"   ❌ Ошибка в обработчике/задаче: {e}")
                 logger.exception("   Стек ошибки:")
 
-            # Уведомляем админов только если result.notify = True
-            if should_notify:
-                await notify_admins_about_event(user_id, event)
-                logger.info("   ✅ Админы уведомлены")
+            # Проверяем notify_time для scheduled_task
+            if handler_type == "task":
+                notify_time = handler_info.get("notify_time", "after")
+                # Для 'before' уведомляем сразу при создании
+                if notify_time == "before" and should_notify:
+                    await notify_admins_about_event(user_id, event)
+                    logger.info("   ✅ Админы уведомлены (notify_time=before)")
+                elif notify_time == "after":
+                    logger.info("   ⏳ Уведомление будет отправлено после выполнения задачи (notify_time=after)")
             else:
-                logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
+                # Для обычных событий уведомляем сразу
+                if should_notify:
+                    await notify_admins_about_event(user_id, event)
+                    logger.info("   ✅ Админы уведомлены")
+                else:
+                    logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
 
         except Exception as e:
             logger.error(f"❌ Ошибка обработки события {event}: {e}")

smart_bot_factory/core/conversation_manager.py

@@ -72,15 +72,20 @@ class ConversationManager:
 
         try:
             # Получаем последние 5 сообщений (сортируем по убыванию и берем первые 5)
-            response = (
+            query = (
                 self.supabase.client.table("sales_messages")
                 .select("role", "content", "created_at")
                 .eq("session_id", session_id)
                 .order("created_at", desc=True)
                 .limit(5)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+
+            response = query.execute()
+
             recent_messages = response.data if response.data else []
 
             if not recent_messages:
@@ -122,12 +127,17 @@ class ConversationManager:
     async def get_user_display_name(self, user_id: int) -> str:
         """Получает красивое отображение пользователя с username"""
         try:
-            response = (
+            query = (
                 self.supabase.client.table("sales_users")
                 .select("first_name", "last_name", "username")
                 .eq("telegram_id", user_id)
-                .execute()
             )
+            
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+            
+            response = query.execute()
 
             if response.data:
                 user_info = response.data[0]
@@ -316,8 +326,7 @@ class ConversationManager:
 
         try:
             # Отправляем сообщение как от бота
-            parse_mode = self.parse_mode if self.parse_mode != "None" else None
-            await send_message_by_human(user_id, message.text, parse_mode=parse_mode)
+            await send_message_by_human(user_id, message.text)
 
             # Сохраняем в БД как сообщение ассистента
             session_info = await supabase_client.get_active_session(user_id)
@@ -406,27 +415,36 @@ class ConversationManager:
             logger.info("🔍 Ищем активные диалоги админов...")
 
             # Получаем все активные диалоги
-            response = (
+            query = (
                 self.supabase.client.table("admin_user_conversations")
                 .select("id", "admin_id", "user_id", "started_at", "auto_end_at")
                 .eq("status", "active")
-                .order("started_at", desc=True)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.supabase.bot_id:
+                query = query.eq("bot_id", self.supabase.bot_id)
+
+            response = query.order("started_at", desc=True).execute()
+
             logger.info(f"📊 Найдено {len(response.data)} активных диалогов в БД")
 
             conversations = []
             for conv in response.data:
                 # Получаем информацию о пользователе
                 try:
-                    user_response = (
+                    user_query = (
                         self.supabase.client.table("sales_users")
                         .select("first_name", "last_name", "username")
                         .eq("telegram_id", conv["user_id"])
-                        .execute()
                     )
 
+                    # Добавляем фильтр по bot_id если он указан
+                    if self.supabase.bot_id:
+                        user_query = user_query.eq("bot_id", self.supabase.bot_id)
+
+                    user_response = user_query.execute()
+
                     user_info = user_response.data[0] if user_response.data else {}
                 except Exception as e:
                     logger.error(
@@ -436,13 +454,18 @@ class ConversationManager:
 
                 # Получаем информацию об админе
                 try:
-                    admin_response = (
+                    admin_query = (
                         self.supabase.client.table("sales_admins")
                         .select("first_name", "last_name", "username")
                         .eq("telegram_id", conv["admin_id"])
-                        .execute()
                     )
 
+                    # Добавляем фильтр по bot_id если он указан
+                    if self.supabase.bot_id:
+                        admin_query = admin_query.eq("bot_id", self.supabase.bot_id)
+
+                    admin_response = admin_query.execute()
+
                     admin_info = admin_response.data[0] if admin_response.data else {}
                 except Exception as e:
                     logger.error(

smart_bot_factory/core/decorators.py

@@ -476,6 +476,7 @@ def event_handler(
 def schedule_task(
     task_name: str,
     notify: bool = False,
+    notify_time: str = "after",  # 'after' или 'before'
     smart_check: bool = True,
     once_only: bool = True,
     delay: Union[str, int] = None,
@@ -1310,6 +1311,11 @@ async def save_immediate_event(
                 f"Событие '{event_type}' уже обрабатывалось (once_only=True)"
             )
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании immediate_event")
+        
     event_record = {
         "event_type": event_type,
         "event_category": "user_event",
@@ -1318,12 +1324,9 @@ async def save_immediate_event(
         "scheduled_at": None,  # Немедленное выполнение
         "status": "immediate",
         "session_id": session_id,
+        "bot_id": bot_id,  # Всегда добавляем bot_id
     }
 
-    # 🆕 Добавляем bot_id если указан
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1375,6 +1378,11 @@ async def save_scheduled_task(
 
     scheduled_at = datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании scheduled_task")
+        
     event_record = {
         "event_type": task_name,
         "event_category": "scheduled_task",
@@ -1383,12 +1391,9 @@ async def save_scheduled_task(
         "scheduled_at": scheduled_at.isoformat(),
         "status": "pending",
         "session_id": session_id,
+        "bot_id": bot_id,  # Всегда добавляем bot_id
     }
 
-    # 🆕 Добавляем bot_id если указан
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1445,6 +1450,11 @@ async def save_global_event(
         scheduled_at = datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
         status = "pending"
 
+    # Получаем bot_id
+    bot_id = supabase_client.bot_id
+    if not bot_id:
+        logger.warning("⚠️ bot_id не указан при создании global_event")
+        
     event_record = {
         "event_type": handler_type,
         "event_category": "global_handler",
@@ -1452,12 +1462,9 @@ async def save_global_event(
         "event_data": handler_data,
         "scheduled_at": scheduled_at.isoformat() if scheduled_at else None,
         "status": status,
+        "bot_id": bot_id,  # Всегда добавляем bot_id (глобальные события тоже привязаны к боту)
     }
 
-    # 🆕 Добавляем bot_id если указан (глобальные события тоже привязаны к боту)
-    if supabase_client.bot_id:
-        event_record["bot_id"] = supabase_client.bot_id
-
     try:
         response = (
             supabase_client.client.table("scheduled_events")
@@ -1503,22 +1510,32 @@ async def update_event_result(
         update_data["last_error"] = error_message
         # Получаем текущее количество попыток
         try:
-            current_retry = (
+            query = (
                 supabase_client.client.table("scheduled_events")
                 .select("retry_count")
                 .eq("id", event_id)
-                .execute()
-                .data[0]["retry_count"]
             )
+            
+            # Добавляем фильтр по bot_id если указан
+            if supabase_client.bot_id:
+                query = query.eq("bot_id", supabase_client.bot_id)
+                
+            current_retry = query.execute().data[0]["retry_count"]
             update_data["retry_count"] = current_retry + 1
         except Exception:
             logger.debug("Не удалось получить текущее количество попыток, устанавливаем 1")
             update_data["retry_count"] = 1
 
     try:
-        supabase_client.client.table("scheduled_events").update(update_data).eq(
+        query = supabase_client.client.table("scheduled_events").update(update_data).eq(
             "id", event_id
-        ).execute()
+        )
+        
+        # Добавляем фильтр по bot_id если указан
+        if supabase_client.bot_id:
+            query = query.eq("bot_id", supabase_client.bot_id)
+            
+        query.execute()
         logger.info(f"📝 Результат события {event_id} обновлен: {status}")
     except Exception as e:
         logger.error(f"❌ Ошибка обновления результата события {event_id}: {e}")
@@ -1613,7 +1630,14 @@ async def background_event_processor():
 
                         # ========== ОБРАБОТКА АДМИНСКИХ СОБЫТИЙ ==========
                         if event_category == "admin_event":
+                            # Проверяем bot_id
+                            if not event.get("bot_id"):
+                                logger.warning(f"⚠️ Админское событие {event['id']} не имеет bot_id")
+                            
                             try:
+                                logger.info(f"🔄 Начало обработки админского события {event['id']}")
+                                logger.info(f"📝 Данные события: {event}")
+                                
                                 # Обрабатываем и получаем результат
                                 result = await process_admin_event(event)
 
@@ -1621,22 +1645,37 @@ async def background_event_processor():
                                 import json
 
                                 supabase_client = get_supabase_client()
-                                supabase_client.client.table("scheduled_events").update(
-                                    {
-                                        "status": "completed",
-                                        "executed_at": datetime.now(
-                                            timezone.utc
-                                        ).isoformat(),
-                                        "result_data": (
-                                            json.dumps(result, ensure_ascii=False)
-                                            if result
-                                            else None
-                                        ),
-                                    }
-                                ).eq("id", event["id"]).execute()
+                                if not supabase_client:
+                                    raise RuntimeError("Не найден supabase_client")
+
+                                # Готовим данные для обновления
+                                update_data = {
+                                    "status": "completed",
+                                    "executed_at": datetime.now(timezone.utc).isoformat(),
+                                    "result_data": json.dumps(result, ensure_ascii=False) if result else None,
+                                }
+                                
+                                # Если у события нет bot_id, но он есть в клиенте - добавляем
+                                if not event.get("bot_id") and supabase_client.bot_id:
+                                    update_data["bot_id"] = supabase_client.bot_id
+                                    logger.info(f"📝 Добавлен bot_id: {supabase_client.bot_id}")
+
+                                # Строим запрос
+                                query = (
+                                    supabase_client.client.table("scheduled_events")
+                                    .update(update_data)
+                                    .eq("id", event["id"])
+                                )
+
+                                # Добавляем фильтр по bot_id если он был в событии
+                                if event.get("bot_id"):
+                                    query = query.eq("bot_id", event["bot_id"])
+
+                                # Выполняем обновление
+                                query.execute()
 
                                 logger.info(
-                                    f"✅ Админское событие {event['id']} выполнено"
+                                    f"✅ Админское событие {event['id']} выполнено и обновлено в БД"
                                 )
                                 continue
 
@@ -1644,18 +1683,45 @@ async def background_event_processor():
                                 logger.error(
                                     f"❌ Ошибка обработки админского события {event['id']}: {e}"
                                 )
+                                logger.exception("Стек ошибки:")
 
-                                # Обновляем статус на failed
-                                supabase_client = get_supabase_client()
-                                supabase_client.client.table("scheduled_events").update(
-                                    {
+                                try:
+                                    # Обновляем статус на failed
+                                    supabase_client = get_supabase_client()
+                                    if not supabase_client:
+                                        raise RuntimeError("Не найден supabase_client")
+
+                                    # Готовим данные для обновления
+                                    update_data = {
                                         "status": "failed",
                                         "last_error": str(e),
-                                        "executed_at": datetime.now(
-                                            timezone.utc
-                                        ).isoformat(),
+                                        "executed_at": datetime.now(timezone.utc).isoformat(),
                                     }
-                                ).eq("id", event["id"]).execute()
+                                    
+                                    # Если у события нет bot_id, но он есть в клиенте - добавляем
+                                    if not event.get("bot_id") and supabase_client.bot_id:
+                                        update_data["bot_id"] = supabase_client.bot_id
+                                        logger.info(f"📝 Добавлен bot_id: {supabase_client.bot_id}")
+
+                                    # Строим запрос
+                                    query = (
+                                        supabase_client.client.table("scheduled_events")
+                                        .update(update_data)
+                                        .eq("id", event["id"])
+                                    )
+
+                                    # Добавляем фильтр по bot_id если он был в событии
+                                    if event.get("bot_id"):
+                                        query = query.eq("bot_id", event["bot_id"])
+
+                                    # Выполняем обновление
+                                    query.execute()
+                                    logger.info(f"✅ Статус события {event['id']} обновлен на failed")
+                                    
+                                except Exception as update_error:
+                                    logger.error(f"❌ Ошибка обновления статуса события: {update_error}")
+                                    logger.exception("Стек ошибки обновления:")
+                                
                                 continue
 
                         # ========== ОБРАБОТКА USER СОБЫТИЙ ==========
@@ -1820,7 +1886,27 @@ async def process_scheduled_event(event: Dict):
 
     result = None
     if event_category == "scheduled_task":
+        # Получаем информацию о задаче
+        router_manager = get_router_manager()
+        if router_manager:
+            scheduled_tasks = router_manager.get_scheduled_tasks()
+        else:
+            scheduled_tasks = _scheduled_tasks
+
+        task_info = scheduled_tasks.get(event_type, {})
+        notify = task_info.get("notify", False)
+        notify_time = task_info.get("notify_time", "after")
+
+        # Выполняем задачу
         result = await execute_scheduled_task(event_type, user_id, event_data)
+
+        # Отправляем уведомление после выполнения если notify=True и notify_time="after"
+        if notify and notify_time == "after":
+            from ..core.bot_utils import notify_admins_about_event
+            event_for_notify = {"тип": event_type, "инфо": event_data}
+            await notify_admins_about_event(user_id, event_for_notify)
+            logger.info(f"   ✅ Админы уведомлены после выполнения задачи '{event_type}'")
+
     elif event_category == "global_handler":
         result = await execute_global_handler(event_type, event_data)
     elif event_category == "user_event":

smart_bot_factory/core/message_sender.py

@@ -7,6 +7,7 @@ import time
 from datetime import datetime
 from typing import Any, Dict, Optional
 
+from aiogram.types import InlineKeyboardMarkup
 import pytz
 
 logger = logging.getLogger(__name__)
@@ -193,7 +194,7 @@ async def send_message_by_ai(
 
 
 async def send_message_by_human(
-    user_id: int, message_text: str, session_id: Optional[str] = None
+    user_id: int, message_text: str, session_id: Optional[str] = None, parse_mode: str = "Markdown", reply_markup: Optional[InlineKeyboardMarkup] = None
 ) -> Dict[str, Any]:
     """
     Отправляет сообщение пользователю от имени человека (готовый текст)
@@ -214,7 +215,7 @@ async def send_message_by_human(
         supabase_client = get_global_var("supabase_client")
 
         # Отправляем сообщение пользователю
-        message = await bot.send_message(chat_id=user_id, text=message_text)
+        message = await bot.send_message(chat_id=user_id, text=message_text, parse_mode=parse_mode, reply_markup=reply_markup)
 
         # Если указана сессия, сохраняем сообщение в БД
         if session_id:

smart_bot_factory/core/router.py

@@ -93,6 +93,7 @@ class EventRouter:
         self,
         task_name: str,
         notify: bool = False,
+        notify_time: str = "after",  # 'after' или 'before'
         smart_check: bool = True,
         once_only: bool = True,
         delay: Union[str, int] = None,
@@ -105,6 +106,9 @@ class EventRouter:
         Args:
             task_name: Название задачи
             notify: Уведомлять ли админов
+            notify_time: Когда отправлять уведомление админам:
+                - 'before': при создании задачи
+                - 'after': после успешного выполнения (по умолчанию)
             smart_check: Использовать ли умную проверку
             once_only: Выполнять ли только один раз
             delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
@@ -141,10 +145,15 @@ class EventRouter:
                 )
                 raise
 
+            # Проверяем корректность notify_time
+            if notify_time not in ["before", "after"]:
+                raise ValueError(f"notify_time должен быть 'before' или 'after', получено: {notify_time}")
+
             self._scheduled_tasks[task_name] = {
                 "handler": func,
                 "name": func.__name__,
                 "notify": notify,
+                "notify_time": notify_time,  # Когда отправлять уведомление
                 "smart_check": smart_check,
                 "once_only": once_only,
                 "router": self.name,

smart_bot_factory/handlers/handlers.py

@@ -95,9 +95,7 @@ async def timeup_handler(message: Message, state: FSMContext):
             .in_("status", ["pending", "immediate"])
         )
 
-        # 🆕 Фильтруем по bot_id если указан
-        if supabase_client.bot_id:
-            user_events_query = user_events_query.eq("bot_id", supabase_client.bot_id)
+        user_events_query = user_events_query.eq("bot_id", supabase_client.bot_id)
 
         user_events = user_events_query.execute()
 
@@ -107,14 +105,9 @@ async def timeup_handler(message: Message, state: FSMContext):
             .select("*")
             .is_("user_id", "null")
             .in_("status", ["pending", "immediate"])
+            .eq("bot_id", supabase_client.bot_id)
         )
 
-        # 🆕 Фильтруем по bot_id если указан
-        if supabase_client.bot_id:
-            global_events_query = global_events_query.eq(
-                "bot_id", supabase_client.bot_id
-            )
-
         global_events = global_events_query.execute()
 
         # Объединяем события
@@ -155,23 +148,25 @@ async def timeup_handler(message: Message, state: FSMContext):
                 )
 
                 # Выполняем событие
-                await process_scheduled_event(event)
+                if event_category != "admin_event":
+                    await process_scheduled_event(event)
 
                 # Помечаем как выполненное
-                await update_event_result(
-                    event_id,
-                    "completed",
-                    {
-                        "executed": True,
-                        "test_mode": True,
-                        "tested_by_user": message.from_user.id,
-                        "tested_at": datetime.now().isoformat(),
-                    },
-                )
-
-                success_count += 1
-                results.append(f"✅ {event_label}")
-                logger.info(f"✅ Событие {event_id} успешно выполнено")
+                if event_category != "admin_event" or event_category != "global_handler":
+                    await update_event_result(
+                        event_id,
+                        "completed",
+                        {
+                            "executed": True,
+                            "test_mode": True,
+                            "tested_by_user": message.from_user.id,
+                            "tested_at": datetime.now().isoformat(),
+                        },
+                    )
+                if event_category != "admin_event":
+                    success_count += 1
+                    results.append(f"✅ {event_label}")
+                    logger.info(f"✅ Событие {event_id} успешно выполнено")
 
             except Exception as e:
                 failed_count += 1

smart_bot_factory/integrations/supabase_client.py

@@ -570,22 +570,37 @@ class SupabaseClient:
     ) -> int:
         """Начинает диалог между админом и пользователем"""
         try:
+            # Проверяем существование пользователя с правильным bot_id
+            user_query = self.client.table("sales_users").select("telegram_id").eq("telegram_id", user_id)
+            if self.bot_id:
+                user_query = user_query.eq("bot_id", self.bot_id)
+            
+            user_response = user_query.execute()
+            if not user_response.data:
+                logger.error(f"❌ Пользователь {user_id} не найден в sales_users{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                raise APIError("User not found in sales_users")
+
             # Завершаем активные диалоги этого админа
             await self.end_admin_conversations(admin_id)
 
+            # Готовим данные для записи
+            conversation_data = {
+                "admin_id": admin_id,
+                "user_id": user_id,
+                "session_id": session_id,
+                "status": "active",
+                "auto_end_at": (
+                    datetime.now(timezone.utc) + timedelta(minutes=30)
+                ).isoformat(),
+            }
+
+            # Добавляем bot_id если он указан
+            if self.bot_id:
+                conversation_data["bot_id"] = self.bot_id
+
             response = (
                 self.client.table("admin_user_conversations")
-                .insert(
-                    {
-                        "admin_id": admin_id,
-                        "user_id": user_id,
-                        "session_id": session_id,
-                        "status": "active",
-                        "auto_end_at": (
-                            datetime.now(timezone.utc) + timedelta(minutes=30)
-                        ).isoformat(),
-                    }
-                )
+                .insert(conversation_data)
                 .execute()
             )
 
@@ -608,7 +623,7 @@ class SupabaseClient:
                 self.client.table("admin_user_conversations")
                 .update(
                     {
-                        "status": "ended",
+                        "status": "completed",  # Используем 'completed' вместо 'ended'
                         "ended_at": datetime.now(timezone.utc).isoformat(),
                     }
                 )
@@ -619,6 +634,9 @@ class SupabaseClient:
                 query = query.eq("admin_id", admin_id)
             if user_id:
                 query = query.eq("user_id", user_id)
+            # Добавляем фильтр по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
 
             response = query.execute()
             ended_count = len(response.data)
@@ -1193,15 +1211,20 @@ class SupabaseClient:
         """Проверяет, изменился ли этап пользователя с момента планирования события"""
         try:
             # Получаем текущую информацию о сессии
-            current_response = (
+            query = (
                 self.client.table("sales_chat_sessions")
                 .select("id", "current_stage")
-                .eq("user_telegram_id", user_id)
+                .eq("user_id", user_id)
                 .order("created_at", desc=True)
                 .limit(1)
-                .execute()
             )
 
+            # Добавляем фильтр по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
+
+            current_response = query.execute()
+
             if not current_response.data:
                 return False
 
@@ -1515,6 +1538,7 @@ class SupabaseClient:
 
                 scheduled_datetime = scheduled_datetime.replace(tzinfo=timezone.utc)
 
+            # Готовим данные для записи
             event_record = {
                 "event_type": event_name,
                 "event_category": "admin_event",
@@ -1524,6 +1548,11 @@ class SupabaseClient:
                 "status": "pending",
             }
 
+            # Добавляем bot_id если он указан
+            if self.bot_id:
+                event_record["bot_id"] = self.bot_id
+                logger.info(f"📝 Добавлен bot_id: {self.bot_id} для админского события")
+
             response = (
                 self.client.table("scheduled_events").insert(event_record).execute()
             )
@@ -1549,15 +1578,22 @@ class SupabaseClient:
             List[Dict]: Список админских событий
         """
         try:
+            # Строим базовый запрос
             query = (
                 self.client.table("scheduled_events")
                 .select("*")
                 .eq("event_category", "admin_event")
             )
 
+            # Добавляем фильтры
             if status:
                 query = query.eq("status", status)
 
+            # Фильтруем по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
+                logger.info(f"🔍 Фильтруем админские события по bot_id: {self.bot_id}")
+
             response = query.order("scheduled_at", desc=False).execute()
 
             logger.info(f"Найдено {len(response.data)} админских событий")
@@ -1578,15 +1614,22 @@ class SupabaseClient:
             bool: True если активное событие с таким именем существует
         """
         try:
-            response = (
+            # Строим запрос
+            query = (
                 self.client.table("scheduled_events")
                 .select("id", "event_type", "status")
                 .eq("event_category", "admin_event")
                 .eq("event_type", event_name)
                 .eq("status", "pending")
-                .execute()
             )
 
+            # Фильтруем по bot_id если он указан
+            if self.bot_id:
+                query = query.eq("bot_id", self.bot_id)
+                logger.info(f"🔍 Проверка названия события с фильтром по bot_id: {self.bot_id}")
+
+            response = query.execute()
+
             exists = len(response.data) > 0
 
             if exists:

{smart_bot_factory-0.3.8.dist-info → smart_bot_factory-0.3.10.dist-info}/METADATA

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

{smart_bot_factory-0.3.8.dist-info → smart_bot_factory-0.3.10.dist-info}/RECORD

@@ -6,7 +6,7 @@ smart_bot_factory/utm_link_generator.py,sha256=eA3Eic4Wvs0QpMdAFPJgYJyzv-_pSQWZ5
 smart_bot_factory/admin/__init__.py,sha256=xHUtMLeQDDQEXZrg4WAGpt-TWp8adjCC0-mYUBuino4,489
 smart_bot_factory/admin/admin_events.py,sha256=FkiD0FtnlgpxLCoN9KXR61VCn8OsI0JCWm9RjVVa6tk,43903
 smart_bot_factory/admin/admin_logic.py,sha256=TiXhZIXiXK1YQkrueY_zPFYL3_sJzoAvd100AP-ZCWU,23136
-smart_bot_factory/admin/admin_manager.py,sha256=hjk4XI5prdlE6KMm64DjzadujGu1DmXWkeTQLweWF54,6406
+smart_bot_factory/admin/admin_manager.py,sha256=u22j1xy2zLTw0kejgzWF5m657_IyMDKnDlM9kBzbjh4,6359
 smart_bot_factory/admin/admin_tester.py,sha256=YwovS51chPJoQ33pIiug-vS3augQzc1hHfbma48HtDk,6352
 smart_bot_factory/admin/timeout_checker.py,sha256=afWsg39X6M5SaRKMk7ptNod8Z0StIa2o8H5Lx8y1ZE0,24438
 smart_bot_factory/aiogram_calendar/__init__.py,sha256=UCoae3mXXDgYqqSQPotEpUxzAsZ_e62FuW9MWl1sG34,410
@@ -29,11 +29,11 @@ smart_bot_factory/configs/growthmed-october-24/tests/realistic_scenarios.yaml,sh
 smart_bot_factory/configs/growthmed-october-24/tests/scenario_examples.yaml,sha256=bzDulOU4a2LyWlcHzlQU8GYhOky2WTfyizGfjX4ioMY,2436
 smart_bot_factory/configs/growthmed-october-24/welcome_file/welcome_file_msg.txt,sha256=Db21Mm0r8SBWFdX9EeIF2FZtLQ2cvuwVlSRJd2KEYCg,922
 smart_bot_factory/configs/growthmed-october-24/welcome_file/Чек лист по 152ФЗ и 323ФЗ для медицины.pdf,sha256=BiAiQHNnQXJPMsks9AeL6s0beEjRFkRMJLMlAn4WorA,5284954
-smart_bot_factory/core/bot_utils.py,sha256=WlJ3QMIO96-n6-KyjQrGm2PR8Z1U-lvIGtSSXSSaLuE,49874
-smart_bot_factory/core/conversation_manager.py,sha256=zduDEaTr7iQoVvbcMdmqBsyN4x1ZaOpTnUt0JsAgQ7I,28497
-smart_bot_factory/core/decorators.py,sha256=9zBlgKZb0fnClZ0dVULNJKd9Fdl7VRDnVX07LmLU85I,103031
-smart_bot_factory/core/message_sender.py,sha256=VjOLZUhw0Lkz_IOh4p9J_L5DkEkaURFRRU-qrIsG2qc,32338
-smart_bot_factory/core/router.py,sha256=GdsSZxeuYICyzXNFeJnS4CnbaXGxojg-c9JK7z2OFiM,15592
+smart_bot_factory/core/bot_utils.py,sha256=vbWb4wUkG-FlQIGTQ6RLoSSVg_LRVTzpnX3tyowsbqY,52032
+smart_bot_factory/core/conversation_manager.py,sha256=ga0ThoDpvov97x5KLcHpL8aRlEZB1XRw3JPrexIb-jk,29506
+smart_bot_factory/core/decorators.py,sha256=1FwJMjSM-QEgX3hX_LEW0A6VS3TWXBRIwwpPxK2pZuA,108247
+smart_bot_factory/core/message_sender.py,sha256=gK0HbjLumAu5_Vr29DnOQkwbPGGmQrtkgW1dVt_9Bb8,32518
+smart_bot_factory/core/router.py,sha256=66sCp7Okyu1ceIQPpxFF88-NizTD1N7rR4ZAdwDYmi8,16285
 smart_bot_factory/core/router_manager.py,sha256=x-cc4zhZUVPCTUH980GdlE_-JjHRtYnPdEBiWnf3ka8,10156
 smart_bot_factory/core/states.py,sha256=mFyQ-oxIjTX03Wy5NHZUgYgh8fsJ5YmQU09_PhPAB04,889
 smart_bot_factory/creation/__init__.py,sha256=lHFgYIjOLvdsDAW8eLMp8zfFUCd-6wepvUaUMeJ7feU,128
@@ -41,9 +41,9 @@ smart_bot_factory/creation/bot_builder.py,sha256=-gF53eCaWBRKoUbRGR-PDHpqLWlceQ9
 smart_bot_factory/creation/bot_testing.py,sha256=aMPSgj2o2zl6yWiV1a6RMmSJfiwMYp-_0ZkmJ6aFZVs,54561
 smart_bot_factory/dashboard/__init__.py,sha256=Qie1pJgzprBlCPrZVQLhVs1JR5-YrpzfcBvHHD3OLJk,94
 smart_bot_factory/event/__init__.py,sha256=E5u8Pjul_T0E77Ftmj-mqrip05w7KwUXlF1WMc5_lIs,192
-smart_bot_factory/handlers/handlers.py,sha256=IELP8fH-hW8KhnTRKBvaO-2rnPmJRGmmcKN8acrvPe0,63656
+smart_bot_factory/handlers/handlers.py,sha256=za41yxSfsSwARnuI-l57JO90HN2knOXIqkbgq_z-MOA,63623
 smart_bot_factory/integrations/openai_client.py,sha256=R04qglOWNu3yQ32QRMRMzO01T6luWTp83H3OJMvD-uM,24316
-smart_bot_factory/integrations/supabase_client.py,sha256=vBmwNt069GXk9qel6UvgudNyvOEsp_YCkOX6XCPlaCY,66158
+smart_bot_factory/integrations/supabase_client.py,sha256=7Yip9din4PDqFD1X2pkKB4KYAhmf04LUzxo9SnOrVg4,68415
 smart_bot_factory/message/__init__.py,sha256=neUUYAs8ITz3cV1B_T0P9_3XZvvn8cZ2VDpDqrf6lrc,1940
 smart_bot_factory/router/__init__.py,sha256=ywywG6iFBLLkBvtZ-huPVetqjXGN4UiUzoK6lw46bMg,272
 smart_bot_factory/supabase/__init__.py,sha256=xa1xmHLaQVoghjD5cqguiL4yd25VYMvGd6_e87uc0tQ,181
@@ -52,8 +52,8 @@ smart_bot_factory/utils/__init__.py,sha256=RgP2IAMFsJF7fxhhg8JLfhbGg9mO63xQM-NEa
 smart_bot_factory/utils/debug_routing.py,sha256=wV9BFwNmjBbF3rNI7UBdGsTf1bIT5XVQIGnxwIxhNYA,4707
 smart_bot_factory/utils/prompt_loader.py,sha256=YClbQjvRgTWCD42Rr92g77zzVEVMUgrqStI6YETC0c4,20022
 smart_bot_factory/utils/user_prompt_loader.py,sha256=lq1eQ4Hb2qN22osOjaFtkGdEc4OgpFPrzPNpPhsm5kA,2353
-smart_bot_factory-0.3.8.dist-info/METADATA,sha256=3D53canLAlt3V72z7HX0EfZT9nSSl4VZVWYuNSFTSmI,40748
-smart_bot_factory-0.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smart_bot_factory-0.3.8.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
-smart_bot_factory-0.3.8.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
-smart_bot_factory-0.3.8.dist-info/RECORD,,
+smart_bot_factory-0.3.10.dist-info/METADATA,sha256=1rn8juhuHmHF0Vf9tmqucWYj0JW-acIjzvIMlvLfvFI,40749
+smart_bot_factory-0.3.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-0.3.10.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-0.3.10.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
+smart_bot_factory-0.3.10.dist-info/RECORD,,