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

smart_bot_factory/__init__.py

@@ -0,0 +1,51 @@
+"""
+Smart Bot Factory - библиотека для создания умных чат-ботов
+"""
+
+from .creation.bot_builder import BotBuilder
+from .core.decorators import event_handler, schedule_task
+from .core.message_sender import send_message_by_ai, send_message_by_human
+from .config import Config
+from .integrations.openai_client import OpenAIClient
+from .integrations.supabase_client import SupabaseClient
+from .core.conversation_manager import ConversationManager
+from .admin.admin_manager import AdminManager
+from .utils.prompt_loader import PromptLoader
+from .handlers.handlers import setup_handlers
+from .admin.admin_logic import setup_admin_handlers
+from .core.bot_utils import setup_utils_handlers, parse_ai_response, process_events
+from .utils.debug_routing import setup_debug_handlers
+from .core.states import UserStates, AdminStates
+from .creation.bot_testing import main as bot_testing_main
+from .analytics.analytics_manager import AnalyticsManager
+from .admin.timeout_checker import check_timeouts, setup_bot_environment
+from .setup_checker import check_setup
+from .admin.admin_tester import test_admin_system
+
+__all__ = [
+    'BotBuilder',
+    'event_handler',
+    'schedule_task',
+    'send_message_by_ai',
+    'send_message_by_human',
+    'Config',
+    'OpenAIClient',
+    'SupabaseClient',
+    'ConversationManager',
+    'AdminManager',
+    'PromptLoader',
+    'setup_handlers',
+    'setup_admin_handlers',
+    'setup_utils_handlers',
+    'parse_ai_response',
+    'process_events',
+    'setup_debug_handlers',
+    'UserStates',
+    'AdminStates',
+    'bot_testing_main',
+    'AnalyticsManager',
+    'check_timeouts',
+    'setup_bot_environment',
+    'check_setup',
+    'test_admin_system',
+]

smart_bot_factory/admin/__init__.py

@@ -0,0 +1,16 @@
+"""
+Admin модули smart_bot_factory
+"""
+
+from .admin_logic import setup_admin_handlers
+from .admin_manager import AdminManager
+from .admin_tester import test_admin_system
+from .timeout_checker import check_timeouts, setup_bot_environment
+
+__all__ = [
+    'setup_admin_handlers',
+    'AdminManager',
+    'test_admin_system',
+    'check_timeouts',
+    'setup_bot_environment'
+]

smart_bot_factory/admin/admin_logic.py

@@ -0,0 +1,430 @@
+# Исправленный admin_logic.py с правильной обработкой диалогов
+
+import logging
+from datetime import datetime
+from aiogram import Router, F
+from aiogram.filters import Command, StateFilter
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+
+logger = logging.getLogger(__name__)
+
+# Импортируем состояния
+from ..core.states import UserStates, AdminStates
+
+# Создаем роутер для админских обработчиков
+admin_router = Router()
+
+def setup_admin_handlers(dp):
+    """Настройка админских обработчиков"""
+    dp.include_router(admin_router)
+
+async def admin_start_handler(message: Message, state: FSMContext):
+    """Обработчик /start для админов в режиме администратора"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    
+    await state.set_state(AdminStates.admin_mode)
+    
+    admin_status = admin_manager.get_admin_mode_text(message.from_user.id)
+    
+    # Основное меню админа
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="📊 Статистика", callback_data="admin_stats")],
+        [InlineKeyboardButton(text="💬 Активные чаты", callback_data="admin_active_chats")],
+        [InlineKeyboardButton(text="🔄 Режим польз.", callback_data="admin_toggle_mode")]
+    ])
+    
+    welcome_text = f"""
+{admin_status}
+
+🎛️ **Панель администратора**
+
+Доступные команды:
+• `/стат` - статистика воронки
+• `/история <user_id>` - история пользователя
+• `/чат <user_id>` - начать диалог
+• `/чаты` - активные диалоги
+• `/стоп` - завершить диалог
+• `/админ` - переключить режим
+"""
+
+    await message.answer(welcome_text, reply_markup=keyboard, parse_mode='Markdown')
+
+@admin_router.message(Command("стат"))
+async def admin_stats_handler(message: Message, state: FSMContext):
+    """Статистика воронки"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    analytics_manager = get_global_var('analytics_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        # Получаем статистику
+        funnel_stats = await analytics_manager.get_funnel_stats(7)
+        events_stats = await analytics_manager.get_events_stats(7)
+        
+        # Форматируем ответ
+        funnel_text = analytics_manager.format_funnel_stats(funnel_stats)
+        events_text = analytics_manager.format_events_stats(events_stats)
+        
+        full_text = f"{funnel_text}\n\n{events_text}"
+        
+        await message.answer(full_text, parse_mode='Markdown')
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения статистики: {e}")
+        await message.answer("❌ Ошибка получения статистики")
+
+@admin_router.message(Command("история"))
+async def admin_history_handler(message: Message, state: FSMContext):
+    """История пользователя"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    analytics_manager = get_global_var('analytics_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        parts = message.text.split()
+        if len(parts) < 2:
+            await message.answer("Укажите ID пользователя: /история 123456789")
+            return
+        
+        user_id = int(parts[1])
+        
+        # Получаем историю (та же функция что использует кнопка)
+        journey = await analytics_manager.get_user_journey(user_id)
+        
+        if not journey:
+            await message.answer(f"❌ У пользователя {user_id} нет активной сессии")
+            return
+        
+        # Используем ту же функцию форматирования что и кнопка
+        history_text = analytics_manager.format_user_journey(user_id, journey)
+        
+        await message.answer(history_text)
+        
+    except ValueError:
+        await message.answer("❌ Неверный формат ID пользователя")
+    except Exception as e:
+        logger.error(f"Ошибка получения истории: {e}")
+        await message.answer("❌ Ошибка получения истории")
+
+@admin_router.message(Command("чат"))
+async def admin_chat_handler(message: Message, state: FSMContext):
+    """Начать диалог с пользователем"""
+    from handlers import get_global_var
+    
+    admin_manager = get_global_var('admin_manager') 
+    supabase_client = get_global_var('supabase_client')
+    conversation_manager = get_global_var('conversation_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        # Парсим user_id из команды
+        parts = message.text.split()
+        if len(parts) < 2:
+            await message.answer("Укажите ID пользователя: /чат 123456789")
+            return
+        
+        user_id = int(parts[1])
+        admin_id = message.from_user.id
+        
+        logger.info(f"👑 Админ {admin_id} хочет начать диалог с пользователем {user_id}")
+        
+        # Проверяем, есть ли активная сессия у пользователя
+        session_info = await supabase_client.get_active_session(user_id)
+        if not session_info:
+            await message.answer(f"❌ У пользователя {user_id} нет активной сессии")
+            logger.warning(f"❌ У пользователя {user_id} нет активной сессии")
+            return
+        
+        logger.info(f"✅ У пользователя {user_id} есть активная сессия: {session_info['id']}")
+        
+        # Начинаем диалог
+        logger.info(f"🚀 Запускаем создание диалога...")
+        success = await conversation_manager.start_admin_conversation(admin_id, user_id)
+        
+        if success:
+            # ✅ ИСПРАВЛЕНИЕ: Правильно переключаем состояние админа
+            await state.set_state(AdminStates.in_conversation)
+            await state.update_data(conversation_user_id=user_id)
+            
+            await message.answer(f"✅ Диалог с пользователем {user_id} начат\n💬 Ваши сообщения будут переданы пользователю\n⏹️ Используйте /стоп для завершения")
+            logger.info(f"✅ Диалог успешно создан, админ переключен в состояние in_conversation")
+        else:
+            await message.answer(f"❌ Не удалось начать диалог с пользователем {user_id}")
+            logger.error(f"❌ Не удалось создать диалог")
+            
+    except ValueError:
+        await message.answer("❌ Неверный формат ID пользователя")
+        logger.error(f"❌ Неверный формат ID пользователя: {message.text}")
+    except Exception as e:
+        logger.error(f"❌ Ошибка начала диалога: {e}")
+        await message.answer("❌ Ошибка начала диалога")
+
+@admin_router.message(Command("чаты"))
+async def admin_active_chats_command(message: Message, state: FSMContext):
+    """Показать активные диалоги админов"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    conversation_manager = get_global_var('conversation_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        conversations = await conversation_manager.get_active_conversations()
+        formatted_text = conversation_manager.format_active_conversations(conversations)
+        
+        # ✅ ИСПРАВЛЕНИЕ: Убираем parse_mode='Markdown' чтобы избежать ошибок парсинга
+        await message.answer(formatted_text)
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения активных чатов: {e}")
+        await message.answer("❌ Ошибка получения активных диалогов")
+
+@admin_router.message(Command("стоп"))
+async def admin_stop_handler(message: Message, state: FSMContext):
+    """Завершить диалог"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    conversation_manager = get_global_var('conversation_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        admin_id = message.from_user.id
+        
+        # Проверяем есть ли активный диалог
+        conversation = await conversation_manager.get_admin_active_conversation(admin_id)
+        
+        if conversation:
+            user_id = conversation['user_id']
+            logger.info(f"🛑 Завершаем диалог админа {admin_id} с пользователем {user_id}")
+            
+            success = await conversation_manager.end_admin_conversation(admin_id)
+            
+            if success:
+                # ✅ ИСПРАВЛЕНИЕ: Правильно переключаем состояние обратно
+                await state.set_state(AdminStates.admin_mode)
+                await state.update_data(conversation_user_id=None)
+                
+                await message.answer(f"✅ Диалог с пользователем {user_id} завершен")
+                logger.info(f"✅ Диалог завершен, админ переключен в admin_mode")
+            else:
+                await message.answer("❌ Ошибка завершения диалога")
+        else:
+            await message.answer("❌ Нет активного диалога")
+            logger.info(f"❌ У админа {admin_id} нет активного диалога")
+            
+    except Exception as e:
+        logger.error(f"Ошибка завершения диалога: {e}")
+        await message.answer("❌ Ошибка завершения диалога")
+
+@admin_router.message(Command("админ"))
+async def admin_toggle_handler(message: Message, state: FSMContext):
+    """Переключение режима админа"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    from .handlers import user_start_handler
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    new_mode = admin_manager.toggle_admin_mode(message.from_user.id)
+    
+    if new_mode:
+        # Переключились в режим админа
+        await admin_start_handler(message, state)
+    else:
+        # Переключились в режим пользователя
+        await state.clear()
+        await message.answer("🔄 Переключен в режим пользователя\nНапишите /start для начала диалога")
+
+@admin_router.message(Command("debug_chat"))
+async def debug_chat_handler(message: Message, state: FSMContext):
+    """Отладка диалогов админов"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    conversation_manager = get_global_var('conversation_manager')
+    supabase_client = get_global_var('supabase_client')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    parts = message.text.split()
+    if len(parts) < 2:
+        await message.answer("Использование: /debug_chat USER_ID")
+        return
+    
+    try:
+        user_id = int(parts[1])
+        
+        # 1. Проверяем запись в БД
+        conversation = await conversation_manager.is_user_in_admin_chat(user_id)
+        
+        debug_info = [
+            f"🔍 ОТЛАДКА ДИАЛОГА С {user_id}",
+            "",
+            f"📊 Диалог в БД: {'✅' if conversation else '❌'}",
+        ]
+        
+        if conversation:
+            debug_info.extend([
+                f"👑 Админ: {conversation['admin_id']}",
+                f"🕐 Начат: {conversation['started_at']}",
+            ])
+        
+        # 2. Проверяем активную сессию пользователя
+        session_info = await supabase_client.get_active_session(user_id)
+        debug_info.append(f"🎯 Активная сессия: {'✅' if session_info else '❌'}")
+        
+        if session_info:
+            debug_info.append(f"📝 ID сессии: {session_info['id']}")
+        
+        # 3. Проверяем состояние пользователя (если он онлайн)
+        debug_info.append(f"")
+        debug_info.append(f"ℹ️ Для проверки состояния пользователь должен написать что-то")
+        
+        await message.answer("\n".join(debug_info))
+        
+    except Exception as e:
+        await message.answer(f"❌ Ошибка: {e}")
+        logger.error(f"Ошибка отладки: {e}")
+
+@admin_router.callback_query(F.data.startswith("admin_"))
+async def admin_callback_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик callback кнопок админов"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    analytics_manager = get_global_var('analytics_manager')
+    conversation_manager = get_global_var('conversation_manager')
+    
+    if not admin_manager.is_admin(callback.from_user.id):
+        await callback.answer("Нет доступа")
+        return
+    
+    data = callback.data
+    
+    try:
+        if data == "admin_stats":
+            # Показываем статистику
+            funnel_stats = await analytics_manager.get_funnel_stats(7)
+            events_stats = await analytics_manager.get_events_stats(7)
+            
+            funnel_text = analytics_manager.format_funnel_stats(funnel_stats)
+            events_text = analytics_manager.format_events_stats(events_stats)
+            
+            await callback.message.answer(f"{funnel_text}\n\n{events_text}")
+            
+        elif data == "admin_toggle_mode":
+            # Переключаем режим
+            new_mode = admin_manager.toggle_admin_mode(callback.from_user.id)
+            mode_text = "администратор" if new_mode else "пользователь"
+            await callback.answer(f"Режим переключен: {mode_text}")
+            
+            if not new_mode:
+                await state.clear()
+                await callback.message.answer("🔄 Теперь вы в режиме пользователя")
+
+        elif data == "admin_active_chats":
+            # Показываем активные диалоги
+            conversations = await conversation_manager.get_active_conversations()
+            formatted_text = conversation_manager.format_active_conversations(conversations)
+            
+            # ✅ ИСПРАВЛЕНИЕ: Убираем parse_mode='Markdown'
+            await callback.message.answer(formatted_text)
+                
+        elif data.startswith("admin_history_"):
+            user_id = int(data.split("_")[2])
+            journey = await analytics_manager.get_user_journey(user_id)
+            history_text = analytics_manager.format_user_journey(user_id, journey)
+            await callback.message.answer(history_text)
+            
+        elif data.startswith("admin_end_"):
+            user_id = int(data.split("_")[2])
+            
+            # Проверяем есть ли активный диалог
+            conversation = await conversation_manager.get_admin_active_conversation(callback.from_user.id)
+            
+            if conversation and conversation['user_id'] == user_id:
+                await conversation_manager.end_admin_conversation(callback.from_user.id)
+                
+                # ✅ ИСПРАВЛЕНИЕ: Правильно переключаем состояние
+                await state.set_state(AdminStates.admin_mode)
+                await state.update_data(conversation_user_id=None)
+                
+                await callback.answer("Диалог завершен")
+                await callback.message.answer(f"✅ Диалог с пользователем {user_id} завершен")
+                logger.info(f"✅ Диалог завершен через кнопку, админ переключен в admin_mode")
+            else:
+                await callback.answer("Диалог не найден")
+
+        elif data.startswith("admin_chat_"):
+            user_id = int(data.split("_")[2])
+            admin_id = callback.from_user.id
+            
+            success = await conversation_manager.start_admin_conversation(admin_id, user_id)
+            if success:
+                # ✅ ИСПРАВЛЕНИЕ: Правильно переключаем состояние
+                await state.set_state(AdminStates.in_conversation)
+                await state.update_data(conversation_user_id=user_id)
+                
+                await callback.answer("Диалог начат")
+                await callback.message.answer(f"✅ Диалог с пользователем {user_id} начат")
+                logger.info(f"✅ Диалог начат через кнопку, админ переключен в in_conversation")
+            else:
+                await callback.answer("Не удалось начать диалог")         
+
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"Ошибка обработки callback {data}: {e}")
+        await callback.answer("Ошибка")
+
+@admin_router.message(StateFilter(AdminStates.admin_mode, AdminStates.in_conversation))
+async def admin_message_handler(message: Message, state: FSMContext):
+    """Обработчик сообщений админов"""
+    from handlers import get_global_var
+    admin_manager = get_global_var('admin_manager')
+    conversation_manager = get_global_var('conversation_manager')
+    
+    if not admin_manager.is_admin(message.from_user.id):
+        return
+    
+    try:
+        logger.info(f"👑 Получено сообщение от админа {message.from_user.id}: '{message.text}'")
+        
+        # Пытаемся обработать как админское сообщение
+        handled = await conversation_manager.route_admin_message(message, state)
+        
+        if handled:
+            logger.info(f"✅ Сообщение админа обработано и переслано пользователю")
+        else:
+            # Не админское сообщение - показываем справку
+            logger.info(f"❌ Сообщение админа не обработано, показываем справку")
+            await message.answer("""
+👑 **Режим администратора**
+
+Доступные команды:
+• `/стат` - статистика воронки
+• `/история <user_id>` - история пользователя  
+• `/чат <user_id>` - начать диалог
+• `/стоп` - завершить диалог
+• `/админ` - переключить режим
+
+💡 Если вы в диалоге с пользователем, просто напишите сообщение - оно будет переслано пользователю.
+""", parse_mode='Markdown')
+            
+    except Exception as e:
+        logger.error(f"Ошибка обработки сообщения админа: {e}")
+        await message.answer("❌ Ошибка обработки команды")

smart_bot_factory/admin/admin_manager.py

@@ -0,0 +1,141 @@
+import logging
+from typing import List, Dict, Set
+from aiogram.types import User
+
+logger = logging.getLogger(__name__)
+
+class AdminManager:
+    """Управление администраторами бота"""
+    
+    def __init__(self, config, supabase_client):
+        self.config = config
+        self.supabase = supabase_client
+        self.admin_ids: Set[int] = set(config.ADMIN_TELEGRAM_IDS)
+        self.admin_modes: Dict[int, bool] = {}  # admin_id -> is_in_admin_mode
+        
+        logger.info(f"Инициализирован менеджер админов: {len(self.admin_ids)} админов")
+    
+    async def sync_admins_from_config(self):
+        """Синхронизирует админов из конфига с базой данных"""
+        if not self.admin_ids:
+            logger.warning("Нет админов в конфигурации")
+            return
+        
+        try:
+            for admin_id in self.admin_ids:
+                await self.supabase.sync_admin({
+                    'telegram_id': admin_id,
+                    'username': None,  # будет обновлено при первом сообщении
+                    'first_name': None,
+                    'last_name': None
+                })
+                
+                # Устанавливаем режим администратора по умолчанию
+                if admin_id not in self.admin_modes:
+                    self.admin_modes[admin_id] = True
+            
+            logger.info(f"Синхронизированы админы: {self.admin_ids}")
+            
+        except Exception as e:
+            logger.error(f"Ошибка синхронизации админов: {e}")
+            raise
+    
+    async def update_admin_info(self, user: User):
+        """Обновляет информацию об админе"""
+        if not self.is_admin(user.id):
+            return
+        
+        try:
+            await self.supabase.sync_admin({
+                'telegram_id': user.id,
+                'username': user.username,
+                'first_name': user.first_name,
+                'last_name': user.last_name
+            })
+            
+        except Exception as e:
+            logger.error(f"Ошибка обновления информации админа {user.id}: {e}")
+    
+    def is_admin(self, telegram_id: int) -> bool:
+        """Проверяет, является ли пользователь админом"""
+        return telegram_id in self.admin_ids
+    
+    def is_in_admin_mode(self, telegram_id: int) -> bool:
+        """Проверяет, находится ли админ в режиме администратора"""
+        if not self.is_admin(telegram_id):
+            return False
+        return self.admin_modes.get(telegram_id, True)
+    
+    def toggle_admin_mode(self, telegram_id: int) -> bool:
+        """Переключает режим админа. Возвращает новое состояние"""
+        if not self.is_admin(telegram_id):
+            return False
+        
+        current_mode = self.admin_modes.get(telegram_id, True)
+        new_mode = not current_mode
+        self.admin_modes[telegram_id] = new_mode
+        
+        logger.info(f"Админ {telegram_id} переключен в режим: {'администратор' if new_mode else 'пользователь'}")
+        return new_mode
+    
+    def set_admin_mode(self, telegram_id: int, is_admin_mode: bool):
+        """Устанавливает режим админа"""
+        if not self.is_admin(telegram_id):
+            return
+        
+        self.admin_modes[telegram_id] = is_admin_mode
+        logger.info(f"Режим админа {telegram_id} установлен: {'администратор' if is_admin_mode else 'пользователь'}")
+    
+    async def get_active_admins(self) -> List[int]:
+        """Возвращает список активных админов в режиме администратора"""
+        return [admin_id for admin_id in self.admin_ids if self.is_in_admin_mode(admin_id)]
+    
+    def get_admin_mode_text(self, telegram_id: int) -> str:
+        """Возвращает текстовое описание режима админа"""
+        if not self.is_admin(telegram_id):
+            return "Не администратор"
+        
+        if self.is_in_admin_mode(telegram_id):
+            return "👑 Режим администратора"
+        else:
+            return "👤 Режим пользователя"
+    
+    def format_admin_status(self, telegram_id: int) -> str:
+        """Форматирует статус админа для отображения"""
+        if not self.is_admin(telegram_id):
+            return ""
+        
+        mode = "👑 АДМИН" if self.is_in_admin_mode(telegram_id) else "👤 ПОЛЬЗ"
+        return f"[{mode}]"
+    
+    async def notify_admins(self, message: str, exclude_admin: int = None):
+        """Отправляет уведомление всем активным админам"""
+        from main import bot  # Импорт здесь чтобы избежать циклических импортов
+        
+        active_admins = await self.get_active_admins()
+        
+        if exclude_admin:
+            active_admins = [aid for aid in active_admins if aid != exclude_admin]
+        
+        sent_count = 0
+        for admin_id in active_admins:
+            try:
+                await bot.send_message(admin_id, message, parse_mode='Markdown')
+                sent_count += 1
+            except Exception as e:
+                logger.error(f"Ошибка отправки уведомления админу {admin_id}: {e}")
+        
+        logger.info(f"Уведомление отправлено {sent_count} админам")
+        return sent_count
+    
+    def get_stats(self) -> Dict[str, any]:
+        """Возвращает статистику по админам"""
+        total_admins = len(self.admin_ids)
+        active_admins = len([aid for aid in self.admin_ids if self.is_in_admin_mode(aid)])
+        
+        return {
+            'total_admins': total_admins,
+            'active_admins': active_admins,
+            'admin_ids': list(self.admin_ids),
+            'modes': dict(self.admin_modes)
+        }