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

smart_bot_factory/creation/bot_testing.py

@@ -13,6 +13,12 @@
     
 ОТЧЕТЫ:
     bots/BOT_ID/reports/test_YYYYMMDD_HHMMSS.txt - подробные отчеты
+
+ФОРМАТ СЦЕНАРИЕВ:
+    expected_keywords поддерживает синонимы:
+    - Одно слово: ["привет"] - проверяется только это слово
+    - Синонимы: [["привет", "здравствуйте", "добро пожаловать"]] - достаточно найти любое из слов
+    - Смешанный формат: ["привет", ["здравствуйте", "добро пожаловать"]] - комбинация одиночных слов и синонимов
 """
 
 import asyncio
@@ -73,8 +79,25 @@ class TestStep:
     def __init__(self, user_input: str, expected_keywords: List[str], 
                  forbidden_keywords: List[str] = None):
         self.user_input = user_input
-        self.expected_keywords = [kw.lower() for kw in expected_keywords]
+        # Поддержка синонимов: если элемент списка - список, то это синонимы
+        self.expected_keywords = self._process_keywords(expected_keywords)
         self.forbidden_keywords = [kw.lower() for kw in (forbidden_keywords or [])]
+    
+    def _process_keywords(self, keywords: List) -> List:
+        """Обрабатывает ключевые слова, поддерживая синонимы"""
+        processed = []
+        for kw in keywords:
+            if isinstance(kw, list):
+                # Это группа синонимов
+                synonyms = [s.lower() for s in kw if isinstance(s, str)]
+                processed.append(synonyms)
+            elif isinstance(kw, str):
+                # Одно слово
+                processed.append([kw.lower()])
+            else:
+                # Игнорируем неверные типы
+                continue
+        return processed
 
 
 class TestScenario:
@@ -343,7 +366,14 @@ class BotTester:
                 logging.info(f"💬 Ввод пользователя: '{step.user_input}'")
                 
                 if step.expected_keywords:
-                    logging.info(f"🎯 Ожидаемые слова: {step.expected_keywords}")
+                    # Форматируем ожидаемые ключевые слова для логов
+                    expected_display = []
+                    for group in step.expected_keywords:
+                        if len(group) == 1:
+                            expected_display.append(group[0])
+                        else:
+                            expected_display.append(f"[{'/'.join(group)}]")
+                    logging.info(f"🎯 Ожидаемые слова: {expected_display}")
                 if step.forbidden_keywords:
                     logging.info(f"🚫 Запрещенные слова: {step.forbidden_keywords}")
                 
@@ -358,14 +388,25 @@ class BotTester:
                 logging.info(f"🤖 Ответ бота: '{response_preview}'")
                 logging.info(f"⏱️ Время обработки: {step_duration}мс")
                 
-                # Проверяем ожидаемые ключевые слова
-                missing_keywords = []
+                # Проверяем ожидаемые ключевые слова (с поддержкой синонимов)
+                missing_keyword_groups = []
                 found_expected = []
-                for keyword in step.expected_keywords:
-                    if keyword.lower() in clean_response.lower():
-                        found_expected.append(keyword)
+                for keyword_group in step.expected_keywords:
+                    # keyword_group - это либо список синонимов, либо список с одним словом
+                    found_in_group = False
+                    found_synonym = None
+                    
+                    for synonym in keyword_group:
+                        if synonym in clean_response.lower():
+                            found_in_group = True
+                            found_synonym = synonym
+                            break
+                    
+                    if found_in_group:
+                        found_expected.append(found_synonym)
                     else:
-                        missing_keywords.append(keyword)
+                        # Если группа синонимов не найдена, добавляем всю группу в missing
+                        missing_keyword_groups.append(keyword_group)
                 
                 # Проверяем запрещенные ключевые слова
                 found_forbidden = []
@@ -376,22 +417,34 @@ class BotTester:
                 # Выводим результаты проверки
                 if found_expected:
                     logging.info(f"✅ Найденные ожидаемые: {found_expected}")
-                if missing_keywords:
-                    logging.info(f"❌ НЕ найденные ожидаемые: {missing_keywords}")
+                if missing_keyword_groups:
+                    # Показываем пропущенные группы синонимов в удобном формате
+                    missing_display = []
+                    for group in missing_keyword_groups:
+                        if len(group) == 1:
+                            missing_display.append(group[0])
+                        else:
+                            missing_display.append(f"[{'/'.join(group)}]")
+                    logging.info(f"❌ НЕ найденные ожидаемые: {missing_display}")
                 if found_forbidden:
                     logging.info(f"🚫 Найденные запрещенные: {found_forbidden}")
                 
                 # Определяем результат шага
-                passed = len(missing_keywords) == 0 and len(found_forbidden) == 0
+                passed = len(missing_keyword_groups) == 0 and len(found_forbidden) == 0
                 status_icon = "✅" if passed else "❌"
                 status_text = "ПРОЙДЕН" if passed else "ПРОВАЛЕН"
                 logging.info(f"🎯 Результат шага {step_num}: {status_icon} {status_text}")
                 
+                # Преобразуем missing_keyword_groups в плоский список для обратной совместимости
+                missing_keywords_flat = []
+                for group in missing_keyword_groups:
+                    missing_keywords_flat.extend(group)
+                
                 step_result = StepResult(
                     step=step,
                     bot_response=clean_response,
                     passed=passed,
-                    missing_keywords=missing_keywords,
+                    missing_keywords=missing_keywords_flat,
                     found_forbidden=found_forbidden
                 )
                 
@@ -813,10 +866,18 @@ class ReportGenerator:
                     step_num = i + 1
                     status = "✅" if step_result.passed else "❌"
                     
+                    # Форматируем ожидаемые ключевые слова с учетом синонимов
+                    expected_display = []
+                    for group in step_result.step.expected_keywords:
+                        if len(group) == 1:
+                            expected_display.append(group[0])
+                        else:
+                            expected_display.append(f"[{'/'.join(group)}]")
+                    
                     report_lines.extend([
                         f"ШАГ {step_num} {status}:",
                         f"  Ввод: \"{step_result.step.user_input}\"",
-                        f"  Ожидаемые: {step_result.step.expected_keywords}",
+                        f"  Ожидаемые: {expected_display}",
                         f"  Запрещенные: {step_result.step.forbidden_keywords}",
                         ""
                     ])

smart_bot_factory/handlers/handlers.py

@@ -134,8 +134,16 @@ async def user_start_handler(message: Message, state: FSMContext):
         await state.set_state(UserStates.waiting_for_message)
         
         # 6. ОТПРАВЛЯЕМ ПРИВЕТСТВЕННОЕ СООБЩЕНИЕ
-        await send_message(message, welcome_message)
-        logger.info(f"Приветственное сообщение отправлено пользователю {message.from_user.id}")
+        try:
+            await send_message(message, welcome_message)
+            logger.info(f"Приветственное сообщение отправлено пользователю {message.from_user.id}")
+        except Exception as e:
+            if "Forbidden: bot was blocked by the user" in str(e):
+                logger.warning(f"🚫 Бот заблокирован пользователем {message.from_user.id}")
+                return
+            else:
+                logger.error(f"❌ Ошибка отправки приветственного сообщения: {e}")
+                raise
         
         # 7. ЕСЛИ ЕСТЬ ФАЙЛ ОТПРАВЛЯЕМ ВМЕСТЕ С ПОДПИСЬЮ
         logging.info(f"📎 Попытка отправки приветственного файла для сессии {session_id}")

smart_bot_factory/integrations/__init__.py

@@ -7,3 +7,4 @@ from .openai_client import OpenAIClient
 __all__ = ['OpenAIClient']
 
 
+

smart_bot_factory/integrations/supabase_client.py

@@ -421,7 +421,7 @@ class SupabaseClient:
             logger.error(f"Ошибка при завершении диалогов: {e}")
             return 0
     
-    async def get_admin_conversation(self, admin_id: int) -> Optional[Dict[str, Any]]:
+    async def get_admin_active_conversation(self, admin_id: int) -> Optional[Dict[str, Any]]:
         """Получает активный диалог админа"""
         try:
             response = self.client.table('admin_user_conversations').select(
@@ -589,4 +589,274 @@ class SupabaseClient:
             
         except APIError as e:
             logger.error(f"Ошибка при архивировании сессий: {e}")
-            raise
+            raise
+    
+    async def get_sent_files(self, user_id: int) -> List[str]:
+        """Получает список отправленных файлов для пользователя
+        
+        Args:
+            user_id: Telegram ID пользователя
+            
+        Returns:
+            List[str]: Список имен файлов, разделенных запятой
+        """
+        try:
+            query = self.client.table('sales_users').select('files').eq('telegram_id', user_id)
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            if response.data and response.data[0].get('files'):
+                files_str = response.data[0]['files']
+                return [f.strip() for f in files_str.split(',') if f.strip()]
+            
+            return []
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения отправленных файлов для пользователя {user_id}: {e}")
+            return []
+    
+    async def get_sent_directories(self, user_id: int) -> List[str]:
+        """Получает список отправленных каталогов для пользователя
+        
+        Args:
+            user_id: Telegram ID пользователя
+            
+        Returns:
+            List[str]: Список путей каталогов, разделенных запятой
+        """
+        try:
+            query = self.client.table('sales_users').select('directories').eq('telegram_id', user_id)
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            if response.data and response.data[0].get('directories'):
+                dirs_str = response.data[0]['directories']
+                return [d.strip() for d in dirs_str.split(',') if d.strip()]
+            
+            return []
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения отправленных каталогов для пользователя {user_id}: {e}")
+            return []
+    
+    async def add_sent_files(self, user_id: int, files_list: List[str]):
+        """Добавляет файлы в список отправленных для пользователя
+        
+        Args:
+            user_id: Telegram ID пользователя
+            files_list: Список имен файлов для добавления
+        """
+        try:
+            logger.info(f"Добавление файлов для пользователя {user_id}: {files_list}")
+            
+            # Получаем текущий список
+            current_files = await self.get_sent_files(user_id)
+            logger.info(f"Текущие файлы в БД: {current_files}")
+            
+            # Объединяем с новыми файлами (без дубликатов)
+            all_files = list(set(current_files + files_list))
+            logger.info(f"Объединенный список файлов: {all_files}")
+            
+            # Сохраняем обратно
+            files_str = ', '.join(all_files)
+            logger.info(f"Сохраняем строку: {files_str}")
+            
+            query = self.client.table('sales_users').update({
+                'files': files_str
+            }).eq('telegram_id', user_id)
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+                logger.info(f"Фильтр по bot_id: {self.bot_id}")
+            
+            response = query.execute()
+            logger.info(f"Ответ от БД: {response.data}")
+            
+            logger.info(f"✅ Добавлено {len(files_list)} файлов для пользователя {user_id}")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка добавления отправленных файлов для пользователя {user_id}: {e}")
+            logger.exception("Полный стек ошибки:")
+    
+    async def add_sent_directories(self, user_id: int, dirs_list: List[str]):
+        """Добавляет каталоги в список отправленных для пользователя
+        
+        Args:
+            user_id: Telegram ID пользователя
+            dirs_list: Список путей каталогов для добавления
+        """
+        try:
+            logger.info(f"Добавление каталогов для пользователя {user_id}: {dirs_list}")
+            
+            # Получаем текущий список
+            current_dirs = await self.get_sent_directories(user_id)
+            logger.info(f"Текущие каталоги в БД: {current_dirs}")
+            
+            # Объединяем с новыми каталогами (без дубликатов)
+            all_dirs = list(set(current_dirs + dirs_list))
+            logger.info(f"Объединенный список каталогов: {all_dirs}")
+            
+            # Сохраняем обратно
+            dirs_str = ', '.join(all_dirs)
+            logger.info(f"Сохраняем строку: {dirs_str}")
+            
+            query = self.client.table('sales_users').update({
+                'directories': dirs_str
+            }).eq('telegram_id', user_id)
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+                logger.info(f"Фильтр по bot_id: {self.bot_id}")
+            
+            response = query.execute()
+            logger.info(f"Ответ от БД: {response.data}")
+            
+            logger.info(f"✅ Добавлено {len(dirs_list)} каталогов для пользователя {user_id}")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка добавления отправленных каталогов для пользователя {user_id}: {e}")
+            logger.exception("Полный стек ошибки:")
+
+    # =============================================================================
+    # МЕТОДЫ ДЛЯ АНАЛИТИКИ
+    # =============================================================================
+    
+    async def get_funnel_stats(self, days: int = 7) -> Dict[str, Any]:
+        """Получает статистику воронки продаж"""
+        try:
+            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            
+            # Общее количество сессий
+            sessions_response = self.client.table('sales_chat_sessions').select('id').gte(
+                'created_at', cutoff_date.isoformat()
+            )
+            if self.bot_id:
+                sessions_response = sessions_response.eq('bot_id', self.bot_id)
+            
+            total_sessions = len(sessions_response.execute().data)
+            
+            # Статистика по этапам
+            stages_response = self.client.table('sales_chat_sessions').select(
+                'current_stage', 'quality_score'
+            ).gte('created_at', cutoff_date.isoformat())
+            
+            if self.bot_id:
+                stages_response = stages_response.eq('bot_id', self.bot_id)
+            
+            sessions_data = stages_response.execute().data
+            
+            stages = {}
+            quality_scores = []
+            
+            for session in sessions_data:
+                stage = session.get('current_stage', 'unknown')
+                stages[stage] = stages.get(stage, 0) + 1
+                
+                if session.get('quality_score'):
+                    quality_scores.append(session['quality_score'])
+            
+            avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+            
+            return {
+                'total_sessions': total_sessions,
+                'stages': stages,
+                'avg_quality': round(avg_quality, 2),
+                'period_days': days
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения статистики воронки: {e}")
+            return {
+                'total_sessions': 0,
+                'stages': {},
+                'avg_quality': 0,
+                'period_days': days
+            }
+    
+    async def get_events_stats(self, days: int = 7) -> Dict[str, int]:
+        """Получает статистику событий"""
+        try:
+            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            
+            response = self.client.table('scheduled_events').select(
+                'event_type', 'status'
+            ).gte('created_at', cutoff_date.isoformat())
+            
+            events_data = response.execute().data
+            
+            stats = {}
+            for event in events_data:
+                event_type = event.get('event_type', 'unknown')
+                status = event.get('status', 'unknown')
+                
+                key = f"{event_type}_{status}"
+                stats[key] = stats.get(key, 0) + 1
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения статистики событий: {e}")
+            return {}
+
+    async def get_user_last_message_info(self, user_id: int) -> Optional[Dict[str, Any]]:
+        """Получает информацию о последнем сообщении пользователя"""
+        try:
+            # Получаем последнее сообщение пользователя
+            response = self.client.table('sales_messages').select(
+                'id', 'created_at', 'session_id', 'sender_type'
+            ).eq('sender_telegram_id', user_id).order('created_at', desc=True).limit(1).execute()
+            
+            if not response.data:
+                return None
+            
+            last_message = response.data[0]
+            
+            # Получаем информацию о сессии
+            session_response = self.client.table('sales_chat_sessions').select(
+                'id', 'current_stage', 'updated_at'
+            ).eq('id', last_message['session_id']).execute()
+            
+            if not session_response.data:
+                return None
+            
+            session = session_response.data[0]
+            
+            return {
+                'last_message_at': last_message['created_at'],
+                'session_id': last_message['session_id'],
+                'current_stage': session['current_stage'],
+                'session_updated_at': session['updated_at']
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения информации о последнем сообщении пользователя {user_id}: {e}")
+            return None
+
+    async def check_user_stage_changed(self, user_id: int, original_session_id: str) -> bool:
+        """Проверяет, изменился ли этап пользователя с момента планирования события"""
+        try:
+            # Получаем текущую информацию о сессии
+            response = self.client.table('sales_chat_sessions').select(
+                'id', 'current_stage'
+            ).eq('user_telegram_id', user_id).order('created_at', desc=True).limit(1).execute()
+            
+            if not response.data:
+                return False
+            
+            current_session = response.data[0]
+            
+            # Если сессия изменилась - этап точно изменился
+            if current_session['id'] != original_session_id:
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки изменения этапа пользователя {user_id}: {e}")
+            return False

smart_bot_factory/utm_link_generator.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Генератор UTM-ссылок для Telegram ботов
+Создает ссылки в формате: @https://t.me/bot?start=source-vk_campaign-summer2025
+"""
+
+def get_user_input():
+    """Получает данные от пользователя через консоль"""
+    print("🔗 Генератор UTM-ссылок для Telegram")
+    print("=" * 50)
+    
+    # Основные параметры
+    bot_username = input("Введите username бота (без @): ").strip()
+    if not bot_username:
+        print("❌ Username бота обязателен!")
+        return None
+    
+    print("\n📊 Введите UTM-метки (нажмите Enter для пропуска):")
+    
+    # UTM параметры (соответствуют полям в базе данных)
+    utm_source = input("utm_source (источник): ").strip()
+    utm_medium = input("utm_medium (канал): ").strip()
+    utm_campaign = input("utm_campaign (кампания): ").strip()
+    utm_content = input("utm_content (контент): ").strip()
+    utm_term = input("utm_term (ключевое слово): ").strip()
+    
+    return {
+        'bot_username': bot_username,
+        'utm_source': utm_source,
+        'utm_medium': utm_medium,
+        'utm_campaign': utm_campaign,
+        'utm_content': utm_content,
+        'utm_term': utm_term
+    }
+
+def create_utm_string(utm_data):
+    """Создает строку UTM параметров в формате source-vk_campaign-summer2025"""
+    utm_parts = []
+    
+    # Маппинг полей базы данных на новый формат (без utm, в нижнем регистре)
+    field_mapping = {
+        'utm_source': 'source',
+        'utm_medium': 'medium', 
+        'utm_campaign': 'campaign',
+        'utm_content': 'content',
+        'utm_term': 'term'
+    }
+    
+    for db_field, utm_field in field_mapping.items():
+        value = utm_data.get(db_field)
+        if value:
+            utm_parts.append(f"{utm_field}-{value}")
+    
+    return "_".join(utm_parts)
+
+def generate_telegram_link(bot_username, utm_string):
+    """Генерирует полную ссылку на Telegram бота"""
+    return f"https://t.me/{bot_username}?start={utm_string}"
+
+def check_size_and_validate(utm_string):
+    """Проверяет размер строки после start= и валидирует"""
+    MAX_SIZE = 64
+    
+    if len(utm_string) > MAX_SIZE:
+        return False, f"Строка слишком большая: {len(utm_string)} символов (максимум {MAX_SIZE})"
+    
+    return True, f"Размер OK: {len(utm_string)} символов"
+
+
+def main():
+    """Основная функция"""
+    try:
+        # Получаем данные от пользователя
+        data = get_user_input()
+        if not data:
+            return
+        
+        # Создаем UTM строку
+        utm_string = create_utm_string(data)
+        
+        if not utm_string:
+            print("❌ Не указано ни одной UTM-метки!")
+            return
+        
+        # Проверяем размер
+        is_valid, size_message = check_size_and_validate(utm_string)
+        
+        print(f"\n📏 {size_message}")
+        
+        if not is_valid:
+            print("❌ Ссылка превышает максимальный размер!")
+            print("💡 Сократите значения UTM-меток или уберите менее важные")
+            return
+        
+        # Генерируем и выводим ссылку
+        telegram_link = generate_telegram_link(data['bot_username'], utm_string)
+        
+        print(f"\n✅ Сгенерированная ссылка:")
+        print(f"🔗 {telegram_link}")
+    except KeyboardInterrupt:
+        print("\n\n👋 Отменено пользователем")
+    except Exception as e:
+        print(f"\n❌ Ошибка: {e}")
+
+if __name__ == "__main__":
+    main()