smart-bot-factory 0.1.0__py3-none-any.whl

smart_bot_factory/integrations/bot_utils_integration.py

@@ -0,0 +1,224 @@
+"""
+Интеграция с bot_utils.py для обработки событий
+"""
+
+import logging
+from typing import List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+async def enhanced_process_events(session_id: str, events: List[Dict[str, Any]], user_id: int):
+    """
+    Улучшенная версия process_events из bot_utils.py
+    с поддержкой декораторов обработчиков событий
+    """
+    from ..events.decorators import (
+        execute_event_handler, 
+        get_event_handlers, 
+        get_scheduled_tasks,
+        execute_scheduled_task_from_event
+    )
+    
+    logger.info(f"🔔 Обрабатываем {len(events)} событий для пользователя {user_id}")
+    
+    for event in events:
+        try:
+            event_type = event.get('тип', '')
+            event_info = event.get('инфо', '')
+            
+            if not event_type:
+                continue
+            
+            logger.info(f"📝 Обрабатываем событие: {event_type}")
+            
+            # Проверяем, есть ли зарегистрированный обработчик событий
+            event_handlers = get_event_handlers()
+            scheduled_tasks = get_scheduled_tasks()
+            
+            if event_type in event_handlers:
+                # Используем зарегистрированный обработчик событий
+                logger.info(f"🔧 Используем зарегистрированный обработчик для '{event_type}'")
+                
+                try:
+                    # Парсим event_info если это строка
+                    if isinstance(event_info, str):
+                        event_data = _parse_event_info(event_info, user_id)
+                    else:
+                        event_data = event_info
+                    
+                    # Вызываем обработчик
+                    result = await execute_event_handler(event_type, user_id, event_data)
+                    logger.info(f"✅ Обработчик '{event_type}' выполнен: {result}")
+                    
+                except Exception as e:
+                    logger.error(f"❌ Ошибка в обработчике '{event_type}': {e}")
+                    # Fallback к стандартной обработке
+                    await _fallback_event_processing(session_id, event_type, event_info, user_id)
+                    
+            elif event_type in scheduled_tasks:
+                # Это запланированная задача - парсим время из event_info
+                logger.info(f"⏰ Планируем задачу '{event_type}' на основе event_info: {event_info}")
+                
+                try:
+                    result = await execute_scheduled_task_from_event(user_id, event_type, event_info)
+                    logger.info(f"✅ Задача '{event_type}' запланирована: {result}")
+                    
+                except Exception as e:
+                    logger.error(f"❌ Ошибка в планировании задачи '{event_type}': {e}")
+                    # Fallback к стандартной обработке
+                    await _fallback_event_processing(session_id, event_type, event_info, user_id)
+            else:
+                # Используем стандартную обработку из bot_utils.py
+                logger.info(f"📋 Используем стандартную обработку для '{event_type}'")
+                await _fallback_event_processing(session_id, event_type, event_info, user_id)
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка при обработке события {event}: {e}")
+
+def _parse_event_info(event_info: str, user_id: int) -> Dict[str, Any]:
+    """
+    Парсит строку event_info и извлекает структурированные данные
+    """
+    # Простой парсинг для типичных случаев
+    # Например: "Иван Петров, +7-999-123-45-67, интересуется имплантацией"
+    
+    data = {
+        "user_id": user_id,
+        "raw_info": event_info
+    }
+    
+    # Пытаемся извлечь телефон
+    import re
+    phone_match = re.search(r'\+?[7-8]?[\s\-]?\(?\d{3}\)?[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}', event_info)
+    if phone_match:
+        data["phone"] = phone_match.group(0)
+    
+    # Пытаемся извлечь имя (первое слово)
+    words = event_info.split(',')
+    if words:
+        data["name"] = words[0].strip()
+    
+    # Пытаемся извлечь услугу/интерес
+    if len(words) > 2:
+        data["interest"] = words[2].strip()
+    
+    return data
+
+async def _fallback_event_processing(session_id: str, event_type: str, event_info: str, user_id: int):
+    """
+    Стандартная обработка событий (из оригинального bot_utils.py)
+    """
+    # Импортируем оригинальную функцию
+    import sys
+    from pathlib import Path
+    
+    # Добавляем корень проекта в путь
+    project_root = Path(__file__).parent.parent.parent.parent
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+    
+    try:
+        from supabase_client import SupabaseClient
+        from main import supabase_client
+        
+        # Сохраняем в БД
+        await supabase_client.add_session_event(session_id, event_type, event_info)
+        
+        # Уведомляем админов
+        await _notify_admins_about_event(user_id, {
+            'тип': event_type,
+            'инфо': event_info
+        })
+        
+    except ImportError:
+        logger.warning("Не удалось импортировать оригинальные модули для fallback обработки")
+
+async def _notify_admins_about_event(user_id: int, event: Dict[str, Any]):
+    """
+    Уведомление админов о событии (из оригинального bot_utils.py)
+    """
+    try:
+        import sys
+        from pathlib import Path
+        
+        # Добавляем корень проекта в путь
+        project_root = Path(__file__).parent.parent.parent.parent
+        if str(project_root) not in sys.path:
+            sys.path.insert(0, str(project_root))
+        
+        from main import supabase_client, admin_manager, bot
+        from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+        from datetime import datetime
+        
+        event_type = event.get('тип', '')
+        event_info = event.get('инфо', '')
+        
+        if not event_type:
+            return
+        
+        # Получаем информацию о пользователе
+        try:
+            user_response = supabase_client.client.table('sales_users').select(
+                'first_name', 'last_name', 'username'
+            ).eq('telegram_id', user_id).execute()
+            
+            user_info = user_response.data[0] if user_response.data else {}
+            
+            # Формируем имя пользователя
+            name_parts = []
+            if user_info.get('first_name'):
+                name_parts.append(user_info['first_name'])
+            if user_info.get('last_name'):
+                name_parts.append(user_info['last_name'])
+            
+            user_name = " ".join(name_parts) if name_parts else "Без имени"
+            
+            # Формируем отображение пользователя
+            if user_info.get('username'):
+                user_display = f"{user_name} (@{user_info['username']})"
+            else:
+                user_display = user_name
+                
+        except Exception as e:
+            logger.error(f"Ошибка получения информации о пользователе {user_id}: {e}")
+            user_display = "Пользователь"
+        
+        # Маппинг эмодзи
+        emoji_map = {
+            'телефон': '📱',
+            'консультация': '💬',
+            'покупка': '💰',
+            'отказ': '❌',
+            'appointment_booking': '📅',
+            'phone_collection': '📱'
+        }
+        
+        emoji = emoji_map.get(event_type, '🔔')
+        
+        # Формируем уведомление
+        notification = f"""
+{emoji} {event_type.upper()}!
+👤 {user_display}
+🆔 ID: {user_id}
+📝 {event_info}
+🕐 {datetime.now().strftime('%H:%M')}
+"""
+        
+        # Создаем клавиатуру
+        keyboard = InlineKeyboardMarkup(inline_keyboard=[
+            [
+                InlineKeyboardButton(text="💬 Чат", callback_data=f"admin_chat_{user_id}"),
+                InlineKeyboardButton(text="📋 История", callback_data=f"admin_history_{user_id}")
+            ]
+        ])
+        
+        # Отправляем всем активным админам
+        active_admins = await admin_manager.get_active_admins()
+        for admin_id in active_admins:
+            try:
+                await bot.send_message(admin_id, notification.strip(), reply_markup=keyboard)
+            except Exception as e:
+                logger.error(f"Ошибка отправки уведомления админу {admin_id}: {e}")
+                
+    except Exception as e:
+        logger.error(f"Ошибка отправки уведомления админам: {e}")

smart_bot_factory/services/__init__.py

@@ -0,0 +1,12 @@
+"""
+Сервисы для работы с внешними API
+"""
+
+from .telegram_integration import TelegramIntegration
+from .message_sender import send_message_by_ai, send_message_by_human
+
+__all__ = [
+    'TelegramIntegration',
+    'send_message_by_ai',
+    'send_message_by_human'
+]

smart_bot_factory/services/message_sender.py

@@ -0,0 +1,235 @@
+"""
+Функции для отправки сообщений через ИИ и от человека
+"""
+
+import logging
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+import pytz
+
+logger = logging.getLogger(__name__)
+
+async def send_message_by_ai(
+    user_id: int, 
+    message_text: str, 
+    session_id: str = None,
+    system_prompt: str = None
+) -> Dict[str, Any]:
+    """
+    Отправляет сообщение пользователю через ИИ (копирует логику process_user_message)
+    
+    Args:
+        user_id: ID пользователя в Telegram
+        message_text: Текст сообщения для обработки ИИ
+        session_id: ID сессии чата
+        system_prompt: Системный промпт для ИИ
+        
+    Returns:
+        Результат отправки
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from ..integrations import supabase_client, openai_client, config, bot, prompt_loader, parse_ai_response, process_events
+        
+        # Если session_id не указан, получаем активную сессию пользователя
+        if not session_id:
+            session_info = await supabase_client.get_active_session(user_id)
+            if not session_info:
+                return {
+                    "status": "error",
+                    "error": "Активная сессия не найдена",
+                    "user_id": user_id
+                }
+            session_id = session_info['id']
+        
+        # Если system_prompt не указан, получаем из сессии
+        if not system_prompt:
+            session_info = await supabase_client.get_session_info(session_id)
+            if not session_info:
+                return {
+                    "status": "error", 
+                    "error": "Информация о сессии не найдена",
+                    "user_id": user_id
+                }
+            system_prompt = session_info['system_prompt']
+        
+        # Сохраняем сообщение пользователя в БД
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='user',
+            content=message_text,
+            message_type='text'
+        )
+        logger.info(f"✅ Сообщение пользователя сохранено в БД")
+        
+        # Получаем историю сообщений
+        chat_history = await supabase_client.get_chat_history(session_id, limit=config.MAX_CONTEXT_MESSAGES)
+        logger.info(f"📚 Загружена история: {len(chat_history)} сообщений")
+        
+        # Добавляем текущее время
+        moscow_tz = pytz.timezone('Europe/Moscow')
+        current_time = datetime.now(moscow_tz)
+        time_info = current_time.strftime('%H:%M, %d.%m.%Y, %A')
+        
+        # Модифицируем системный промпт, добавляя время
+        system_prompt_with_time = f"""
+{system_prompt}
+
+ТЕКУЩЕЕ ВРЕМЯ: {time_info} (московское время)
+"""
+        
+        # Формируем контекст для OpenAI
+        messages = [{"role": "system", "content": system_prompt_with_time}]
+        
+        for msg in chat_history[-config.MAX_CONTEXT_MESSAGES:]:
+            messages.append({
+                "role": msg['role'],
+                "content": msg['content']
+            })
+        
+        # Добавляем финальные инструкции
+        final_instructions = await prompt_loader.load_final_instructions()
+        if final_instructions:
+            messages.append({"role": "system", "content": final_instructions})
+            logger.info(f"🎯 Добавлены финальные инструкции")
+        
+        logger.info(f"📝 Контекст сформирован: {len(messages)} сообщений")
+        
+        # Отправляем действие "печатает"
+        await bot.send_chat_action(user_id, "typing")
+        
+        # Получаем ответ от ИИ
+        start_time = time.time()
+        ai_response = await openai_client.get_completion(messages)
+        processing_time = int((time.time() - start_time) * 1000)
+        
+        logger.info(f"🤖 OpenAI ответил за {processing_time}мс")
+        
+        # Обрабатываем ответ
+        tokens_used = 0
+        ai_metadata = {}
+        response_text = ""
+        
+        if not ai_response or not ai_response.strip():
+            logger.warning(f"❌ OpenAI вернул пустой ответ!")
+            fallback_message = "Извините, произошла техническая ошибка. Попробуйте переформулировать вопрос."
+            ai_response = fallback_message
+            response_text = fallback_message
+        else:
+            tokens_used = openai_client.estimate_tokens(ai_response)
+            response_text, ai_metadata = parse_ai_response(ai_response)
+            
+            if not ai_metadata:
+                response_text = ai_response
+                ai_metadata = {}
+            elif not response_text.strip():
+                response_text = ai_response
+        
+        # Обновляем этап сессии и качество лида
+        if ai_metadata:
+            stage = ai_metadata.get('этап')
+            quality = ai_metadata.get('качество')
+            
+            if stage or quality is not None:
+                await supabase_client.update_session_stage(session_id, stage, quality)
+                logger.info(f"✅ Этап и качество обновлены в БД")
+            
+            # Обрабатываем события
+            events = ai_metadata.get('события', [])
+            if events:
+                logger.info(f"🔔 Обрабатываем {len(events)} событий")
+                await process_events(session_id, events, user_id)
+        
+        # Сохраняем ответ ассистента
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='assistant',
+            content=response_text,
+            message_type='text',
+            tokens_used=tokens_used,
+            processing_time_ms=processing_time,
+            ai_metadata=ai_metadata
+        )
+        
+        # Определяем финальный ответ
+        if config.DEBUG_MODE:
+            final_response = ai_response
+        else:
+            final_response = response_text
+        
+        # Отправляем ответ пользователю напрямую через бота
+        await bot.send_message(
+            chat_id=user_id,
+            text=final_response
+        )
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "response_text": response_text,
+            "tokens_used": tokens_used,
+            "processing_time_ms": processing_time,
+            "events_processed": len(events) if events else 0
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка в send_message_by_ai: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "user_id": user_id
+        }
+
+async def send_message_by_human(
+    user_id: int, 
+    message_text: str,
+    session_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Отправляет сообщение пользователю от имени человека (готовый текст)
+    
+    Args:
+        user_id: ID пользователя в Telegram
+        message_text: Готовый текст сообщения
+        session_id: ID сессии (опционально, для сохранения в БД)
+        
+    Returns:
+        Результат отправки
+    """
+    try:
+        # Импортируем необходимые компоненты
+        from ..integrations import bot, supabase_client
+        
+        # Отправляем сообщение пользователю
+        message = await bot.send_message(
+            chat_id=user_id,
+            text=message_text
+        )
+        
+        # Если указана сессия, сохраняем сообщение в БД
+        if session_id:
+            await supabase_client.add_message(
+                session_id=session_id,
+                role='assistant',
+                content=message_text,
+                message_type='text',
+                metadata={'sent_by_human': True}
+            )
+            logger.info(f"💾 Сообщение от человека сохранено в БД")
+        
+        return {
+            "status": "success",
+            "user_id": user_id,
+            "message_id": message.message_id,
+            "message_text": message_text,
+            "saved_to_db": bool(session_id)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка в send_message_by_human: {e}")
+        return {
+            "status": "error",
+            "error": str(e),
+            "user_id": user_id
+        }