smart-bot-factory 0.2.10__py3-none-any.whl → 0.3.1__py3-none-any.whl

smart_bot_factory/core/decorators.py

@@ -11,6 +11,38 @@ from functools import wraps
 
 logger = logging.getLogger(__name__)
 
+def format_seconds_to_human(seconds: int) -> str:
+    """
+    Форматирует секунды в человекочитаемый формат
+    
+    Args:
+        seconds: Количество секунд
+    
+    Returns:
+        str: Человекочитаемое время
+    
+    Examples:
+        format_seconds_to_human(3600) -> "1ч 0м"
+        format_seconds_to_human(5445) -> "1ч 30м"
+        format_seconds_to_human(102461) -> "1д 4ч 28м"
+    """
+    if seconds < 60:
+        return f"{seconds}с"
+    
+    days = seconds // 86400
+    hours = (seconds % 86400) // 3600
+    minutes = (seconds % 3600) // 60
+    
+    parts = []
+    if days > 0:
+        parts.append(f"{days}д")
+    if hours > 0:
+        parts.append(f"{hours}ч")
+    if minutes > 0:
+        parts.append(f"{minutes}м")
+    
+    return " ".join(parts) if parts else "0м"
+
 def parse_time_string(time_str: Union[str, int]) -> int:
     """
     Парсит время в удобном формате и возвращает секунды
@@ -403,7 +435,7 @@ def event_handler(event_type: str, notify: bool = False, once_only: bool = True)
         return wrapper
     return decorator
 
-def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: str = None):
+def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
     """
     Декоратор для регистрации задачи, которую можно запланировать на время
     
@@ -413,7 +445,9 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
         smart_check: Использовать ли умную проверку активности пользователя (по умолчанию True)
         once_only: Выполнять ли задачу только один раз (по умолчанию True)
         delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
-        event_type: Тип события для напоминания (например, 'appointment_booking') - ОПЦИОНАЛЬНО
+        event_type: Источник времени события - ОПЦИОНАЛЬНО:
+            - str: Тип события для поиска в БД (например, 'appointment_booking')
+            - Callable: Функция для получения datetime (например, async def(user_id, user_data) -> datetime)
     
     Example:
         # Обычная задача с фиксированным временем
@@ -422,17 +456,25 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
             # Задача будет запланирована на 1 час 30 минут
             return {"status": "sent", "message": user_data}
         
-        # Напоминание о событии (за delay времени до события)
+        # Напоминание о событии из БД (за delay времени до события)
         @schedule_task("appointment_reminder", delay="2h", event_type="appointment_booking")
         async def appointment_reminder(user_id: int, user_data: str):
-            # Напоминание будет отправлено за 2 часа до события appointment_booking
+            # Ищет событие "appointment_booking" в БД
+            # Напоминание будет за 2 часа до времени из события
             return {"status": "sent", "message": user_data}
         
-        # Напоминание о процедуре
-        @schedule_task("procedure_reminder", delay="1d", event_type="procedure_booking")
-        async def procedure_reminder(user_id: int, user_data: str):
-            # Напоминание будет отправлено за 1 день до процедуры
-            return {"status": "sent", "message": user_data}
+        # Напоминание с кастомной функцией получения времени
+        async def get_yclients_appointment_time(user_id: int, user_data: str) -> datetime:
+            '''Получает время записи из YClients API'''
+            from yclients_api import get_next_booking
+            booking = await get_next_booking(user_id)
+            return booking['datetime']  # datetime объект
+        
+        @schedule_task("yclients_reminder", delay="1h", event_type=get_yclients_appointment_time)
+        async def yclients_reminder(user_id: int, user_data: str):
+            # Вызовет get_yclients_appointment_time(user_id, user_data)
+            # Напоминание будет за 1 час до возвращенного datetime
+            return {"status": "sent"}
         
         # Форматы времени:
         # delay="1h 30m 45s" - 1 час 30 минут 45 секунд
@@ -442,7 +484,7 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
         
         # ИИ может передавать только данные (текст):
         # {"тип": "send_reminder", "инфо": "Текст напоминания"} - только текст
-        # {"тип": "appointment_reminder", "инфо": ""} - пустой текст, время берется из события
+        # {"тип": "appointment_reminder", "инфо": ""} - пустой текст, время берется из события/функции
     """
     def decorator(func: Callable) -> Callable:
         # Время ОБЯЗАТЕЛЬНО должно быть указано
@@ -501,7 +543,7 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
         return wrapper
     return decorator
 
-def global_handler(handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None):
+def global_handler(handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
     """
     Декоратор для регистрации глобального обработчика (для всех пользователей)
     
@@ -510,6 +552,9 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
         notify: Уведомлять ли админов о выполнении (по умолчанию False)
         once_only: Выполнять ли обработчик только один раз (по умолчанию True)
         delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
+        event_type: Источник времени события - ОПЦИОНАЛЬНО:
+            - str: Тип события для поиска в БД
+            - Callable: Функция для получения datetime (например, async def(handler_data: str) -> datetime)
     
     Example:
         # Глобальный обработчик с задержкой
@@ -524,6 +569,18 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
             # Может запускаться каждый день через 24 часа
             return {"status": "sent", "report_type": "daily"}
         
+        # С кастомной функцией для получения времени
+        async def get_promo_end_time(handler_data: str) -> datetime:
+            '''Получает время окончания акции из CRM'''
+            from crm_api import get_active_promo
+            promo = await get_active_promo()
+            return promo['end_datetime']
+        
+        @global_handler("promo_ending_notification", delay="2h", event_type=get_promo_end_time)
+        async def notify_promo_ending(handler_data: str):
+            # Уведомление за 2 часа до окончания акции
+            return {"status": "sent"}
+        
         # Форматы времени:
         # delay="1h 30m 45s" - 1 час 30 минут 45 секунд
         # delay="2h" - 2 часа
@@ -532,7 +589,7 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
         
         # ИИ может передавать только данные (текст):
         # {"тип": "global_announcement", "инфо": "Важное объявление!"} - только текст
-        # {"тип": "global_announcement", "инфо": ""} - пустой текст
+        # {"тип": "global_announcement", "инфо": ""} - пустой текст, время из функции
     """
     def decorator(func: Callable) -> Callable:
         # Время ОБЯЗАТЕЛЬНО должно быть указано
@@ -552,7 +609,8 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
             'name': func.__name__,
             'notify': notify,
             'once_only': once_only,
-            'default_delay': default_delay_seconds
+            'default_delay': default_delay_seconds,
+            'event_type': event_type  # Добавляем event_type для глобальных обработчиков
         }
         
         logger.info(f"🌍 Зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")
@@ -755,76 +813,107 @@ async def execute_scheduled_task_from_event(user_id: int, task_name: str, event_
     if default_delay is None:
         raise ValueError(f"Для задачи '{task_name}' не указано время в декораторе (параметр delay)")
     
-    # event_info содержит только текст для задачи
-    user_data = event_info.strip() if event_info else f"Напоминание через {default_delay} секунд"
+    # event_info содержит только текст для задачи (если ИИ не передал - пустая строка)
+    user_data = event_info.strip() if event_info else ""
     
     # Если указан event_type, то это напоминание о событии
     if event_type:
-        logger.info(f"⏰ Задача '{task_name}' - напоминание о событии '{event_type}' за {default_delay}с")
-        
-        # Получаем клиент Supabase
-        supabase_client = get_supabase_client()
-        if not supabase_client:
-            raise RuntimeError("Supabase клиент не найден для получения времени события")
+        event_datetime = None
         
-        try:
-            # Получаем данные события
-            event_data_str = await supabase_client.get_last_event_info_by_user_and_type(user_id, event_type)
+        # ========== ПРОВЕРЯЕМ ТИП event_type: СТРОКА ИЛИ ФУНКЦИЯ ==========
+        if callable(event_type):
+            # ВАРИАНТ 2: Функция - вызываем для получения datetime
+            logger.info(f"⏰ Задача '{task_name}' - вызываем функцию для получения времени события")
             
-            if not event_data_str:
-                logger.warning(f"Событие '{event_type}' не найдено для пользователя {user_id}")
+            try:
+                # Вызываем функцию пользователя с теми же аргументами что у обработчика
+                event_datetime = await event_type(user_id, user_data)
+                
+                if not isinstance(event_datetime, datetime):
+                    raise ValueError(f"Функция event_type должна вернуть datetime, получен {type(event_datetime)}")
+                
+                logger.info(f"✅ Функция вернула время события: {event_datetime}")
+                
+            except Exception as e:
+                logger.error(f"❌ Ошибка в функции event_type: {e}")
                 # Fallback - планируем через default_delay
                 result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
                 return result
+        
+        else:
+            # ВАРИАНТ 1: Строка - ищем событие в БД (текущая логика)
+            logger.info(f"⏰ Задача '{task_name}' - напоминание о событии '{event_type}' за {default_delay}с")
             
-            # Парсим данные события
-            event_data = parse_appointment_data(event_data_str)
+            # Получаем клиент Supabase
+            supabase_client = get_supabase_client()
+            if not supabase_client:
+                raise RuntimeError("Supabase клиент не найден для получения времени события")
             
-            if 'datetime' not in event_data:
-                logger.warning(f"Не удалось распарсить дату/время из события '{event_type}'")
+            try:
+                # Получаем данные события из БД
+                event_data_str = await supabase_client.get_last_event_info_by_user_and_type(user_id, event_type)
+                
+                if not event_data_str:
+                    logger.warning(f"Событие '{event_type}' не найдено для пользователя {user_id}")
+                    # Fallback - планируем через default_delay
+                    result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
+                    return result
+                
+                # Парсим данные события
+                event_data = parse_appointment_data(event_data_str)
+                
+                if 'datetime' not in event_data:
+                    logger.warning(f"Не удалось распарсить дату/время из события '{event_type}'")
+                    # Fallback - планируем через default_delay
+                    result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
+                    return result
+                
+                event_datetime = event_data['datetime']
+                logger.info(f"✅ Получено время события из БД: {event_datetime}")
+                
+            except Exception as e:
+                logger.error(f"❌ Ошибка получения события из БД: {e}")
                 # Fallback - планируем через default_delay
                 result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
                 return result
-            
-            event_datetime = event_data['datetime']
-            now = datetime.now()
-            
-            # Вычисляем время напоминания (за default_delay до события)
-            reminder_datetime = event_datetime - timedelta(seconds=default_delay)
-            
-            # Проверяем, не в прошлом ли напоминание
-            if reminder_datetime <= now:
-                logger.warning(f"Напоминание о событии '{event_type}' уже в прошлом, отправляем немедленно")
-                # Выполняем задачу немедленно
-                result = await execute_scheduled_task(task_name, user_id, user_data)
-                return {
-                    "status": "executed_immediately",
-                    "task_name": task_name,
-                    "reason": "reminder_time_passed",
-                    "event_datetime": event_datetime.isoformat(),
-                    "result": result
-                }
-            
-            # Вычисляем задержку до напоминания
-            delay_seconds = int((reminder_datetime - now).total_seconds())
-            
-            logger.info(f"⏰ Планируем напоминание '{task_name}' за {default_delay}с до события '{event_type}' (через {delay_seconds}с)")
-            
-            # Планируем напоминание
-            result = await schedule_task_for_later_with_db(task_name, user_id, user_data, delay_seconds, session_id)
-            result['event_datetime'] = event_datetime.isoformat()
-            result['reminder_type'] = 'event_reminder'
-            
-            return result
-            
-        except Exception as e:
-            logger.error(f"Ошибка при работе с событием '{event_type}': {e}")
-            # Fallback - планируем через default_delay
-            result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
-            return result
+        
+        # ========== ОБЩАЯ ЛОГИКА ДЛЯ ОБОИХ ВАРИАНТОВ ==========
+        # Теперь у нас есть event_datetime (из БД или из функции)
+        now = datetime.now()
+        
+        # Вычисляем время напоминания (за default_delay до события)
+        reminder_datetime = event_datetime - timedelta(seconds=default_delay)
+        
+        # Проверяем, не в прошлом ли напоминание
+        if reminder_datetime <= now:
+            logger.warning(f"Напоминание уже в прошлом, отправляем немедленно")
+            # Выполняем задачу немедленно
+            result = await execute_scheduled_task(task_name, user_id, user_data)
+            return {
+                "status": "executed_immediately",
+                "task_name": task_name,
+                "reason": "reminder_time_passed",
+                "event_datetime": event_datetime.isoformat(),
+                "result": result
+            }
+        
+        # Вычисляем задержку до напоминания
+        delay_seconds = int((reminder_datetime - now).total_seconds())
+        
+        event_source = "функции" if callable(task_info.get('event_type')) else f"события '{event_type}'"
+        human_time = format_seconds_to_human(delay_seconds)
+        logger.info(f"⏰ Планируем напоминание '{task_name}' за {format_seconds_to_human(default_delay)} до {event_source} (через {human_time} / {delay_seconds}с)")
+        
+        # Планируем напоминание
+        result = await schedule_task_for_later_with_db(task_name, user_id, user_data, delay_seconds, session_id)
+        result['event_datetime'] = event_datetime.isoformat()
+        result['reminder_type'] = 'event_reminder'
+        
+        return result
     else:
         # Обычная задача с фиксированным временем
-        logger.info(f"⏰ Планируем задачу '{task_name}' через {default_delay}с с текстом: '{user_data}'")
+        human_time = format_seconds_to_human(default_delay)
+        logger.info(f"⏰ Планируем задачу '{task_name}' через {human_time} ({default_delay}с) с текстом: '{user_data}'")
         
         # Планируем задачу на фоне с сохранением в БД
         result = await schedule_task_for_later_with_db(task_name, user_id, user_data, default_delay, session_id)
@@ -877,7 +966,7 @@ async def execute_global_handler_from_event(handler_type: str, event_info: str):
     
     Args:
         handler_type: Тип глобального обработчика
-        event_info: Информация от ИИ (только текст, время задается в декораторе)
+        event_info: Информация от ИИ (только текст, время задается в декораторе или функции)
     """
     router_manager = get_router_manager()
     if router_manager:
@@ -890,20 +979,87 @@ async def execute_global_handler_from_event(handler_type: str, event_info: str):
     
     handler_info = global_handlers[handler_type]
     default_delay = handler_info.get('default_delay')
+    event_type = handler_info.get('event_type')
     
     # Время всегда берется из декоратора, ИИ может передавать только текст
     if default_delay is None:
         raise ValueError(f"Для глобального обработчика '{handler_type}' не указано время в декораторе (параметр delay)")
     
-    # event_info содержит только текст для обработчика
-    handler_data = event_info.strip() if event_info else f"Глобальное событие через {default_delay} секунд"
+    # event_info содержит только текст для обработчика (если ИИ не передал - пустая строка)
+    handler_data = event_info.strip() if event_info else ""
     
-    logger.info(f"🌍 Планируем глобальный обработчик '{handler_type}' через {default_delay}с с данными: '{handler_data}'")
-    
-    # Планируем обработчик на фоне с сохранением в БД
-    result = await schedule_global_handler_for_later_with_db(handler_type, default_delay, handler_data)
+    # Если указан event_type, вычисляем время относительно события
+    if event_type:
+        event_datetime = None
+        
+        # Проверяем тип event_type: строка или функция
+        if callable(event_type):
+            # ВАРИАНТ 2: Функция - вызываем для получения datetime
+            logger.info(f"🌍 Глобальный обработчик '{handler_type}' - вызываем функцию для получения времени")
+            
+            try:
+                # Вызываем функцию (только с handler_data для глобальных)
+                event_datetime = await event_type(handler_data)
+                
+                if not isinstance(event_datetime, datetime):
+                    raise ValueError(f"Функция event_type должна вернуть datetime, получен {type(event_datetime)}")
+                
+                logger.info(f"✅ Функция вернула время события: {event_datetime}")
+                
+            except Exception as e:
+                logger.error(f"❌ Ошибка в функции event_type: {e}")
+                # Fallback - планируем через default_delay
+                result = await schedule_global_handler_for_later_with_db(handler_type, default_delay, handler_data)
+                return result
+        
+        else:
+            # ВАРИАНТ 1: Строка - ищем в БД (можно расширить логику если нужно)
+            logger.info(f"🌍 Глобальный обработчик '{handler_type}' - event_type '{event_type}' (строка)")
+            # Для глобальных обработчиков пока просто используем default_delay
+            # Можно расширить логику если понадобится
+            result = await schedule_global_handler_for_later_with_db(handler_type, default_delay, handler_data)
+            return result
+        
+        # Общая логика для функций
+        now = datetime.now()
+        
+        # Вычисляем время напоминания (за default_delay до события)
+        reminder_datetime = event_datetime - timedelta(seconds=default_delay)
+        
+        # Проверяем, не в прошлом ли напоминание
+        if reminder_datetime <= now:
+            logger.warning(f"Напоминание глобального события уже в прошлом, выполняем немедленно")
+            # Выполняем немедленно
+            result = await execute_global_handler(handler_type, handler_data)
+            return {
+                "status": "executed_immediately",
+                "handler_type": handler_type,
+                "reason": "reminder_time_passed",
+                "event_datetime": event_datetime.isoformat(),
+                "result": result
+            }
+        
+        # Вычисляем задержку до напоминания
+        delay_seconds = int((reminder_datetime - now).total_seconds())
+        
+        human_time = format_seconds_to_human(delay_seconds)
+        logger.info(f"🌍 Планируем глобальный обработчик '{handler_type}' за {format_seconds_to_human(default_delay)} до события (через {human_time} / {delay_seconds}с)")
+        
+        # Планируем обработчик
+        result = await schedule_global_handler_for_later_with_db(handler_type, delay_seconds, handler_data)
+        result['event_datetime'] = event_datetime.isoformat()
+        result['reminder_type'] = 'global_event_reminder'
+        
+        return result
     
-    return result
+    else:
+        # Обычный глобальный обработчик с фиксированной задержкой
+        logger.info(f"🌍 Планируем глобальный обработчик '{handler_type}' через {default_delay}с с данными: '{handler_data}'")
+        
+        # Планируем обработчик на фоне с сохранением в БД
+        result = await schedule_global_handler_for_later_with_db(handler_type, default_delay, handler_data)
+        
+        return result
 
 
 # =============================================================================
@@ -941,11 +1097,17 @@ async def save_immediate_event(
         raise RuntimeError("Supabase клиент не инициализирован")
     
     # Проверяем, нужно ли предотвращать дублирование
-    event_handler_info = _event_handlers.get(event_type, {})
+    router_manager = get_router_manager()
+    if router_manager:
+        event_handlers = router_manager.get_event_handlers()
+    else:
+        event_handlers = _event_handlers
+    
+    event_handler_info = event_handlers.get(event_type, {})
     once_only = event_handler_info.get('once_only', True)
     
     if once_only:
-        # Проверяем, было ли уже обработано аналогичное событие
+        # Проверяем, было ли уже обработано аналогичное событие для этого пользователя
         already_processed = await check_event_already_processed(event_type, user_id, session_id)
         if already_processed:
             logger.info(f"🔄 Событие '{event_type}' уже обрабатывалось для пользователя {user_id}, пропускаем")
@@ -985,11 +1147,17 @@ async def save_scheduled_task(
         raise RuntimeError("Supabase клиент не инициализирован")
     
     # Проверяем, нужно ли предотвращать дублирование
-    task_info = _scheduled_tasks.get(task_name, {})
+    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(task_name, {})
     once_only = task_info.get('once_only', True)
     
     if once_only:
-        # Проверяем, была ли уже запланирована аналогичная задача
+        # Проверяем, была ли уже запланирована аналогичная задача для этого пользователя
         already_processed = await check_event_already_processed(task_name, user_id, session_id)
         if already_processed:
             logger.info(f"🔄 Задача '{task_name}' уже запланирована для пользователя {user_id}, пропускаем")
@@ -1108,7 +1276,7 @@ async def update_event_result(
         logger.error(f"❌ Ошибка обновления результата события {event_id}: {e}")
 
 async def get_pending_events(limit: int = 50) -> list:
-    """Получает события готовые к выполнению"""
+    """Получает события готовые к выполнению СЕЙЧАС"""
     
     supabase_client = get_supabase_client()
     if not supabase_client:
@@ -1131,29 +1299,145 @@ async def get_pending_events(limit: int = 50) -> list:
         logger.error(f"❌ Ошибка получения событий из БД: {e}")
         return []
 
+async def get_pending_events_in_next_minute(limit: int = 100) -> list:
+    """Получает события готовые к выполнению в течение следующей минуты"""
+    
+    supabase_client = get_supabase_client()
+    if not supabase_client:
+        logger.error("❌ Supabase клиент не найден")
+        return []
+    
+    try:
+        now = datetime.now(timezone.utc)
+        next_minute = now + timedelta(seconds=60)
+        
+        response = supabase_client.client.table('scheduled_events')\
+            .select('*')\
+            .in_('status', ['pending', 'immediate'])\
+            .or_(f'scheduled_at.is.null,scheduled_at.lte.{next_minute.isoformat()}')\
+            .order('created_at')\
+            .limit(limit)\
+            .execute()
+        
+        return response.data
+    except Exception as e:
+        logger.error(f"❌ Ошибка получения событий из БД: {e}")
+        return []
+
 async def background_event_processor():
-    """Фоновый процессор для всех типов событий"""
+    """Фоновый процессор для всех типов событий (проверяет БД каждую минуту)"""
     
     logger.info("🔄 Запуск фонового процессора событий")
     
     while True:
         try:
-            # Получаем события готовые к выполнению
-            pending_events = await get_pending_events(limit=50)
+            # Получаем события готовые к выполнению в следующую минуту
+            pending_events = await get_pending_events_in_next_minute(limit=100)
             
             if pending_events:
                 logger.info(f"📋 Найдено {len(pending_events)} событий для обработки")
                 
                 for event in pending_events:
                     try:
+                        event_type = event['event_type']
+                        event_category = event['event_category']
+                        user_id = event.get('user_id')
+                        session_id = event.get('session_id')
+                        
+                        # Для user_event - проверяем once_only
+                        if event_category == 'user_event':
+                            router_manager = get_router_manager()
+                            if router_manager:
+                                event_handlers = router_manager.get_event_handlers()
+                            else:
+                                event_handlers = _event_handlers
+                            
+                            event_handler_info = event_handlers.get(event_type, {})
+                            once_only = event_handler_info.get('once_only', True)
+                            
+                            if once_only:
+                                # Проверяем, было ли уже выполнено это событие для данного пользователя
+                                supabase_client = get_supabase_client()
+                                check_query = supabase_client.client.table('scheduled_events')\
+                                    .select('id')\
+                                    .eq('event_type', event_type)\
+                                    .eq('user_id', user_id)\
+                                    .eq('status', 'completed')\
+                                    .neq('id', event['id'])  # Исключаем текущее событие
+                                
+                                if session_id:
+                                    check_query = check_query.eq('session_id', session_id)
+                                
+                                existing = check_query.execute()
+                                
+                                if existing.data:
+                                    await update_event_result(event['id'], 'cancelled', {"reason": "already_executed_once_only"})
+                                    logger.info(f"⛔ Событие {event['id']} ({event_type}) пропущено: уже выполнялось для пользователя {user_id} (once_only=True)")
+                                    continue
+                        
+                        # Для scheduled_task - проверяем smart_check и once_only
+                        if event_category == 'scheduled_task':
+                            router_manager = get_router_manager()
+                            scheduled_tasks = router_manager.get_scheduled_tasks() if router_manager else _scheduled_tasks
+                            task_info = scheduled_tasks.get(event_type, {})
+                            use_smart_check = task_info.get('smart_check', True)
+                            once_only = task_info.get('once_only', True)
+                            
+                            # Проверяем once_only для задач
+                            if once_only:
+                                supabase_client = get_supabase_client()
+                                check_query = supabase_client.client.table('scheduled_events')\
+                                    .select('id')\
+                                    .eq('event_type', event_type)\
+                                    .eq('user_id', user_id)\
+                                    .eq('status', 'completed')\
+                                    .neq('id', event['id'])
+                                
+                                if session_id:
+                                    check_query = check_query.eq('session_id', session_id)
+                                
+                                existing = check_query.execute()
+                                
+                                if existing.data:
+                                    await update_event_result(event['id'], 'cancelled', {"reason": "already_executed_once_only"})
+                                    logger.info(f"⛔ Задача {event['id']} ({event_type}) пропущена: уже выполнялась для пользователя {user_id} (once_only=True)")
+                                    continue
+                            
+                            if use_smart_check:
+                                # Умная проверка
+                                check_result = await smart_execute_check(
+                                    event['id'], 
+                                    user_id, 
+                                    session_id,
+                                    event_type,
+                                    event['event_data']
+                                )
+                                
+                                if check_result['action'] == 'cancel':
+                                    await update_event_result(event['id'], 'cancelled', {"reason": check_result['reason']})
+                                    logger.info(f"⛔ Задача {event['id']} отменена: {check_result['reason']}")
+                                    continue
+                                elif check_result['action'] == 'reschedule':
+                                    # Обновляем scheduled_at в БД
+                                    new_scheduled_at = datetime.now(timezone.utc) + timedelta(seconds=check_result['new_delay'])
+                                    supabase_client = get_supabase_client()
+                                    supabase_client.client.table('scheduled_events').update({
+                                        'scheduled_at': new_scheduled_at.isoformat(),
+                                        'status': 'pending'
+                                    }).eq('id', event['id']).execute()
+                                    logger.info(f"🔄 Задача {event['id']} перенесена на {check_result['new_delay']}с")
+                                    continue
+                        
+                        # Выполняем событие
                         await process_scheduled_event(event)
                         await update_event_result(event['id'], 'completed', {"processed": True})
+                        logger.info(f"✅ Событие {event['id']} выполнено")
                         
                     except Exception as e:
                         logger.error(f"❌ Ошибка обработки события {event['id']}: {e}")
                         await update_event_result(event['id'], 'failed', None, str(e))
             
-            await asyncio.sleep(60)
+            await asyncio.sleep(60)  # Проверяем каждую минуту
             
         except Exception as e:
             logger.error(f"❌ Ошибка в фоновом процессоре: {e}")
@@ -1183,7 +1467,7 @@ async def process_scheduled_event(event: Dict):
 # =============================================================================
 
 async def schedule_task_for_later_with_db(task_name: str, user_id: int, user_data: str, delay_seconds: int, session_id: str = None):
-    """Планирует выполнение задачи через указанное время с сохранением в БД"""
+    """Планирует выполнение задачи через указанное время с сохранением в БД (без asyncio.sleep)"""
     
     # Проверяем через RouterManager или fallback к старым декораторам
     router_manager = get_router_manager()
@@ -1200,53 +1484,13 @@ async def schedule_task_for_later_with_db(task_name: str, user_id: int, user_dat
         logger.error(f"❌ [decorators.py:{line_no}] Задача '{task_name}' не найдена. Доступные: {available_tasks}")
         raise ValueError(f"Задача '{task_name}' не найдена")
     
-    logger.info(f"⏰ Планируем задачу '{task_name}' через {delay_seconds} секунд")
+    human_time = format_seconds_to_human(delay_seconds)
+    logger.info(f"⏰ Планируем задачу '{task_name}' через {human_time} ({delay_seconds}с) для user_id={user_id}")
     
-    # Сохраняем в БД
+    # Просто сохраняем в БД - фоновый процессор сам выполнит задачу
     event_id = await save_scheduled_task(task_name, user_id, user_data, delay_seconds, session_id)
     
-    async def delayed_task():
-        await asyncio.sleep(delay_seconds)
-        
-        # Получаем информацию о задаче
-        task_info = scheduled_tasks.get(task_name, {})
-        use_smart_check = task_info.get('smart_check', True)
-        
-        if use_smart_check:
-            # Умная проверка перед выполнением
-            try:
-                result = await smart_execute_check(event_id, user_id, session_id, task_name, user_data)
-                if result['action'] == 'execute':
-                    await execute_scheduled_task(task_name, user_id, user_data)
-                    await update_event_result(event_id, 'completed', {"executed": True, "reason": "scheduled_execution"})
-                elif result['action'] == 'cancel':
-                    await update_event_result(event_id, 'cancelled', {"reason": result['reason']})
-                elif result['action'] == 'reschedule':
-                    # Перепланируем задачу на новое время
-                    new_delay = result['new_delay']
-                    await update_event_result(event_id, 'rescheduled', {
-                        "new_delay": new_delay,
-                        "reason": result['reason']
-                    })
-                    # Запускаем новую задачу
-                    await asyncio.sleep(new_delay)
-                    await execute_scheduled_task(task_name, user_id, user_data)
-                    await update_event_result(event_id, 'completed', {"executed": True, "reason": "rescheduled_execution"})
-                    
-            except Exception as e:
-                await update_event_result(event_id, 'failed', None, str(e))
-                raise
-        else:
-            # Простое выполнение без умной проверки
-            try:
-                await execute_scheduled_task(task_name, user_id, user_data)
-                await update_event_result(event_id, 'completed', {"executed": True, "reason": "simple_execution"})
-            except Exception as e:
-                await update_event_result(event_id, 'failed', None, str(e))
-                raise
-    
-    # Запускаем задачу в фоне
-    asyncio.create_task(delayed_task())
+    logger.info(f"💾 Задача '{task_name}' сохранена в БД с ID {event_id}, будет обработана фоновым процессором")
     
     return {
         "status": "scheduled",
@@ -1257,7 +1501,7 @@ async def schedule_task_for_later_with_db(task_name: str, user_id: int, user_dat
     }
 
 async def schedule_global_handler_for_later_with_db(handler_type: str, delay_seconds: int, handler_data: str):
-    """Планирует выполнение глобального обработчика через указанное время с сохранением в БД"""
+    """Планирует выполнение глобального обработчика через указанное время с сохранением в БД (без asyncio.sleep)"""
     
     # Проверяем обработчик через RouterManager или fallback к старым декораторам
     router_manager = get_router_manager()
@@ -1271,20 +1515,10 @@ async def schedule_global_handler_for_later_with_db(handler_type: str, delay_sec
     
     logger.info(f"🌍 Планируем глобальный обработчик '{handler_type}' через {delay_seconds} секунд")
     
-    # Сохраняем в БД
+    # Просто сохраняем в БД - фоновый процессор сам выполнит обработчик
     event_id = await save_global_event(handler_type, handler_data, delay_seconds)
     
-    async def delayed_global_handler():
-        await asyncio.sleep(delay_seconds)
-        try:
-            await execute_global_handler(handler_type, handler_data)
-            await update_event_result(event_id, 'completed', {"executed": True})
-        except Exception as e:
-            await update_event_result(event_id, 'failed', None, str(e))
-            raise
-    
-    # Запускаем задачу в фоне
-    asyncio.create_task(delayed_global_handler())
+    logger.info(f"💾 Глобальный обработчик '{handler_type}' сохранен в БД с ID {event_id}, будет обработан фоновым процессором")
     
     return {
         "status": "scheduled",