smart-bot-factory 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

smart_bot_factory/core/message_sender.py

@@ -242,3 +242,210 @@ async def send_message_by_human(
             "error": str(e),
             "user_id": user_id
         }
+
+async def send_message_to_users_by_stage(
+    stage: str,
+    message_text: str,
+    bot_id: str
+) -> Dict[str, Any]:
+    """
+    Отправляет сообщение всем пользователям, находящимся на определенной стадии
+    
+    Args:
+        stage: Стадия диалога (например, 'introduction', 'qualification', 'closing')
+        message_text: Текст сообщения для отправки
+        bot_id: ID бота (если не указан, используется текущий бот)
+        
+    Returns:
+        Результат отправки с количеством отправленных сообщений
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from ..handlers.handlers import get_global_var
+        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 {
+                "status": "success",
+                "stage": stage,
+                "users_found": 0,
+                "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 = []
+        
+        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
+                )
+                
+                # Сохраняем сообщение в БД
+                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()
+                    }
+                )
+                
+                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,
+            "users_found": len(unique_users),
+            "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
+        }
+
+async def get_users_by_stage_stats(
+    bot_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Получает статистику пользователей по стадиям
+    
+    Args:
+        bot_id: ID бота (если не указан, используется текущий бот)
+        
+    Returns:
+        Статистика по стадиям с количеством пользователей
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from ..handlers.handlers import get_global_var
+        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"📊 Получаем статистику по стадиям для бота '{current_bot_id}'")
+        
+        # Получаем статистику по стадиям с user_id для подсчета уникальных пользователей
+        stats_query = supabase_client.client.table('sales_chat_sessions').select(
+            'user_id, current_stage, created_at'
+        ).eq('status', 'active')
+        
+        # Фильтруем по bot_id если указан
+        if current_bot_id:
+            stats_query = stats_query.eq('bot_id', current_bot_id)
+        
+        # Сортируем по дате создания (последние сначала)
+        stats_query = stats_query.order('created_at', desc=True)
+        
+        sessions_data = stats_query.execute()
+        
+        # Подсчитываем уникальных пользователей по стадиям (берем последнюю сессию каждого пользователя)
+        user_stages = {}  # {user_id: stage}
+        
+        for session in sessions_data.data:
+            user_id = session['user_id']
+            stage = session['current_stage'] or 'unknown'
+            
+            # Если пользователь еще не добавлен, добавляем его стадию (первая встреченная - самая последняя)
+            if user_id not in user_stages:
+                user_stages[user_id] = stage
+        
+        # Подсчитываем количество пользователей по стадиям
+        stage_stats = {}
+        for stage in user_stages.values():
+            stage_stats[stage] = stage_stats.get(stage, 0) + 1
+        
+        total_users = len(user_stages)
+        
+        # Сортируем по количеству пользователей (по убыванию)
+        sorted_stages = sorted(stage_stats.items(), key=lambda x: x[1], reverse=True)
+        
+        result = {
+            "status": "success",
+            "bot_id": current_bot_id,
+            "total_active_users": total_users,
+            "stages": dict(sorted_stages),
+            "stages_list": sorted_stages
+        }
+        
+        logger.info(f"📊 Статистика по стадиям: {total_users} активных пользователей")
+        for stage, count in sorted_stages:
+            logger.info(f"   {stage}: {count} пользователей")
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка в get_users_by_stage_stats: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "bot_id": bot_id
+        }

smart_bot_factory/core/router.py

@@ -2,7 +2,7 @@
 Роутер для Smart Bot Factory - аналог aiogram Router
 """
 
-from typing import Dict, Any, Callable
+from typing import Dict, Any, Callable, Union
 import logging
 
 logger = logging.getLogger(__name__)
@@ -57,7 +57,7 @@ class Router:
             return wrapper
         return decorator
     
-    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True):
+    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: str = None):
         """
         Декоратор для регистрации запланированной задачи в роутере
         
@@ -66,18 +66,43 @@ class Router:
             notify: Уведомлять ли админов
             smart_check: Использовать ли умную проверку
             once_only: Выполнять ли только один раз
+            delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
+            event_type: Тип события для напоминания (например, 'appointment_booking') - ОПЦИОНАЛЬНО
         """
         def decorator(func: Callable) -> Callable:
+            # Время ОБЯЗАТЕЛЬНО должно быть указано
+            if delay is None:
+                raise ValueError(f"Для задачи '{task_name}' в роутере {self.name} ОБЯЗАТЕЛЬНО нужно указать параметр delay")
+            
+            # Импортируем функцию парсинга времени
+            from .decorators import parse_time_string
+            
+            # Парсим время
+            try:
+                default_delay_seconds = parse_time_string(delay)
+                if event_type:
+                    logger.info(f"⏰ Роутер {self.name}: задача '{task_name}' настроена как напоминание о событии '{event_type}' за {delay} ({default_delay_seconds}с)")
+                else:
+                    logger.info(f"⏰ Роутер {self.name}: задача '{task_name}' настроена с задержкой: {delay} ({default_delay_seconds}с)")
+            except ValueError as e:
+                logger.error(f"❌ Ошибка парсинга времени для задачи '{task_name}' в роутере {self.name}: {e}")
+                raise
+            
             self._scheduled_tasks[task_name] = {
                 'handler': func,
                 'name': func.__name__,
                 'notify': notify,
                 'smart_check': smart_check,
                 'once_only': once_only,
-                'router': self.name
+                'router': self.name,
+                'default_delay': default_delay_seconds,
+                'event_type': event_type  # Новое поле для типа события
             }
             
-            logger.info(f"⏰ Роутер {self.name}: зарегистрирована задача '{task_name}': {func.__name__}")
+            if event_type:
+                logger.info(f"⏰ Роутер {self.name}: зарегистрирована задача-напоминание '{task_name}' для события '{event_type}': {func.__name__}")
+            else:
+                logger.info(f"⏰ Роутер {self.name}: зарегистрирована задача '{task_name}': {func.__name__}")
             
             from functools import wraps
             @wraps(func)
@@ -90,7 +115,7 @@ class Router:
             return wrapper
         return decorator
     
-    def global_handler(self, handler_type: str, notify: bool = False, once_only: bool = True):
+    def global_handler(self, handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None):
         """
         Декоратор для регистрации глобального обработчика в роутере
         
@@ -98,14 +123,31 @@ class Router:
             handler_type: Тип глобального обработчика
             notify: Уведомлять ли админов
             once_only: Выполнять ли только один раз
+            delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
         """
         def decorator(func: Callable) -> Callable:
+            # Время ОБЯЗАТЕЛЬНО должно быть указано
+            if delay is None:
+                raise ValueError(f"Для глобального обработчика '{handler_type}' в роутере {self.name} ОБЯЗАТЕЛЬНО нужно указать параметр delay")
+            
+            # Импортируем функцию парсинга времени
+            from .decorators import parse_time_string
+            
+            # Парсим время
+            try:
+                default_delay_seconds = parse_time_string(delay)
+                logger.info(f"🌍 Роутер {self.name}: глобальный обработчик '{handler_type}' настроен с задержкой: {delay} ({default_delay_seconds}с)")
+            except ValueError as e:
+                logger.error(f"❌ Ошибка парсинга времени для глобального обработчика '{handler_type}' в роутере {self.name}: {e}")
+                raise
+            
             self._global_handlers[handler_type] = {
                 'handler': func,
                 'name': func.__name__,
                 'notify': notify,
                 'once_only': once_only,
-                'router': self.name
+                'router': self.name,
+                'default_delay': default_delay_seconds
             }
             
             logger.info(f"🌍 Роутер {self.name}: зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")
@@ -120,7 +162,7 @@ class Router:
                     raise
             return wrapper
         return decorator
-    
+
     def get_event_handlers(self) -> Dict[str, Dict[str, Any]]:
         """Получает все обработчики событий роутера"""
         return self._event_handlers.copy()
@@ -169,5 +211,4 @@ class Router:
         logger.info(f"🔗 Роутер {self.name}: включен роутер {router.name}")
     
     def __repr__(self):
-        return f"Router(name='{self.name}', events={len(self._event_handlers)}, tasks={len(self._scheduled_tasks)}, globals={len(self._global_handlers)})"
-
+        return f"Router(name='{self.name}', events={len(self._event_handlers)}, tasks={len(self._scheduled_tasks)}, globals={len(self._global_handlers)})"

smart_bot_factory/core/router_manager.py

@@ -60,29 +60,41 @@ class RouterManager:
             'global_handlers': {}
         }
         
+        logger.debug(f"🔍 RouterManager._update_combined_handlers(): обновляем обработчики для {len(self._routers)} роутеров")
+        
         # Собираем обработчики из всех роутеров
         for router in self._routers:
+            logger.debug(f"🔍 Обрабатываем роутер: {router.name}")
+            
             # Обработчики событий
-            for event_type, handler_info in router.get_event_handlers().items():
+            event_handlers = router.get_event_handlers()
+            logger.debug(f"🔍 Роутер {router.name}: {len(event_handlers)} обработчиков событий")
+            for event_type, handler_info in event_handlers.items():
                 if event_type in self._combined_handlers['event_handlers']:
                     existing_router = self._combined_handlers['event_handlers'][event_type]['router']
                     logger.warning(f"⚠️ Конфликт обработчиков событий '{event_type}' между роутерами {existing_router} и {router.name}")
                 self._combined_handlers['event_handlers'][event_type] = handler_info
             
             # Запланированные задачи
-            for task_name, task_info in router.get_scheduled_tasks().items():
+            scheduled_tasks = router.get_scheduled_tasks()
+            logger.debug(f"🔍 Роутер {router.name}: {len(scheduled_tasks)} запланированных задач: {list(scheduled_tasks.keys())}")
+            for task_name, task_info in scheduled_tasks.items():
                 if task_name in self._combined_handlers['scheduled_tasks']:
                     existing_router = self._combined_handlers['scheduled_tasks'][task_name]['router']
                     logger.warning(f"⚠️ Конфликт задач '{task_name}' между роутерами {existing_router} и {router.name}")
                 self._combined_handlers['scheduled_tasks'][task_name] = task_info
             
             # Глобальные обработчики
-            for handler_type, handler_info in router.get_global_handlers().items():
+            global_handlers = router.get_global_handlers()
+            logger.debug(f"🔍 Роутер {router.name}: {len(global_handlers)} глобальных обработчиков")
+            for handler_type, handler_info in global_handlers.items():
                 if handler_type in self._combined_handlers['global_handlers']:
                     existing_router = self._combined_handlers['global_handlers'][handler_type]['router']
                     logger.warning(f"⚠️ Конфликт глобальных обработчиков '{handler_type}' между роутерами {existing_router} и {router.name}")
                 self._combined_handlers['global_handlers'][handler_type] = handler_info
         
+        logger.debug(f"🔍 RouterManager._update_combined_handlers(): итого - {len(self._combined_handlers['scheduled_tasks'])} задач: {list(self._combined_handlers['scheduled_tasks'].keys())}")
+        
         total_handlers = (len(self._combined_handlers['event_handlers']) + 
                          len(self._combined_handlers['scheduled_tasks']) + 
                          len(self._combined_handlers['global_handlers']))
@@ -95,7 +107,9 @@ class RouterManager:
     
     def get_scheduled_tasks(self) -> Dict[str, Dict[str, Any]]:
         """Получает все запланированные задачи"""
-        return self._combined_handlers['scheduled_tasks'].copy()
+        tasks = self._combined_handlers['scheduled_tasks'].copy()
+        logger.debug(f"🔍 RouterManager.get_scheduled_tasks(): возвращаем {len(tasks)} задач: {list(tasks.keys())}")
+        return tasks
     
     def get_global_handlers(self) -> Dict[str, Dict[str, Any]]:
         """Получает все глобальные обработчики"""

smart_bot_factory/creation/bot_builder.py

@@ -383,11 +383,16 @@ class BotBuilder:
             # Устанавливаем глобальные переменные в модуле бота для удобного доступа
             self.set_global_vars_in_module(self.bot_id)
             
-            
-            # Устанавливаем роутер-менеджер в декораторы
+            # Устанавливаем роутер-менеджер в декораторы ПЕРЕД настройкой обработчиков
             if self.router_manager:
                 from ..core.decorators import set_router_manager
                 set_router_manager(self.router_manager)
+                logger.info("✅ RouterManager установлен в decorators")
+                
+                # Обновляем обработчики после установки RouterManager
+                # (на случай если декораторы выполнялись после добавления роутера)
+                self.router_manager._update_combined_handlers()
+                logger.info("✅ RouterManager обработчики обновлены")
             
             # Фоновые задачи выполняются через asyncio.create_task в decorators.py
             

smart_bot_factory/handlers/handlers.py

@@ -64,6 +64,116 @@ async def start_handler(message: Message, state: FSMContext):
         logger.error(f"Ошибка при обработке /start: {e}")
         await send_message(message, "Произошла ошибка при инициализации. Попробуйте позже.")
 
+@router.message(Command(commands=["timeup"]))
+async def timeup_handler(message: Message, state: FSMContext):
+    """Обработчик команды /timeup - тестирование запланированных событий"""
+    from ..core.decorators import process_scheduled_event, update_event_result
+    from datetime import datetime
+    
+    supabase_client = get_global_var('supabase_client')
+    
+    try:
+        await message.answer("🔄 Запускаю тестирование запланированных событий...")
+        
+        # Получаем события для этого пользователя И глобальные события (user_id = null)
+        # 1. События пользователя
+        user_events = supabase_client.client.table('scheduled_events').select(
+            '*'
+        ).eq('user_id', message.from_user.id).in_('status', ['pending', 'immediate']).execute()
+        
+        # 2. Глобальные события (без user_id)
+        global_events = supabase_client.client.table('scheduled_events').select(
+            '*'
+        ).is_('user_id', 'null').in_('status', ['pending', 'immediate']).execute()
+        
+        # Объединяем события
+        all_events = (user_events.data or []) + (global_events.data or [])
+        
+        if not all_events:
+            await message.answer("📭 Нет запланированных событий для тестирования")
+            return
+        
+        total_events = len(all_events)
+        user_count = len(user_events.data or [])
+        global_count = len(global_events.data or [])
+        
+        status_msg = f"📋 Найдено {total_events} событий:"
+        if user_count > 0:
+            status_msg += f"\n   👤 Ваших: {user_count}"
+        if global_count > 0:
+            status_msg += f"\n   🌍 Глобальных: {global_count}"
+        status_msg += "\n\nВыполняю их немедленно..."
+        
+        await message.answer(status_msg)
+        
+        # Выполняем каждое событие
+        success_count = 0
+        failed_count = 0
+        results = []
+        
+        for event in all_events:
+            event_id = event['id']
+            event_type = event['event_type']
+            event_category = event['event_category']
+            is_global = event.get('user_id') is None
+            
+            try:
+                event_label = f"🌍 {event_type}" if is_global else f"👤 {event_type}"
+                logger.info(f"🧪 Тестируем событие {event_id}: {event_category}/{event_type} ({'глобальное' if is_global else f'пользователя {message.from_user.id}'})")
+                
+                # Выполняем событие
+                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} успешно выполнено")
+                
+            except Exception as e:
+                failed_count += 1
+                error_msg = str(e)
+                event_label = f"🌍 {event_type}" if is_global else f"👤 {event_type}"
+                results.append(f"❌ {event_label}: {error_msg[:50]}")
+                logger.error(f"❌ Ошибка выполнения события {event_id}: {error_msg}")
+                
+                # Помечаем как failed
+                await update_event_result(event_id, 'failed', None, error_msg)
+        
+        # Отправляем итоговую статистику
+        result_text = [
+            "📊 **Результаты тестирования:**",
+            "",
+            f"✅ Успешно: {success_count}",
+            f"❌ Ошибок: {failed_count}",
+            f"📋 Всего: {total_events}",
+            "",
+            "**События:**",
+            f"👤 - ваши события",
+            f"🌍 - глобальные события",
+            ""
+        ]
+        
+        # Добавляем результаты (максимум 10 событий)
+        for result in results[:10]:
+            result_text.append(result)
+        
+        if len(results) > 10:
+            result_text.append(f"... и еще {len(results) - 10} событий")
+        
+        await message.answer("\n".join(result_text))
+        
+    except Exception as e:
+        logger.error(f"❌ Критическая ошибка в timeup_handler: {e}")
+        await message.answer(f"❌ Ошибка тестирования: {str(e)}")
+
+
 async def user_start_handler(message: Message, state: FSMContext):
     """Обработчик /start для обычных пользователей"""
     supabase_client = get_global_var('supabase_client')

smart_bot_factory/integrations/supabase_client.py

@@ -805,31 +805,21 @@ class SupabaseClient:
             return {}
 
     async def get_user_last_message_info(self, user_id: int) -> Optional[Dict[str, Any]]:
-        """Получает информацию о последнем сообщении пользователя"""
+        """Получает информацию о последней активности пользователя из сессии"""
         try:
-            # Получаем последнее сообщение пользователя
-            response = self.client.table('sales_messages').select(
-                'id', 'created_at', 'session_id', 'sender_type'
-            ).eq('sender_telegram_id', user_id).order('created_at', desc=True).limit(1).execute()
+            # Получаем последнюю сессию пользователя
+            response = self.client.table('sales_chat_sessions').select(
+                'id', 'current_stage', 'created_at', 'updated_at'
+            ).eq('user_id', user_id).order('updated_at', desc=True).limit(1).execute()
             
             if not response.data:
                 return None
             
-            last_message = response.data[0]
-            
-            # Получаем информацию о сессии
-            session_response = self.client.table('sales_chat_sessions').select(
-                'id', 'current_stage', 'updated_at'
-            ).eq('id', last_message['session_id']).execute()
-            
-            if not session_response.data:
-                return None
-            
-            session = session_response.data[0]
+            session = response.data[0]
             
             return {
-                'last_message_at': last_message['created_at'],
-                'session_id': last_message['session_id'],
+                'last_message_at': session['updated_at'],
+                'session_id': session['id'],
                 'current_stage': session['current_stage'],
                 'session_updated_at': session['updated_at']
             }
@@ -842,21 +832,91 @@ class SupabaseClient:
         """Проверяет, изменился ли этап пользователя с момента планирования события"""
         try:
             # Получаем текущую информацию о сессии
-            response = self.client.table('sales_chat_sessions').select(
+            current_response = self.client.table('sales_chat_sessions').select(
                 'id', 'current_stage'
             ).eq('user_telegram_id', user_id).order('created_at', desc=True).limit(1).execute()
             
-            if not response.data:
+            if not current_response.data:
                 return False
             
-            current_session = response.data[0]
+            current_session = current_response.data[0]
             
             # Если сессия изменилась - этап точно изменился
             if current_session['id'] != original_session_id:
                 return True
             
+            # Если сессия та же, получаем оригинальный этап из scheduled_events
+            # и сравниваем с текущим
+            original_response = self.client.table('sales_chat_sessions').select(
+                'current_stage'
+            ).eq('id', original_session_id).execute()
+            
+            if not original_response.data:
+                # Если не нашли оригинальную сессию, считаем что этап не изменился
+                return False
+            
+            original_stage = original_response.data[0]['current_stage']
+            current_stage = current_session['current_stage']
+            
+            # Проверяем, изменился ли этап внутри той же сессии
+            if original_stage != current_stage:
+                logger.info(f"🔄 Этап изменился: {original_stage} -> {current_stage} (сессия {original_session_id})")
+                return True
+            
             return False
             
         except Exception as e:
             logger.error(f"Ошибка проверки изменения этапа пользователя {user_id}: {e}")
-            return False
+            return False
+
+    async def get_last_event_info_by_user_and_type(self, user_id: int, event_type: str) -> Optional[str]:
+        """
+        Получает event_info последнего события определенного типа для пользователя
+        
+        Args:
+            user_id: Telegram ID пользователя
+            event_type: Тип события для поиска
+            
+        Returns:
+            str: event_info последнего найденного события или None если не найдено
+        """
+        try:
+            # 1. Получаем последнюю сессию пользователя
+            sessions_query = self.client.table('sales_chat_sessions').select(
+                'id'
+            ).eq('user_id', user_id).order('created_at', desc=True).limit(1)
+            
+            # Фильтруем по bot_id если указан
+            if self.bot_id:
+                sessions_query = sessions_query.eq('bot_id', self.bot_id)
+            
+            sessions_response = sessions_query.execute()
+            
+            if not sessions_response.data:
+                logger.info(f"Пользователь {user_id} не найден в сессиях")
+                return None
+            
+            session_id = sessions_response.data[0]['id']
+            logger.info(f"Найдена последняя сессия {session_id} для пользователя {user_id}")
+            
+            # 2. Ищем последнее событие с этим session_id и event_type
+            events_response = self.client.table('session_events').select(
+                'event_info', 'created_at'
+            ).eq('session_id', session_id).eq('event_type', event_type).order(
+                'created_at', desc=True
+            ).limit(1).execute()
+            
+            if not events_response.data:
+                logger.info(f"События типа '{event_type}' не найдены для сессии {session_id}")
+                return None
+            
+            event_info = events_response.data[0]['event_info']
+            created_at = events_response.data[0]['created_at']
+            
+            logger.info(f"Найдено последнее событие '{event_type}' для пользователя {user_id}: {event_info[:50]}... (создано: {created_at})")
+            
+            return event_info
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения последнего события для пользователя {user_id}, тип '{event_type}': {e}")
+            return None