commons-metrics 0.0.15__py3-none-any.whl

commons_metrics/github_api_client.py

@@ -0,0 +1,305 @@
+import requests
+import base64
+from typing import List, Dict, Optional
+import os
+from .commons_repos_client import extract_package_version_from_pubspec, extract_package_version_from_package_json
+
+class GitHubAPIClient:
+    """
+    Cliente para interactuar con la API de GitHub
+    """
+    
+    def __init__(self, token: str, owner: str = None, repo: str = None):
+        """
+        Inicializa el cliente de GitHub API
+        
+        Args:
+            token: Personal Access Token de GitHub
+            owner: Dueño del repositorio (ej: 'grupobancolombia-innersource') - Opcional
+            repo: Nombre del repositorio (ej: 'NU0066001_BDS_MOBILE_Lib') - Opcional
+        """
+        self.token = token
+        self.owner = owner
+        self.repo = repo
+        self.base_url = f"https://api.github.com/repos/{owner}/{repo}" if owner and repo else "https://api.github.com"
+        self.headers = {
+            "Authorization": f"token {token}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+    
+    def get_directory_contents(self, path: str = "") -> List[Dict]:
+        """
+        Obtiene el contenido de un directorio en el repositorio
+        
+        Args:
+            path: Ruta del directorio (ej: 'lib/atoms')
+            
+        Returns:
+            Lista de diccionarios con información de archivos/carpetas
+        """
+        url = f"{self.base_url}/contents/{path}"
+        response = requests.get(url, headers=self.headers)
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 404:
+            return []
+        else:
+            raise Exception(f"Error getting directory contents: {response.status_code} - {response.text}")
+    
+    def get_file_content(self, path: str) -> Optional[str]:
+        """
+        Obtiene el contenido de un archivo
+        
+        Args:
+            path: Ruta del archivo en el repositorio
+            
+        Returns:
+            Contenido del archivo como string, o None si no existe
+        """
+        url = f"{self.base_url}/contents/{path}"
+        response = requests.get(url, headers=self.headers)
+        
+        if response.status_code == 200:
+            content = response.json()
+            if content.get('encoding') == 'base64':
+                decoded_content = base64.b64decode(content['content']).decode('utf-8')
+                return decoded_content
+            return None
+        elif response.status_code == 404:
+            return None
+        else:
+            raise Exception(f"Error getting file content: {response.status_code} - {response.text}")
+    
+    def list_folders_in_directory(self, path: str) -> List[str]:
+        """
+        Lista solo las carpetas dentro de un directorio
+        
+        Args:
+            path: Ruta del directorio
+            
+        Returns:
+            Lista de nombres de carpetas
+        """
+        contents = self.get_directory_contents(path)
+        folders = [
+            item['name'] 
+            for item in contents 
+            if item['type'] == 'dir'
+        ]
+        return folders
+    
+    def walk_directory(self, path: str = "", extension: str = None, exclude_patterns: List[str] = None) -> List[Dict]:
+        """
+        Recorre recursivamente un directorio y retorna todos los archivos
+        
+        Args:
+            path: Ruta del directorio inicial
+            extension: Extensión a filtrar (ej: '.ts', '.dart')
+            exclude_patterns: Lista de patrones a excluir (ej: ['.spec.', '.test.', '.d.ts'])
+            
+        Returns:
+            Lista de diccionarios con información de archivos encontrados
+        """
+        all_files = []
+        exclude_patterns = exclude_patterns or []
+        
+        def should_exclude(filename: str) -> bool:
+            return any(pattern in filename for pattern in exclude_patterns)
+        
+        def recurse_directory(current_path: str):
+            contents = self.get_directory_contents(current_path)
+            
+            for item in contents:
+                item_path = f"{current_path}/{item['name']}" if current_path else item['name']
+                
+                if item['type'] == 'file':
+                    # Aplicar filtros de extensión y exclusión
+                    if extension and not item['name'].endswith(extension):
+                        continue
+                    if should_exclude(item['name']):
+                        continue
+                    
+                    all_files.append({
+                        'name': item['name'],
+                        'path': item_path,
+                        'url': item.get('url', ''),
+                        'download_url': item.get('download_url', '')
+                    })
+                    
+                elif item['type'] == 'dir':
+                    # Excluir directorios comunes que no contienen componentes
+                    if item['name'] not in ['node_modules', 'dist', 'build', '.git', 'test', 'tests', '__pycache__']:
+                        recurse_directory(item_path)
+        
+        recurse_directory(path)
+        return all_files
+    
+    def search_code(self, query: str, per_page: int = 100) -> List[Dict]:
+        """
+        Busca código en GitHub usando la API de búsqueda
+        
+        Args:
+            query: Query de búsqueda (ej: '"bds_mobile" in:file filename:pubspec.yaml')
+            per_page: Número de resultados por página (máximo 100)
+            
+        Returns:
+            Lista de diccionarios con información de archivos encontrados
+        """
+        all_results = []
+        page = 1
+        
+        while True:
+            url = "https://api.github.com/search/code"
+            params = {
+                'q': query,
+                'per_page': per_page,
+                'page': page
+            }
+            
+            response = requests.get(url, headers=self.headers, params=params)
+            
+            if response.status_code == 200:
+                data = response.json()
+                items = data.get('items', [])
+                
+                if not items:
+                    break
+                
+                all_results.extend(items)
+                
+                # Si hay menos items que per_page, es la última página
+                if len(items) < per_page:
+                    break
+                    
+                page += 1
+            elif response.status_code == 403:
+                # Rate limit alcanzado
+                print(f"⚠️ Rate limit alcanzado. Resultados obtenidos: {len(all_results)}")
+                break
+            else:
+                raise Exception(f"Error searching code: {response.status_code} - {response.text}")
+        
+        return all_results
+    
+    def search_projects_with_bds(self, platform: str, design_system_name: str = None) -> List[Dict]:
+        """
+        Busca proyectos que usan el sistema de diseño BDS (mobile o web)
+        
+        Args:
+            platform: 'mobile' o 'web'
+            design_system_name: Nombre del paquete del sistema de diseño
+                               Si no se proporciona, usa valores por defecto:
+                               - mobile: "bds_mobile"
+                               - web: "@bancolombia/design-system-web"
+            
+        Returns:
+            Lista de proyectos con información del repositorio incluyendo la versión
+        
+        Raises:
+            ValueError: Si platform no es 'mobile' o 'web'
+        """
+        # Validar plataforma
+        if platform not in ['mobile', 'web']:
+            raise ValueError(f"Platform debe ser 'mobile' o 'web', se recibió: {platform}")
+        
+        # Configurar valores según la plataforma
+        if platform == 'mobile':
+            config_file = 'pubspec.yaml'
+            default_package_name = 'bds_mobile'
+            extract_version_method = extract_package_version_from_pubspec
+        else:  # web
+            config_file = 'package.json'
+            default_package_name = '@bancolombia/design-system-web'
+            extract_version_method = extract_package_version_from_package_json
+        
+        # Usar nombre de paquete por defecto si no se proporciona
+        package_name = design_system_name or default_package_name
+        
+        # Agregar filtro de organización si self.owner está definido
+        org_filter = f" org:{self.owner}" if self.owner else ""
+        query = f'"{package_name}" in:file filename:{config_file}{org_filter}'
+        results = self.search_code(query)
+        
+        projects = []
+        for item in results:
+            # Obtener contenido del archivo de configuración para extraer la versión
+            file_content = self._get_file_content_from_url(item['url'])
+            version = extract_version_method(file_content, package_name)
+            
+            project_info = {
+                'name': item['repository']['name'],
+                'full_name': item['repository']['full_name'],
+                'owner': item['repository']['owner']['login'],
+                'repo_url': item['repository']['html_url'],
+                'file_path': item['path'],
+                'bds_version': version
+            }
+            projects.append(project_info)
+        
+        return projects
+    
+    def search_repositories(self, query: str, per_page: int = 100) -> List[Dict]:
+        """
+        Busca repositorios en GitHub usando la API de búsqueda
+        
+        Args:
+            query: Query de búsqueda (ej: 'NU0296001 mobile in:name org:grupobancolombia-innersource')
+            per_page: Número de resultados por página (máximo 100)
+            
+        Returns:
+            Lista de diccionarios con información de repositorios encontrados
+        """
+        all_results = []
+        page = 1
+        search_url = "https://api.github.com/search/repositories"
+        
+        while True:
+            params = {
+                'q': query,
+                'per_page': per_page,
+                'page': page
+            }
+            
+            response = requests.get(search_url, headers=self.headers, params=params)
+            
+            if response.status_code != 200:
+                print(f"Error searching repositories: {response.status_code}")
+                print(f"Response: {response.text}")
+                break
+            
+            data = response.json()
+            items = data.get('items', [])
+            
+            if not items:
+                break
+            
+            all_results.extend(items)
+            
+            # Verificar si hay más páginas
+            if len(items) < per_page:
+                break
+            
+            page += 1
+            
+        return all_results
+    
+    def _get_file_content_from_url(self, api_url: str) -> Optional[str]:
+        """
+        Obtiene el contenido de un archivo desde una URL de la API de GitHub
+        
+        Args:
+            api_url: URL de la API de GitHub para el archivo
+            
+        Returns:
+            Contenido del archivo como string, o None si no existe
+        """
+        response = requests.get(api_url, headers=self.headers)
+        
+        if response.status_code == 200:
+            content = response.json()
+            if content.get('encoding') == 'base64':
+                decoded_content = base64.b64decode(content['content']).decode('utf-8')
+                return decoded_content
+            return None
+        return None

commons_metrics/repositories.py

@@ -0,0 +1,269 @@
+from typing import Optional
+
+class ComponentRepository:
+    """
+    Repository class for component-specific database operations
+    """
+    def __init__(self, db_connection):
+        self.db = db_connection
+
+    def save_component(self, technical_name, functional_name, id_type, folder, class_name, status):
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+
+            insert_query = """
+                INSERT INTO schmetrc.component(technical_name,functional_name, type_id, folder, class_name, status) 
+                VALUES (%s, %s, %s, %s, %s, %s)
+                RETURNING id;
+            """
+
+            cursor.execute(insert_query, (technical_name, functional_name, id_type, folder, class_name, status))
+            component_id = cursor.fetchone()[0]
+            self.db.commit_transaction()
+
+            return component_id
+
+        except Exception as e:
+            self.db.rollback_transaction()
+            raise Exception(f"Error saving component '{technical_name}': {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()
+
+    def query_components_by_type(self, id_type: int) -> list:
+        """
+        Consulta componentes de un tipo específico en la base de datos
+
+        Args:
+            id_type (int): ID del tipo de componente a consultar
+        """
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+
+            query = """
+            SELECT id, technical_name, type_id, status, functional_name, folder, class_name 
+            FROM schmetrc.component 
+            WHERE type_id = %s
+            ORDER BY technical_name
+            """
+
+            cursor.execute(query, (id_type,))
+            results = cursor.fetchall()
+
+            components = []
+            for row in results:
+                component = {
+                    'id': row[0],
+                    'technical_name': row[1],
+                    'type_id': row[2],
+                    'status': row[3],
+                    'functional_name': row[4],
+                    'folder': row[5],
+                    'class_name': row[6]
+                }
+                components.append(component)
+
+            return components
+
+        except Exception as e:
+            raise Exception(f"Error querying components by type {id_type}: {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()
+
+    def query_versions_by_type(self, type_id: int) -> list:
+        """
+        Consulta versiones de un tipo específico (mobile o web) en la base de datos
+
+        Args:
+            type_id (int): ID del tipo (13 para mobile, 12 para web)
+            
+        Returns:
+            list: Lista de versiones con sus IDs
+        """
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+            query = """
+            SELECT id, version, type_id, creation_date
+            FROM schmetrc.general_version
+            WHERE type_id = %s
+            ORDER BY version DESC
+            """
+            cursor.execute(query, (type_id,))
+            results = cursor.fetchall()
+            
+            # Get column names from cursor description
+            column_names = [desc[0] for desc in cursor.description]
+
+            versions = []
+            for row in results:
+                # Crear versión dinámicamente usando los nombres de columnas
+                version = dict(zip(column_names, row))
+                versions.append(version)
+
+            return versions
+
+        except Exception as e:
+            raise RuntimeError(f"Error querying versions by type {type_id}: {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()
+
+    def save_adoption(self, version_id: int, component_id: int, aplication_code: str, count: int, historical_metric_id: int = None):
+        """
+        Inserta un registro de adopción en la tabla schmetrc.general_adoption
+        
+        Args:
+            version_id (int): ID de la versión del sistema de diseño
+            component_id (int): ID del componente
+            aplication_code (str): Código de aplicación (ej: NU0296001)
+            count (int): Cantidad de usos del componente
+            historical_metric_id (int, optional): ID de la fecha en measurement_systems_history. Por defecto None
+        """
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+            insert_query = """
+                INSERT INTO schmetrc.general_adoption(version_id, component_id, aplication_code, count, historical_metric_id) 
+                VALUES (%s, %s, %s, %s, %s)
+                RETURNING id;
+            """
+            
+            cursor.execute(insert_query, (version_id, component_id, aplication_code, count, historical_metric_id))
+            adoption_id = cursor.fetchone()[0]
+            self.db.commit_transaction()
+            return adoption_id
+        except Exception as e:
+            self.db.rollback_transaction()
+            raise RuntimeError(f"Error saving adoption for component {component_id}: {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()
+
+    def get_or_create_current_month_date(self) -> int:
+        """
+        Obtiene el ID de la fecha del mes actual en measurement_systems_history.
+        Si no existe, crea un registro con la fecha de hoy.
+        
+        Returns:
+            int: ID del registro de fecha
+        """
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+            
+            # Buscar si existe un registro del mes actual
+            query_select = """
+            SELECT id
+            FROM schmetrc.measurement_systems_history
+            WHERE EXTRACT(YEAR FROM date) = EXTRACT(YEAR FROM CURRENT_DATE)
+              AND EXTRACT(MONTH FROM date) = EXTRACT(MONTH FROM CURRENT_DATE)
+            LIMIT 1
+            """
+            cursor.execute(query_select)
+            result = cursor.fetchone()
+            
+            if result:
+                # Ya existe un registro del mes actual
+                date_id = result[0]
+                print(f"   ℹ️ Usando fecha existente del mes actual (ID: {date_id})")
+                return date_id
+            else:
+                # No existe, crear uno nuevo con la fecha de hoy
+                query_insert = """
+                INSERT INTO schmetrc.measurement_systems_history (date)
+                VALUES (CURRENT_DATE)
+                RETURNING id
+                """
+                cursor.execute(query_insert)
+                date_id = cursor.fetchone()[0]
+                self.db.commit_transaction()
+                print(f"   ✅ Creado nuevo registro de fecha (ID: {date_id})")
+                return date_id
+            
+        except Exception as e:
+            self.db.rollback_transaction()
+            raise RuntimeError(f"Error getting or creating current month date: {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()
+
+    def delete_adoption_by_date_id(self, date_id: int, type_id: int = None) -> int:
+        """
+        Elimina todos los registros de adopción asociados a un historical_metric_id específico.
+        Opcionalmente filtra por tipo de componente (mobile=13, web=12).
+        Útil para limpiar datos del mes actual antes de una nueva inserción.
+        
+        Args:
+            date_id (int): ID de la fecha cuyos registros se eliminarán (historical_metric_id)
+            type_id (int, optional): ID del tipo de componente para filtrar. Si es None, elimina todos los tipos.
+            
+        Returns:
+            int: Cantidad de registros eliminados
+        """
+        cursor = None
+        try:
+            cursor = self.db.connection.cursor()
+            
+            # Construir query con o sin filtro de tipo
+            if type_id is not None:
+                # Contar registros a eliminar (con filtro de tipo)
+                count_query = """
+                SELECT COUNT(*)
+                FROM schmetrc.general_adoption ga
+                INNER JOIN schmetrc.component c ON ga.component_id = c.id
+                WHERE ga.historical_metric_id = %s AND c.type_id = %s
+                """
+                cursor.execute(count_query, (date_id, type_id))
+                count = cursor.fetchone()[0]
+                
+                if count > 0:
+                    # Eliminar los registros (con filtro de tipo)
+                    delete_query = """
+                    DELETE FROM schmetrc.general_adoption
+                    WHERE id IN (
+                        SELECT ga.id
+                        FROM schmetrc.general_adoption ga
+                        INNER JOIN schmetrc.component c ON ga.component_id = c.id
+                        WHERE ga.historical_metric_id = %s AND c.type_id = %s
+                    )
+                    """
+                    cursor.execute(delete_query, (date_id, type_id))
+                    self.db.commit_transaction()
+                    type_name = "mobile" if type_id == 13 else "web" if type_id == 12 else f"tipo {type_id}"
+                    print(f"   🗑️ Eliminados {count} registros de adopción {type_name} del mes actual")
+                else:
+                    print("   ℹ️ No hay registros previos de adopción para eliminar")
+            else:
+                # Contar registros a eliminar (sin filtro de tipo)
+                count_query = """
+                SELECT COUNT(*)
+                FROM schmetrc.general_adoption
+                WHERE historical_metric_id = %s
+                """
+                cursor.execute(count_query, (date_id,))
+                count = cursor.fetchone()[0]
+                
+                if count > 0:
+                    # Eliminar los registros (sin filtro de tipo)
+                    delete_query = """
+                    DELETE FROM schmetrc.general_adoption
+                    WHERE historical_metric_id = %s
+                    """
+                    cursor.execute(delete_query, (date_id,))
+                    self.db.commit_transaction()
+                    print(f"   🗑️ Eliminados {count} registros de adopción del mes actual")
+                else:
+                    print("   ℹ️ No hay registros previos de adopción para eliminar")
+            
+            return count
+            
+        except Exception as e:
+            self.db.rollback_transaction()
+            raise RuntimeError(f"Error deleting adoption records for date_id {date_id}: {str(e)}")
+        finally:
+            if cursor:
+                cursor.close()