smart-bot-factory 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

smart_bot_factory/integrations/supabase_client.py

@@ -52,15 +52,65 @@ class SupabaseClient:
             response = query.execute()
             
             if response.data:
-                # Обновляем данные существующего пользователя
-                update_query = self.client.table('sales_users').update({
+                # Получаем текущие данные пользователя для мержинга UTM и сегментов
+                existing_user_query = self.client.table('sales_users').select(
+                    'source', 'medium', 'campaign', 'content', 'term', 'segments'
+                ).eq('telegram_id', user_data['telegram_id'])
+                
+                if self.bot_id:
+                    existing_user_query = existing_user_query.eq('bot_id', self.bot_id)
+                
+                existing_response = existing_user_query.execute()
+                existing_utm = existing_response.data[0] if existing_response.data else {}
+                
+                # Формируем данные для обновления
+                update_data = {
                     'username': user_data.get('username'),
                     'first_name': user_data.get('first_name'),
                     'last_name': user_data.get('last_name'),
                     'language_code': user_data.get('language_code'),
                     'updated_at': datetime.now().isoformat(),
                     'is_active': True
-                }).eq('telegram_id', user_data['telegram_id'])
+                }
+                
+                # Мержим UTM данные: обновляем только если новое значение не None
+                utm_fields = ['source', 'medium', 'campaign', 'content', 'term']
+                for field in utm_fields:
+                    new_value = user_data.get(field)
+                    if new_value is not None:
+                        # Есть новое значение - обновляем
+                        update_data[field] = new_value
+                        if existing_utm.get(field) != new_value:
+                            logger.info(f"📊 UTM обновление: {field} = '{new_value}' (было: '{existing_utm.get(field)}')")
+                    else:
+                        # Нового значения нет - сохраняем старое
+                        update_data[field] = existing_utm.get(field)
+                
+                # Обрабатываем сегменты с накоплением через запятую
+                new_segment = user_data.get('segment')
+                if new_segment:
+                    existing_segments = existing_utm.get('segments', '') or ''
+                    if existing_segments:
+                        # Разбираем существующие сегменты
+                        segments_list = [s.strip() for s in existing_segments.split(',') if s.strip()]
+                        # Добавляем новый сегмент, если его еще нет
+                        if new_segment not in segments_list:
+                            segments_list.append(new_segment)
+                            update_data['segments'] = ', '.join(segments_list)
+                            logger.info(f"📊 Сегмент добавлен: '{new_segment}' (было: '{existing_segments}')")
+                        else:
+                            update_data['segments'] = existing_segments
+                            logger.info(f"📊 Сегмент '{new_segment}' уже существует")
+                    else:
+                        # Первый сегмент
+                        update_data['segments'] = new_segment
+                        logger.info(f"📊 Первый сегмент добавлен: '{new_segment}'")
+                else:
+                    # Нового сегмента нет - сохраняем старое значение
+                    update_data['segments'] = existing_utm.get('segments')
+                
+                # Обновляем пользователя
+                update_query = self.client.table('sales_users').update(update_data).eq('telegram_id', user_data['telegram_id'])
                 
                 if self.bot_id:
                     update_query = update_query.eq('bot_id', self.bot_id)
@@ -83,13 +133,17 @@ class SupabaseClient:
                     'campaign': user_data.get('campaign'),
                     'content': user_data.get('content'),
                     'term': user_data.get('term'),
+                    'segments': user_data.get('segment'),  # Первый сегмент при создании
                 }
                 if self.bot_id:
                     user_insert_data['bot_id'] = self.bot_id
                 
                 response = self.client.table('sales_users').insert(user_insert_data).execute()
                 
-                logger.info(f"Создан новый пользователь {user_data['telegram_id']}{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                if user_data.get('segment'):
+                    logger.info(f"Создан новый пользователь {user_data['telegram_id']} с сегментом '{user_data.get('segment')}'{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                else:
+                    logger.info(f"Создан новый пользователь {user_data['telegram_id']}{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
                 return user_data['telegram_id']
                 
         except APIError as e:
@@ -730,47 +784,71 @@ class SupabaseClient:
     async def get_funnel_stats(self, days: int = 7) -> Dict[str, Any]:
         """Получает статистику воронки продаж"""
         try:
-            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            cutoff_date = datetime.now() - timedelta(days=days)
+            
+                        # Получаем ВСЕ уникальные пользователи из sales_users с фильтром по bot_id
+            users_query = self.client.table('sales_users').select('telegram_id')
             
-            # Общее количество сессий
-            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)
+                users_query = users_query.eq('bot_id', self.bot_id)
             
-            total_sessions = len(sessions_response.execute().data)
+            # Исключаем тестовых пользователей
+            users_query = users_query.neq('username', 'test_user')
             
-            # Статистика по этапам
-            stages_response = self.client.table('sales_chat_sessions').select(
-                'current_stage', 'quality_score'
-            ).gte('created_at', cutoff_date.isoformat())
+            users_response = users_query.execute()
+            total_unique_users = len(users_response.data) if users_response.data else 0
             
+            # Получаем сессии с учетом bot_id за период
+            sessions_query = self.client.table('sales_chat_sessions').select(
+                'id', 'user_id', 'current_stage', 'lead_quality_score', 'created_at'
+            ).gte('created_at', cutoff_date.isoformat())
+
             if self.bot_id:
-                stages_response = stages_response.eq('bot_id', self.bot_id)
+                sessions_query = sessions_query.eq('bot_id', self.bot_id)
+
+            sessions_response = sessions_query.execute()
+            sessions = sessions_response.data
             
-            sessions_data = stages_response.execute().data
+            # Исключаем сессии тестовых пользователей
+            if sessions:
+                # Получаем telegram_id тестовых пользователей
+                test_users_query = self.client.table('sales_users').select('telegram_id').eq('username', 'test_user')
+                if self.bot_id:
+                    test_users_query = test_users_query.eq('bot_id', self.bot_id)
+                
+                test_users_response = test_users_query.execute()
+                test_user_ids = {user['telegram_id'] for user in test_users_response.data} if test_users_response.data else set()
+                
+                # Фильтруем сессии
+                sessions = [s for s in sessions if s['user_id'] not in test_user_ids]
+            
+            total_sessions = len(sessions)
+
+            # Группировка по этапам
             
+            # Группировка по этапам
             stages = {}
             quality_scores = []
             
-            for session in sessions_data:
+            for session in sessions:
                 stage = session.get('current_stage', 'unknown')
                 stages[stage] = stages.get(stage, 0) + 1
                 
-                if session.get('quality_score'):
-                    quality_scores.append(session['quality_score'])
+                score = session.get('lead_quality_score', 5)
+                if score:
+                    quality_scores.append(score)
             
-            avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+            avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 5
             
             return {
                 'total_sessions': total_sessions,
+                'total_unique_users': total_unique_users,  # ✅ ВСЕ уникальные пользователи бота
                 'stages': stages,
-                'avg_quality': round(avg_quality, 2),
+                'avg_quality': round(avg_quality, 1),
                 'period_days': days
             }
-            
-        except Exception as e:
+             
+        except APIError as e:
             logger.error(f"Ошибка получения статистики воронки: {e}")
             return {
                 'total_sessions': 0,
@@ -782,25 +860,50 @@ class SupabaseClient:
     async def get_events_stats(self, days: int = 7) -> Dict[str, int]:
         """Получает статистику событий"""
         try:
-            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            cutoff_date = datetime.now() - timedelta(days=days)
             
-            response = self.client.table('scheduled_events').select(
-                'event_type', 'status'
+            # Получаем события с учетом bot_id через сессии
+            query = self.client.table('session_events').select(
+                'event_type', 'session_id'
             ).gte('created_at', cutoff_date.isoformat())
             
-            events_data = response.execute().data
+            events_response = query.execute()
+            events = events_response.data if events_response.data else []
             
-            stats = {}
-            for event in events_data:
-                event_type = event.get('event_type', 'unknown')
-                status = event.get('status', 'unknown')
+            # Фильтруем события по bot_id через сессии
+            if self.bot_id and events:
+                # Получаем ID сессий этого бота
+                sessions_query = self.client.table('sales_chat_sessions').select('id', 'user_id').eq('bot_id', self.bot_id)
+                sessions_response = sessions_query.execute()
                 
-                key = f"{event_type}_{status}"
-                stats[key] = stats.get(key, 0) + 1
+                # Исключаем сессии тестовых пользователей
+                if sessions_response.data:
+                    # Получаем telegram_id тестовых пользователей
+                    test_users_query = self.client.table('sales_users').select('telegram_id').eq('username', 'test_user')
+                    if self.bot_id:
+                        test_users_query = test_users_query.eq('bot_id', self.bot_id)
+                    
+                    test_users_response = test_users_query.execute()
+                    test_user_ids = {user['telegram_id'] for user in test_users_response.data} if test_users_response.data else set()
+                    
+                    # Фильтруем сессии: только не тестовые
+                    bot_sessions = [s for s in sessions_response.data if s['user_id'] not in test_user_ids]
+                    bot_session_ids = {session['id'] for session in bot_sessions}
+                else:
+                    bot_session_ids = set()
+                
+                # Фильтруем события
+                events = [event for event in events if event['session_id'] in bot_session_ids]
+            
+            # Группируем по типам событий
+            event_counts = {}
+            for event in events:
+                event_type = event.get('event_type', 'unknown')
+                event_counts[event_type] = event_counts.get(event_type, 0) + 1
             
-            return stats
+            return event_counts
             
-        except Exception as e:
+        except APIError as e:
             logger.error(f"Ошибка получения статистики событий: {e}")
             return {}
 
@@ -919,4 +1022,286 @@ class SupabaseClient:
             
         except Exception as e:
             logger.error(f"Ошибка получения последнего события для пользователя {user_id}, тип '{event_type}': {e}")
-            return None
+            return None
+
+    async def get_all_segments(self) -> List[str]:
+        """
+        Получает все уникальные сегменты из таблицы sales_users
+        
+        Returns:
+            List[str]: Список уникальных сегментов
+        """
+        try:
+            # Запрос всех непустых сегментов
+            query = self.client.table('sales_users').select('segments').neq('segments', '')
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            # Собираем все уникальные сегменты
+            all_segments = set()
+            for row in response.data:
+                segments_str = row.get('segments', '')
+                if segments_str:
+                    # Разбираем сегменты через запятую
+                    segments = [s.strip() for s in segments_str.split(',') if s.strip()]
+                    all_segments.update(segments)
+            
+            segments_list = sorted(list(all_segments))
+            logger.info(f"Найдено {len(segments_list)} уникальных сегментов")
+            
+            return segments_list
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения сегментов: {e}")
+            return []
+
+    async def get_users_by_segment(self, segment: str = None) -> List[Dict[str, Any]]:
+        """
+        Получает пользователей по сегменту или всех пользователей
+        
+        Args:
+            segment: Название сегмента (если None - возвращает всех)
+            
+        Returns:
+            List[Dict]: Список пользователей с telegram_id
+        """
+        try:
+            query = self.client.table('sales_users').select('telegram_id, segments')
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            if segment is None:
+                # Все пользователи
+                logger.info(f"Получено {len(response.data)} всех пользователей")
+                return response.data
+            
+            # Фильтруем по сегменту
+            users = []
+            for row in response.data:
+                segments_str = row.get('segments', '')
+                if segments_str:
+                    segments = [s.strip() for s in segments_str.split(',') if s.strip()]
+                    if segment in segments:
+                        users.append(row)
+            
+            logger.info(f"Найдено {len(users)} пользователей с сегментом '{segment}'")
+            return users
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения пользователей по сегменту '{segment}': {e}")
+            return []
+    
+    # =============================================================================
+    # МЕТОДЫ ДЛЯ РАБОТЫ С ФАЙЛАМИ СОБЫТИЙ В SUPABASE STORAGE
+    # =============================================================================
+    
+    async def upload_event_file(
+        self, 
+        event_id: str, 
+        file_data: bytes, 
+        original_name: str,
+        file_id: str
+    ) -> Dict[str, str]:
+        """
+        Загружает файл события в Supabase Storage
+        
+        Args:
+            event_id: ID события из БД (используется как папка)
+            file_data: Байты файла
+            original_name: Оригинальное имя файла (для метаданных)
+            file_id: Уникальный ID файла для хранения
+            
+        Returns:
+            Dict с storage_path и original_name
+        """
+        try:
+            bucket_name = 'admin-events'
+            
+            # Формируем путь: admin-events/event_id/file_id.ext
+            extension = original_name.split('.')[-1] if '.' in original_name else ''
+            storage_name = f"{file_id}.{extension}" if extension else file_id
+            storage_path = f"events/{event_id}/files/{storage_name}"
+            
+            # Определяем MIME-type по оригинальному имени файла
+            import mimetypes
+            content_type, _ = mimetypes.guess_type(original_name)
+            if not content_type:
+                content_type = 'application/octet-stream'
+            
+            # Загружаем в Storage
+            self.client.storage.from_(bucket_name).upload(
+                storage_path,
+                file_data,
+                file_options={"content-type": content_type}
+            )
+            
+            logger.info(f"✅ Файл загружен в Storage: {storage_path}")
+            
+            return {
+                'storage_path': storage_path
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка загрузки файла в Storage: {e}")
+            raise
+    
+    async def download_event_file(self, event_id: str, storage_path: str) -> bytes:
+        """
+        Скачивает файл события из Supabase Storage
+        
+        Args:
+            event_id: ID события
+            storage_path: Полный путь к файлу в Storage
+            
+        Returns:
+            bytes: Содержимое файла
+        """
+        try:
+            bucket_name = 'admin-events'
+            
+            # Скачиваем файл
+            file_data = self.client.storage.from_(bucket_name).download(storage_path)
+            
+            logger.info(f"✅ Файл скачан из Storage: {storage_path}")
+            return file_data
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка скачивания файла из Storage: {e}")
+            raise
+    
+    async def delete_event_files(self, event_id: str):
+        """
+        Удаляет ВСЕ файлы события из Supabase Storage
+        
+        Args:
+            event_id: ID события
+        """
+        try:
+            bucket_name = 'admin-events'
+            event_path = f"events/{event_id}/files"
+            
+            # Получаем список всех файлов в папке события
+            files_list = self.client.storage.from_(bucket_name).list(event_path)
+            
+            if not files_list:
+                logger.info(f"ℹ️ Нет файлов для удаления в событии '{event_id}'")
+                return
+            
+            # Формируем пути для удаления
+            file_paths = [f"{event_path}/{file['name']}" for file in files_list]
+            
+            # Удаляем файлы
+            self.client.storage.from_(bucket_name).remove(file_paths)
+            
+            logger.info(f"✅ Удалено {len(file_paths)} файлов события '{event_id}' из Storage")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка удаления файлов события из Storage: {e}")
+            # Не прерываем выполнение, только логируем
+
+    async def save_admin_event(
+        self,
+        event_name: str,
+        event_data: Dict[str, Any],
+        scheduled_datetime: datetime
+    ) -> Dict[str, Any]:
+        """
+        Сохраняет админское событие в таблицу scheduled_events
+        
+        Args:
+            event_name: Название события
+            event_data: Данные события (сегмент, сообщение, файлы)
+            scheduled_datetime: Дата и время отправки (должно быть в UTC с timezone info)
+            
+        Returns:
+            Dict[str, Any]: {'id': str, 'event_type': str, ...} - все данные созданного события
+        """
+        try:
+            import json
+            
+            # Убеждаемся что datetime в правильном формате для PostgreSQL
+            # Если есть timezone info - используем, иначе предполагаем что это UTC
+            if scheduled_datetime.tzinfo is None:
+                logger.warning("⚠️ scheduled_datetime без timezone info, предполагаем UTC")
+                from datetime import timezone
+                scheduled_datetime = scheduled_datetime.replace(tzinfo=timezone.utc)
+            
+            event_record = {
+                'event_type': event_name,
+                'event_category': 'admin_event',
+                'user_id': None,  # Для всех пользователей
+                'event_data': json.dumps(event_data, ensure_ascii=False),
+                'scheduled_at': scheduled_datetime.isoformat(),
+                'status': 'pending'
+            }
+            
+            response = self.client.table('scheduled_events').insert(event_record).execute()
+            event = response.data[0]
+            
+            logger.info(f"💾 Админское событие '{event_name}' сохранено в БД: {event['id']} на {scheduled_datetime.isoformat()}")
+            return event
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка сохранения админского события: {e}")
+            raise
+
+    async def get_admin_events(self, status: str = None) -> List[Dict[str, Any]]:
+        """
+        Получает админские события
+        
+        Args:
+            status: Фильтр по статусу (pending, completed, cancelled)
+            
+        Returns:
+            List[Dict]: Список админских событий
+        """
+        try:
+            query = self.client.table('scheduled_events').select(
+                '*'
+            ).eq('event_category', 'admin_event')
+            
+            if status:
+                query = query.eq('status', status)
+            
+            response = query.order('scheduled_at', desc=False).execute()
+            
+            logger.info(f"Найдено {len(response.data)} админских событий")
+            return response.data
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения админских событий: {e}")
+            return []
+    
+    async def check_event_name_exists(self, event_name: str) -> bool:
+        """
+        Проверяет существует ли активное событие с таким названием
+        
+        Args:
+            event_name: Название события для проверки
+            
+        Returns:
+            bool: True если активное событие с таким именем существует
+        """
+        try:
+            response = self.client.table('scheduled_events').select(
+                'id', 'event_type', 'status'
+            ).eq('event_category', 'admin_event').eq(
+                'event_type', event_name
+            ).eq('status', 'pending').execute()
+            
+            exists = len(response.data) > 0
+            
+            if exists:
+                logger.info(f"⚠️ Найдено активное событие с названием '{event_name}'")
+            
+            return exists
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки названия события: {e}")
+            return False

smart_bot_factory/utm_link_generator.py

@@ -24,20 +24,24 @@ def get_user_input():
     utm_content = input("utm_content (контент): ").strip()
     utm_term = input("utm_term (ключевое слово): ").strip()
     
+    print("\n🎯 Сегментация (нажмите Enter для пропуска):")
+    segment = input("seg (сегмент): ").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
+        'utm_term': utm_term,
+        'segment': segment
     }
 
 def create_utm_string(utm_data):
-    """Создает строку UTM параметров в формате source-vk_campaign-summer2025"""
+    """Создает строку UTM параметров в формате source-vk_campaign-summer2025_seg-premium"""
     utm_parts = []
     
-    # Маппинг полей базы данных на новый формат (без utm, в нижнем регистре)
+    # Маппинг полей базы данных на формат без префикса utm
     field_mapping = {
         'utm_source': 'source',
         'utm_medium': 'medium', 
@@ -51,6 +55,11 @@ def create_utm_string(utm_data):
         if value:
             utm_parts.append(f"{utm_field}-{value}")
     
+    # Добавляем сегмент, если указан
+    segment = utm_data.get('segment')
+    if segment:
+        utm_parts.append(f"seg-{segment}")
+    
     return "_".join(utm_parts)
 
 def generate_telegram_link(bot_username, utm_string):
@@ -104,3 +113,4 @@ def main():
 
 if __name__ == "__main__":
     main()
+

{smart_bot_factory-0.3.2.dist-info → smart_bot_factory-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.3.2
+Version: 0.3.4
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <eserov73@gmail.com>
 License: MIT
@@ -21,10 +21,12 @@ Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aiogram-media-group>=0.5.1
 Requires-Dist: aiogram>=3.4.1
 Requires-Dist: click>=8.0.0
 Requires-Dist: openai>=1.12.0
 Requires-Dist: project-root-finder>=1.9
+Requires-Dist: python-dateutil>=2.9.0.post0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: pytz>=2023.3
 Requires-Dist: pyyaml>=6.0.2