smart-bot-factory 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

smart_bot_factory/core/bot_utils.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+import re
 from datetime import datetime
 from aiogram import Router
 from aiogram.filters import Command
@@ -13,7 +14,13 @@ from aiogram.types import (
 from aiogram.utils.media_group import MediaGroupBuilder
 
 from pathlib import Path
-from ..core.decorators import execute_event_handler, execute_scheduled_task
+from ..core.decorators import (
+    execute_event_handler, 
+    save_immediate_event,
+    schedule_task_for_later_with_db,
+    schedule_global_handler_for_later_with_db,
+    update_event_result
+)
 
 # Функция для получения глобальных переменных
 def get_global_var(var_name):
@@ -24,6 +31,46 @@ def get_global_var(var_name):
 
 logger = logging.getLogger(__name__)
 
+def parse_time_expression(time_text: str) -> int:
+    """
+    Парсит временные выражения и возвращает количество секунд
+    
+    Поддерживаемые форматы:
+    - "30" -> 30 секунд (основной формат)
+    - "Запуск через 30 секунд" -> 30 секунд
+    - "через 5 минут" -> 300 секунд
+    - "через 1 час" -> 3600 секунд
+    - "через 2 часа" -> 7200 секунд
+    """
+    # Сначала пробуем простое число (основной формат)
+    try:
+        return int(time_text)
+    except ValueError:
+        pass
+    
+    # Убираем лишние символы и приводим к нижнему регистру
+    text = re.sub(r'[^\w\s\d]', '', time_text.lower())
+    
+    # Ищем числа в тексте
+    numbers = re.findall(r'\d+', text)
+    if not numbers:
+        raise ValueError(f"Не найдено число в выражении: {time_text}")
+    
+    number = int(numbers[0])
+    
+    # Определяем единицу времени
+    if 'секунд' in text:
+        return number
+    elif 'минут' in text:
+        return number * 60
+    elif 'час' in text:
+        return number * 3600
+    elif 'день' in text or 'дней' in text:
+        return number * 86400
+    else:
+        # По умолчанию считаем секундами
+        return number
+
 # Создаем роутер для общих команд
 utils_router = Router()
 
@@ -182,32 +229,111 @@ async def process_events(session_id: str, events: list, user_id: int):
             logger.info(f"   📝 Тип: {event_type}")
             logger.info(f"   📄 Данные: {event_info}")
             
-            # Сохраняем в БД
-            await supabase_client.add_session_event(session_id, event_type, event_info)
-            logger.info(f"   ✅ Событие сохранено в БД")
+            # Определяем категорию события и сохраняем в БД
+            event_id = None
+            should_execute_immediately = False
+            should_notify = False
             
-            # Уведомляем админов
-            await notify_admins_about_event(user_id, event)
-            logger.info(f"   ✅ Админы уведомлены")
-            
-            # Вызываем зарегистрированный обработчик события или задачи
             try:
+                # Проверяем зарегистрированные обработчики через роутер-менеджер
+                from ..core.decorators import get_router_manager, _event_handlers, _scheduled_tasks, _global_handlers
+                
+                # Получаем обработчики из роутеров или fallback к старым декораторам
+                router_manager = get_router_manager()
+                if router_manager:
+                    event_handlers = router_manager.get_event_handlers()
+                    scheduled_tasks = router_manager.get_scheduled_tasks()
+                    global_handlers = router_manager.get_global_handlers()
+                else:
+                    event_handlers = _event_handlers
+                    scheduled_tasks = _scheduled_tasks
+                    global_handlers = _global_handlers
+                
                 # Сначала пробуем как обычное событие
-                try:
-                    logger.info(f"   🎯 Вызываем обработчик события '{event_type}'")
-                    result = await execute_event_handler(event_type, user_id, event_info)
-                    logger.info(f"   ✅ Обработчик события вернул: {result}")
-                except ValueError:
-                    # Если обработчик события не найден, пробуем как запланированную задачу
-                    logger.info(f"   ⏰ Пробуем как запланированную задачу '{event_type}'")
-                    result = await execute_scheduled_task(event_type, user_id, event_info)
-                    logger.info(f"   ✅ Задача выполнена: {result}")
+                if event_type in event_handlers:
+                    try:
+                        logger.info(f"   🎯 Сохраняем как user_event: '{event_type}'")
+                        event_id = await save_immediate_event(event_type, user_id, event_info, session_id)
+                        should_execute_immediately = True
+                        logger.info(f"   💾 Событие сохранено в БД: {event_id}")
+                    except ValueError as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Событие '{event_type}' уже обрабатывалось, пропускаем")
+                            continue
+                        else:
+                            raise
+                
+                # Если не user_event, пробуем как запланированную задачу
+                elif event_type in scheduled_tasks:
+                    try:
+                        delay_seconds = parse_time_expression(event_info)
+                        logger.info(f"   ⏰ Сохраняем как scheduled_task: '{event_type}' через {delay_seconds}с")
+                        result = await schedule_task_for_later_with_db(event_type, user_id, event_info, delay_seconds, session_id)
+                        event_id = result['event_id']
+                        should_notify = result.get('notify', False)
+                        logger.info(f"   💾 Задача сохранена в БД: {event_id}")
+                        
+                    except ValueError as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Задача '{event_type}' уже запланирована, пропускаем")
+                            continue
+                        else:
+                            logger.error(f"   ❌ Ошибка парсинга времени для scheduled_task '{event_type}': {e}")
+                            # Fallback - планируем через 1 час
+                            result = await schedule_task_for_later_with_db(event_type, user_id, event_info, 3600, session_id)
+                            event_id = result['event_id']
+                            should_notify = result.get('notify', False)
+                            logger.info(f"   ⏰ Задача сохранена с fallback временем (1 час): {event_id}")
+                
+                # Если не scheduled_task, пробуем как глобальный обработчик
+                elif event_type in global_handlers:
+                    try:
+                        delay_seconds = parse_time_expression(event_info)
+                        logger.info(f"   🌍 Сохраняем как global_handler: '{event_type}' через {delay_seconds}с")
+                        result = await schedule_global_handler_for_later_with_db(event_type, delay_seconds, event_info)
+                        event_id = result['event_id']
+                        should_notify = result.get('notify', False)
+                        logger.info(f"   💾 Глобальное событие сохранено в БД: {event_id}")
+                        
+                    except ValueError as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Глобальное событие '{event_type}' уже запланировано, пропускаем")
+                            continue
+                        else:
+                            logger.error(f"   ❌ Ошибка парсинга времени для global_handler '{event_type}': {e}")
+                            # Fallback - планируем через 1 час
+                            result = await schedule_global_handler_for_later_with_db(event_type, 3600, event_info)
+                            event_id = result['event_id']
+                            should_notify = result.get('notify', False)
+                            logger.info(f"   🌍 Глобальное событие сохранено с fallback временем (1 час): {event_id}")
+                
+                else:
+                    logger.warning(f"   ⚠️ Обработчик '{event_type}' не найден среди зарегистрированных")
+                
+                # Выполняем немедленные события
+                if should_execute_immediately and event_id:
+                    try:
+                        result = await execute_event_handler(event_type, user_id, event_info)
+                        should_notify = result.get('notify', False)
+                        await update_event_result(event_id, 'completed', result)
+                        logger.info(f"   ✅ Событие выполнено: {result}")
+                    except Exception as e:
+                        await update_event_result(event_id, 'failed', None, str(e))
+                        logger.error(f"   ❌ Ошибка выполнения события: {e}")
+                        
             except ValueError as e:
                 logger.warning(f"   ⚠️ Обработчик/задача не найдены: {e}")
             except Exception as e:
                 logger.error(f"   ❌ Ошибка в обработчике/задаче: {e}")
                 logger.exception("   Стек ошибки:")
             
+            # Уведомляем админов только если result.notify = True
+            if should_notify:
+                await notify_admins_about_event(user_id, event)
+                logger.info(f"   ✅ Админы уведомлены")
+            else:
+                logger.info(f"   🔕 Уведомления админам отключены для '{event_type}'")
+            
         except Exception as e:
             logger.error(f"❌ Ошибка обработки события {event}: {e}")
             logger.exception("Стек ошибки:")
@@ -302,34 +428,30 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
         parse_mode = config.MESSAGE_PARSE_MODE if config.MESSAGE_PARSE_MODE != 'None' else None
         logger.info(f"   🔧 Parse mode: {parse_mode}")
         
-        # В режиме отладки не скрываем JSON
-        if config.DEBUG_MODE:
-            final_text = text
-            logger.info(f"   🐛 Отправляем полный текст (debug режим)")
-        else:
-            # Убираем JSON если он есть
-            final_text, json_metadata = parse_ai_response(text)
-            logger.info(f"   ✂️ После очистки JSON: {len(final_text)} символов")
-            
-            # Добавляем информацию о файлах и каталогах в конец сообщения
-            if json_metadata:
-                logger.info(f"   📊 Найден JSON: {json_metadata}")
-                
-                files_list = json_metadata.get('файлы', [])
-                directories_list = json_metadata.get('каталоги', [])
-                
-                files_info = []
-                if files_list:
-                    files_str = "\n".join(f"• {file}" for file in files_list)
-                    files_info.append(f"\n\n📎 Доступные файлы:\n{files_str}")
-                
-                if directories_list:
-                    dirs_str = "\n".join(f"• {directory}" for directory in directories_list)
-                    files_info.append(f"\n\n📂 Доступные каталоги:\n{dirs_str}")
-                
-                if files_info:
-                    final_text = final_text.strip() + "".join(files_info)
-                    logger.info(f"   ✨ Добавлена информация о {len(files_list)} файлах и {len(directories_list)} каталогах")
+        # Получаем user_id и импортируем supabase_client
+        user_id = message.from_user.id
+        supabase_client = get_global_var('supabase_client')
+        
+        # Текст уже готов, используем как есть
+        final_text = text
+        
+        # Работаем с переданными файлами и каталогами
+        logger.info(f"   📦 Передано файлов: {files_list}")
+        logger.info(f"   📂 Передано каталогов: {directories_list}")
+        
+        # Получаем список уже отправленных файлов и каталогов
+        sent_files = await supabase_client.get_sent_files(user_id)
+        sent_directories = await supabase_client.get_sent_directories(user_id)
+        
+        logger.info(f"   📋 Уже отправлено файлов: {sent_files}")
+        logger.info(f"   📋 Уже отправлено каталогов: {sent_directories}")
+        
+        # Фильтруем файлы и каталоги, которые уже отправлялись
+        actual_files_list = [f for f in files_list if f not in sent_files]
+        actual_directories_list = [d for d in directories_list if str(d) not in sent_directories]
+        
+        logger.info(f"   🆕 После фильтрации файлов: {actual_files_list}")
+        logger.info(f"   🆕 После фильтрации каталогов: {actual_directories_list}")
                     
         
         # Проверяем, что есть что отправлять
@@ -339,30 +461,36 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
             final_text = "Ошибка формирования ответа. Попробуйте еще раз."
         
         logger.info(f"📱 Подготовка сообщения: {len(final_text)} символов")
+        logger.info(f"   📦 Файлов для обработки: {actual_files_list}")
+        logger.info(f"   📂 Каталогов для обработки: {actual_directories_list}")
         
         # Проверяем наличие файлов для отправки
-        if files_list or directories_list:
+        if actual_files_list or actual_directories_list:
             # Функция определения типа медиа по расширению
             def get_media_type(file_path: str) -> str:
                 ext = Path(file_path).suffix.lower()
                 if ext in {'.jpg', '.jpeg', '.png'}:
                     return 'photo'
-                elif ext in {'.mp4'}:
+                elif ext in {'.mp4', '.mov'}:
                     return 'video'
                 else:
                     return 'document'
             
             # Создаем списки для разных типов файлов
-            media_files = []  # для фото и видео
+            video_files = []  # для видео
+            photo_files = []  # для фото
             document_files = []  # для документов
             
             # Функция обработки файла
             def process_file(file_path: Path, source: str = ""):
                 if file_path.is_file():
                     media_type = get_media_type(str(file_path))
-                    if media_type in ('photo', 'video'):
-                        media_files.append((file_path, media_type))
-                        logger.info(f"   📸 Добавлен медиафайл{f' из {source}' if source else ''}: {file_path.name}")
+                    if media_type == 'video':
+                        video_files.append(file_path)
+                        logger.info(f"   🎥 Добавлено видео{f' из {source}' if source else ''}: {file_path.name}")
+                    elif media_type == 'photo':
+                        photo_files.append(file_path)
+                        logger.info(f"   📸 Добавлено фото{f' из {source}' if source else ''}: {file_path.name}")
                     else:
                         document_files.append(file_path)
                         logger.info(f"   📄 Добавлен документ{f' из {source}' if source else ''}: {file_path.name}")
@@ -370,54 +498,58 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                     logger.warning(f"   ⚠️ Файл не найден: {file_path}")
             
             # Обрабатываем прямые файлы
-            for file_name in files_list:
+            for file_name in actual_files_list:
                 try:
-                    # Получаем путь к папке бота
-                    config = get_global_var('config')
-                    bot_id = config.BOT_ID if config else "unknown"
-                    file_path = Path(f"bots/{bot_id}/files/{file_name}")
-                    process_file(file_path)
+                    process_file(Path(f"files/{file_name}"))
                 except Exception as e:
                     logger.error(f"   ❌ Ошибка обработки файла {file_name}: {e}")
             
             # Обрабатываем файлы из каталогов
-            for dir_name in directories_list:
-                # Получаем путь к каталогу относительно папки бота
-                config = get_global_var('config')
-                bot_id = config.BOT_ID if config else "unknown"
-                dir_path = Path(f"bots/{bot_id}/{dir_name}")
+            for dir_name in actual_directories_list:
+                dir_name = Path(dir_name)
                 try:
-                    if dir_path.is_dir():
-                        for file_path in dir_path.iterdir():
+                    if dir_name.is_dir():
+                        for file_path in dir_name.iterdir():
                             try:
-                                process_file(file_path, dir_path)
+                                process_file(file_path, dir_name)
                             except Exception as e:
                                 logger.error(f"   ❌ Ошибка обработки файла {file_path}: {e}")
                     else:
-                        logger.warning(f"   ⚠️ Каталог не найден: {dir_path}")
+                        logger.warning(f"   ⚠️ Каталог не найден: {dir_name}")
                 except Exception as e:
-                    logger.error(f"   ❌ Ошибка обработки каталога {dir_path}: {e}")
+                    logger.error(f"   ❌ Ошибка обработки каталога {dir_name}: {e}")
             
-            # Отправляем сообщение с медиа (если есть)
-            if media_files:
-                # Создаем медиа-группу с фото/видео и текстом
-                media_group = MediaGroupBuilder(caption=final_text)
-                for file_path, media_type in media_files:
-                    if media_type == 'photo':
-                        media_group.add_photo(media=FSInputFile(str(file_path)))
-                    else:  # video
-                        media_group.add_video(media=FSInputFile(str(file_path)))
+            # Списки для отслеживания реально отправленных файлов
+            sent_files_to_save = []
+            sent_dirs_to_save = []
+            
+            # 1. Отправляем видео (если есть)
+            if video_files:
+                video_group = MediaGroupBuilder()
+                for file_path in video_files:
+                    video_group.add_video(media=FSInputFile(str(file_path)))
                 
-                media = media_group.build()
-                if media:
-                    result = await message.answer_media_group(media=media)
-                    logger.info(f"   ✅ Отправлено сообщение с {len(media)} медиафайлами")
-            else:
-                # Если нет медиа, отправляем просто текст
-                result = await message.answer(final_text, parse_mode=parse_mode, **kwargs)
-                logger.info(f"   ✅ Отправлен текст сообщения")
+                videos = video_group.build()
+                if videos:
+                    await message.answer_media_group(media=videos)
+                    logger.info(f"   ✅ Отправлено {len(videos)} видео")
             
-            # Отправляем документы отдельно (если есть)
+            # 2. Отправляем фото (если есть)
+            if photo_files:
+                photo_group = MediaGroupBuilder()
+                for file_path in photo_files:
+                    photo_group.add_photo(media=FSInputFile(str(file_path)))
+                
+                photos = photo_group.build()
+                if photos:
+                    await message.answer_media_group(media=photos)
+                    logger.info(f"   ✅ Отправлено {len(photos)} фото")
+            
+            # 3. Отправляем текст
+            result = await message.answer(final_text, parse_mode=parse_mode)
+            logger.info(f"   ✅ Отправлен текст сообщения")
+            
+            # 4. Отправляем документы (если есть)
             if document_files:
                 doc_group = MediaGroupBuilder()
                 for file_path in document_files:
@@ -426,7 +558,32 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                 docs = doc_group.build()
                 if docs:
                     await message.answer_media_group(media=docs)
-                    logger.info(f"   ✅ Отправлена группа документов: {len(docs)} файлов")
+                    logger.info(f"   ✅ Отправлено {len(docs)} документов")
+            
+            # 5. Собираем список реально отправленных файлов и каталогов
+            # Если были отправлены файлы из actual_files_list - сохраняем их
+            if video_files or photo_files or document_files:
+                # Сохраняем прямые файлы из actual_files_list (если отправлены)
+                sent_files_to_save.extend(actual_files_list)
+                logger.info(f"   📝 Добавляем в список для сохранения файлы: {actual_files_list}")
+                # Сохраняем каталоги из actual_directories_list (если отправлены файлы из них)
+                sent_dirs_to_save.extend([str(d) for d in actual_directories_list])
+                logger.info(f"   📝 Добавляем в список для сохранения каталоги: {actual_directories_list}")
+            
+            # 6. Обновляем информацию в БД
+            if sent_files_to_save or sent_dirs_to_save:
+                try:
+                    if sent_files_to_save:
+                        logger.info(f"   💾 Сохраняем файлы в БД: {sent_files_to_save}")
+                        await supabase_client.add_sent_files(user_id, sent_files_to_save)
+                    if sent_dirs_to_save:
+                        logger.info(f"   💾 Сохраняем каталоги в БД: {sent_dirs_to_save}")
+                        await supabase_client.add_sent_directories(user_id, sent_dirs_to_save)
+                    logger.info(f"   ✅ Обновлена информация о отправленных файлах в БД")
+                except Exception as e:
+                    logger.error(f"   ❌ Ошибка обновления информации о файлах в БД: {e}")
+            else:
+                logger.info(f"   ℹ️ Нет новых файлов для сохранения в БД")
             
             return result
         else:
@@ -436,6 +593,14 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                 return result
         
     except Exception as e:
+        # Проверяем, является ли ошибка блокировкой бота
+        if "Forbidden: bot was blocked by the user" in str(e):
+            logger.warning(f"🚫 Бот заблокирован пользователем {user_id}")
+            return None
+        elif "TelegramForbiddenError" in str(type(e).__name__):
+            logger.warning(f"🚫 Бот заблокирован пользователем {user_id}")
+            return None
+        
         logger.error(f"❌ ОШИБКА в send_message: {e}")
         logger.exception("Полный стек ошибки send_message:")
         
@@ -446,6 +611,14 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
             logger.info(f"✅ Запасное сообщение отправлено")
             return result
         except Exception as e2:
+            # Проверяем и здесь блокировку бота
+            if "Forbidden: bot was blocked by the user" in str(e2):
+                logger.warning(f"🚫 Бот заблокирован пользователем {user_id} (fallback)")
+                return None
+            elif "TelegramForbiddenError" in str(type(e2).__name__):
+                logger.warning(f"🚫 Бот заблокирован пользователем {user_id} (fallback)")
+                return None
+            
             logger.error(f"❌ Даже запасное сообщение не отправилось: {e2}")
             raise
         
@@ -647,19 +820,19 @@ OpenAI API: {'✅' if openai_status else '❌'}
         
         
 def parse_utm_from_start_param(start_param: str) -> dict:
-    """Парсит UTM-метки из start параметра в формате utmSource-vk_utmCampaign-summer2025
+    """Парсит UTM-метки из start параметра в формате source-vk_campaign-summer2025
     
     Args:
-        start_param: строка вида 'utmSource-vk_utmCampaign-summer2025' или полная ссылка
+        start_param: строка вида 'source-vk_campaign-summer2025' или полная ссылка
         
     Returns:
         dict: {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
         
     Examples:
-        >>> parse_utm_from_start_param('utmSource-vk_utmCampaign-summer2025')
+        >>> parse_utm_from_start_param('source-vk_campaign-summer2025')
         {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
         
-        >>> parse_utm_from_start_param('https://t.me/bot?start=utmSource-vk_utmCampaign-summer2025')
+        >>> parse_utm_from_start_param('https://t.me/bot?start=source-vk_campaign-summer2025')
         {'utm_source': 'vk', 'utm_campaign': 'summer2025'}
     """
     import re
@@ -676,15 +849,15 @@ def parse_utm_from_start_param(start_param: str) -> dict:
             else:
                 return {}
         
-        # Парсим формат: utmSource-vk_utmCampaign-summer2025
+        # Парсим новый формат: source-vk_campaign-summer2025
         if '_' in start_param and '-' in start_param:
             parts = start_param.split('_')
             for part in parts:
                 if '-' in part:
                     key, value = part.split('-', 1)
-                    # Преобразуем utmSource в utm_source
-                    if key.startswith('utm'):
-                        key = 'utm_' + key[3:].lower()
+                    # Преобразуем source в utm_source
+                    if key in ['source', 'medium', 'campaign', 'content', 'term']:
+                        key = 'utm_' + key
                         utm_data[key] = value
             
     except Exception as e: