django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/apps/system/dashboard/services/config_service.py

@@ -0,0 +1,393 @@
+"""
+Config Service
+
+Service for extracting user's DjangoConfig settings for dashboard display.
+"""
+
+from typing import Dict, Any
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ConfigService:
+    """Service for retrieving user's DjangoConfig settings."""
+
+    @staticmethod
+    def validate_serializer(config_dict: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate that DjangoConfigSerializer matches the actual config structure.
+
+        Compares actual config fields with serializer fields and reports:
+        - Missing fields in serializer
+        - Extra fields in serializer
+        - Type mismatches
+
+        Returns:
+            Dict with validation results
+        """
+        from ..serializers.config import DjangoConfigSerializer
+        from rest_framework import serializers
+
+        validation = {
+            'status': 'valid',
+            'missing_in_serializer': [],
+            'extra_in_serializer': [],
+            'type_mismatches': [],
+            'total_config_fields': len(config_dict),
+            'total_serializer_fields': 0,
+        }
+
+        # Get serializer fields
+        serializer = DjangoConfigSerializer()
+        serializer_fields = serializer.fields
+        validation['total_serializer_fields'] = len(serializer_fields)
+
+        # Get actual config fields (excluding _meta as it's added separately)
+        config_fields = set(config_dict.keys()) - {'_meta'}
+        serializer_field_names = set(serializer_fields.keys())
+
+        # Find missing fields (in config but not in serializer)
+        missing = config_fields - serializer_field_names
+        if missing:
+            validation['missing_in_serializer'] = sorted(list(missing))
+            validation['status'] = 'warning'
+
+        # Find extra fields (in serializer but not in config)
+        extra = serializer_field_names - config_fields - {'_meta'}
+        if extra:
+            validation['extra_in_serializer'] = sorted(list(extra))
+
+        # Check type compatibility for common fields
+        common_fields = config_fields & serializer_field_names
+        for field_name in common_fields:
+            config_value = config_dict[field_name]
+            serializer_field = serializer_fields[field_name]
+
+            # Skip None values
+            if config_value is None:
+                continue
+
+            # Check type compatibility
+            type_mismatch = False
+            expected_type = None
+
+            if isinstance(serializer_field, serializers.BooleanField):
+                expected_type = 'boolean'
+                if not isinstance(config_value, bool):
+                    type_mismatch = True
+            elif isinstance(serializer_field, serializers.IntegerField):
+                expected_type = 'integer'
+                if not isinstance(config_value, int):
+                    type_mismatch = True
+            elif isinstance(serializer_field, serializers.CharField):
+                expected_type = 'string'
+                if not isinstance(config_value, str):
+                    type_mismatch = True
+            elif isinstance(serializer_field, serializers.DictField):
+                expected_type = 'dict'
+                if not isinstance(config_value, dict):
+                    type_mismatch = True
+            elif isinstance(serializer_field, serializers.ListField):
+                expected_type = 'list'
+                if not isinstance(config_value, list):
+                    type_mismatch = True
+
+            if type_mismatch:
+                validation['type_mismatches'].append({
+                    'field': field_name,
+                    'expected_type': expected_type,
+                    'actual_type': type(config_value).__name__,
+                })
+                validation['status'] = 'error'
+
+        return validation
+
+    @staticmethod
+    def get_config_data() -> Dict[str, Any]:
+        """
+        Get user's DjangoConfig as JSON-serializable dict.
+
+        Returns the full config structure as-is, mimicking the user's config.py.
+        This allows frontend to display the config tree exactly as user defined it.
+
+        Returns:
+            Dictionary with full config structure
+        """
+        from django_cfg.core.config import get_current_config
+
+        config = get_current_config()
+
+        if not config:
+            return {'error': 'Config not available'}
+
+        # Use Pydantic's model_dump to get full JSON-serializable structure
+        # This includes all nested models (grpc, centrifugo, databases, etc.)
+        try:
+            config_dict = config.model_dump(
+                mode='json',  # JSON-serializable types
+                exclude={
+                    '_django_settings',  # Internal cache
+                    'secret_key',  # Security - don't expose
+                },
+                exclude_none=False,  # Keep None values to show what's not set
+                by_alias=False,
+            )
+            # Sanitize sensitive data in config
+            config_dict = ConfigService._sanitize_config_dict(config_dict)
+        except Exception as e:
+            # Expected: some config fields contain functions that can't be serialized
+            # Fallback to safe extraction which replaces functions with "<function: name>"
+            logger.debug(f"Using fallback extraction due to: {e}")
+            config_dict = ConfigService._safe_extract_config(config)
+
+        # Add some computed/helpful fields
+        config_dict['_meta'] = {
+            'config_class': config.__class__.__name__,
+            'secret_key_configured': bool(config.secret_key and len(config.secret_key) >= 50),
+        }
+
+        return config_dict
+
+    @staticmethod
+    def get_django_settings() -> Dict[str, Any]:
+        """
+        Get all Django settings as JSON-serializable dict.
+
+        Returns complete Django settings (DATABASES, MIDDLEWARE, etc.)
+        Sanitizes sensitive values like SECRET_KEY, passwords.
+
+        Returns:
+            Dictionary with Django settings
+        """
+        settings_dict = {}
+
+        # List of settings to exclude for security
+        sensitive_keys = {
+            'SECRET_KEY',
+            'DATABASE_PASSWORD',
+            'AWS_SECRET_ACCESS_KEY',
+            'EMAIL_HOST_PASSWORD',
+            'STRIPE_SECRET_KEY',
+            'REDIS_PASSWORD',
+        }
+
+        # Get all settings from Django
+        for key in dir(settings):
+            # Skip private/internal settings
+            if key.startswith('_'):
+                continue
+
+            # Skip methods and callables
+            if callable(getattr(settings, key)):
+                continue
+
+            # Get value
+            value = getattr(settings, key)
+
+            # Special handling for DATABASES (always sanitize)
+            if key == 'DATABASES':
+                settings_dict[key] = ConfigService._sanitize_databases(value)
+            # Sanitize sensitive values
+            elif any(sensitive in key.upper() for sensitive in sensitive_keys):
+                if key == 'SECRET_KEY':
+                    settings_dict[key] = '***HIDDEN***' if value else None
+                else:
+                    settings_dict[key] = '***HIDDEN***' if value else None
+            else:
+                # Try to make value JSON-serializable
+                try:
+                    import json
+                    json.dumps(value)  # Test if serializable
+                    settings_dict[key] = value
+                except (TypeError, ValueError):
+                    # Convert to string if not serializable
+                    settings_dict[key] = str(value)
+
+        return settings_dict
+
+    @staticmethod
+    def _sanitize_databases(databases: Dict) -> Dict:
+        """Sanitize database passwords."""
+        import copy
+        sanitized = {}
+        for alias, config in databases.items():
+            # Deep copy to avoid modifying original
+            sanitized_config = copy.deepcopy(config)
+            if 'PASSWORD' in sanitized_config:
+                sanitized_config['PASSWORD'] = '***HIDDEN***' if sanitized_config['PASSWORD'] else None
+            sanitized[alias] = sanitized_config
+        return sanitized
+
+    @staticmethod
+    def _safe_extract_config(config) -> Dict[str, Any]:
+        """
+        Safely extract config fields, skipping non-serializable values.
+
+        Used as fallback when model_dump fails.
+        """
+        import json
+        safe_dict = {}
+
+        # Get model fields
+        for field_name, field_info in config.model_fields.items():
+            # Skip secret_key
+            if field_name in ('secret_key', '_django_settings'):
+                continue
+
+            try:
+                value = getattr(config, field_name)
+
+                # Replace callables/functions with descriptive string
+                if callable(value) and not isinstance(value, type):
+                    func_name = getattr(value, '__name__', 'unknown')
+                    safe_dict[field_name] = f"<function: {func_name}>"
+                    continue
+
+                # Try to JSON serialize to check if safe
+                try:
+                    json.dumps(value)
+                    safe_dict[field_name] = value
+                except (TypeError, ValueError):
+                    # Try to convert nested Pydantic models
+                    if hasattr(value, 'model_dump'):
+                        try:
+                            safe_dict[field_name] = value.model_dump(mode='json')
+                        except:
+                            safe_dict[field_name] = str(value)
+                    elif isinstance(value, dict):
+                        # Try to dump dict items - recursively clean functions
+                        safe_dict[field_name] = ConfigService._safe_dump_dict(value)
+                    else:
+                        # Convert to string as last resort
+                        safe_dict[field_name] = str(value)
+            except Exception:
+                # Skip fields that can't be accessed
+                continue
+
+        # Sanitize the extracted config
+        safe_dict = ConfigService._sanitize_config_dict(safe_dict)
+
+        return safe_dict
+
+    @staticmethod
+    def _sanitize_config_dict(config_dict: Dict) -> Dict:
+        """
+        Sanitize sensitive values in config dict.
+
+        Hides passwords in:
+        - databases.*.password
+        - email.password
+        - redis/cache passwords
+        - any field with 'password', 'secret', 'token', 'key' in name
+        """
+        import copy
+
+        sanitized = copy.deepcopy(config_dict)
+
+        # Sanitize databases
+        if 'databases' in sanitized and isinstance(sanitized['databases'], dict):
+            logger.info(f"Sanitizing databases: {list(sanitized['databases'].keys())}")
+            for db_alias, db_config in sanitized['databases'].items():
+                if isinstance(db_config, dict) and 'password' in db_config:
+                    logger.info(f"Found password in {db_alias}: {bool(db_config['password'])}")
+                    if db_config['password']:
+                        db_config['password'] = '***HIDDEN***'
+                        logger.info(f"Sanitized password in {db_alias}")
+
+        # Sanitize email password
+        if 'email' in sanitized and isinstance(sanitized['email'], dict):
+            if 'password' in sanitized['email'] and sanitized['email']['password']:
+                sanitized['email']['password'] = '***HIDDEN***'
+
+        # Sanitize cache/redis passwords
+        if 'cache' in sanitized and isinstance(sanitized['cache'], dict):
+            for cache_name, cache_config in sanitized['cache'].items():
+                if isinstance(cache_config, dict) and 'password' in cache_config:
+                    if cache_config['password']:
+                        cache_config['password'] = '***HIDDEN***'
+
+        # Sanitize django_rq redis passwords
+        if 'django_rq' in sanitized and isinstance(sanitized['django_rq'], dict):
+            if 'queues' in sanitized['django_rq'] and isinstance(sanitized['django_rq']['queues'], dict):
+                for queue_name, queue_config in sanitized['django_rq']['queues'].items():
+                    if isinstance(queue_config, dict) and 'password' in queue_config:
+                        if queue_config['password']:
+                            queue_config['password'] = '***HIDDEN***'
+
+        # Generic sanitization: any field with sensitive keywords
+        ConfigService._sanitize_dict_recursive(sanitized)
+
+        return sanitized
+
+    @staticmethod
+    def _sanitize_dict_recursive(d: Dict) -> None:
+        """Recursively sanitize sensitive fields in dict (modifies in-place)."""
+        sensitive_keywords = {'api_key', 'secret_key', 'private_key', 'token', 'api_secret', 'secret', 'ipn_secret'}
+
+        for key, value in d.items():
+            # Check if key contains sensitive keyword
+            key_lower = key.lower()
+            if any(keyword in key_lower for keyword in sensitive_keywords):
+                if value and not isinstance(value, (dict, list)):
+                    d[key] = '***HIDDEN***'
+            # Recurse into nested dicts
+            elif isinstance(value, dict):
+                ConfigService._sanitize_dict_recursive(value)
+            # Recurse into lists of dicts
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        ConfigService._sanitize_dict_recursive(item)
+
+    @staticmethod
+    def _safe_dump_dict(d: Dict) -> Dict:
+        """Recursively dump dict, converting Pydantic models and replacing functions."""
+        import json
+        result = {}
+        for key, value in d.items():
+            try:
+                # Replace callables/functions with descriptive string
+                if callable(value) and not isinstance(value, type):
+                    func_name = getattr(value, '__name__', 'unknown')
+                    result[key] = f"<function: {func_name}>"
+                elif hasattr(value, 'model_dump'):
+                    result[key] = value.model_dump(mode='json')
+                elif isinstance(value, dict):
+                    result[key] = ConfigService._safe_dump_dict(value)
+                elif isinstance(value, list):
+                    # Handle lists that might contain functions or dicts
+                    result[key] = ConfigService._safe_dump_list(value)
+                else:
+                    # Test JSON serializability
+                    json.dumps(value)
+                    result[key] = value
+            except:
+                result[key] = str(value)
+        return result
+
+    @staticmethod
+    def _safe_dump_list(lst: list) -> list:
+        """Recursively dump list, converting Pydantic models and replacing functions."""
+        import json
+        result = []
+        for item in lst:
+            try:
+                # Replace callables/functions with descriptive string
+                if callable(item) and not isinstance(item, type):
+                    func_name = getattr(item, '__name__', 'unknown')
+                    result.append(f"<function: {func_name}>")
+                elif hasattr(item, 'model_dump'):
+                    result.append(item.model_dump(mode='json'))
+                elif isinstance(item, dict):
+                    result.append(ConfigService._safe_dump_dict(item))
+                elif isinstance(item, list):
+                    result.append(ConfigService._safe_dump_list(item))
+                else:
+                    # Test JSON serializability
+                    json.dumps(item)
+                    result.append(item)
+            except:
+                result.append(str(item))
+        return result

django_cfg/apps/system/dashboard/services/overview_service.py

@@ -0,0 +1,205 @@
+"""
+Overview Service
+
+Provides overview data including recent users and activity tracking.
+Extracted from django_dashboard for API-based dashboard.
+"""
+
+import logging
+from datetime import timedelta
+from typing import Any, Dict, List
+
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+
+class OverviewService:
+    """
+    Service for dashboard overview data.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: Provides recent activity and user registration tracking%%
+
+    TAGS: overview, dashboard, activity, service
+    DEPENDS_ON: [django.contrib.auth]
+    """
+
+    def __init__(self):
+        """Initialize overview service."""
+        self.logger = logger
+
+    def _get_user_model(self):
+        """Get the user model safely."""
+        return get_user_model()
+
+    def get_recent_users(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent users for activity section.
+
+        Args:
+            limit: Maximum number of users to return (default: 10)
+
+        Returns:
+            List of user dictionaries with id, username, email, is_active, date_joined
+
+        %%AI_HINT: Real Django ORM query for recent users%%
+        """
+        try:
+            User = self._get_user_model()
+            recent_users = User.objects.order_by('-date_joined')[:limit]
+
+            return [
+                {
+                    'id': user.id,
+                    'username': user.username,
+                    'email': user.email or '',
+                    'is_active': user.is_active,
+                    'is_staff': user.is_staff,
+                    'date_joined': user.date_joined.isoformat() if user.date_joined else None,
+                }
+                for user in recent_users
+            ]
+        except Exception as e:
+            self.logger.error(f"Error getting recent users: {e}")
+            return []
+
+    def get_activity_tracker(self, days: int = 365) -> List[Dict[str, Any]]:
+        """
+        Get activity tracker data for GitHub-style heatmap.
+
+        Returns list of dicts with date and count for last N days.
+
+        Args:
+            days: Number of days to track (default: 365)
+
+        Returns:
+            List of activity data: [{'date': 'YYYY-MM-DD', 'count': int, 'level': int}, ...]
+            level: 0-4 (0=no activity, 4=very high activity)
+
+        %%AI_HINT: Generates daily activity counts from user registrations and logins%%
+        """
+        try:
+            User = self._get_user_model()
+            today = timezone.now().date()
+            activity_data = []
+
+            for days_ago in range(days - 1, -1, -1):  # Newest last
+                date = today - timedelta(days=days_ago)
+
+                # Count user registrations on this day
+                registrations = User.objects.filter(
+                    date_joined__date=date
+                ).count()
+
+                # Count logins on this day (if last_login exists)
+                logins = 0
+                if hasattr(User, 'last_login'):
+                    logins = User.objects.filter(
+                        last_login__date=date
+                    ).count()
+
+                # Total activity for the day
+                total_activity = registrations + logins
+
+                activity_data.append({
+                    'date': date.isoformat(),
+                    'count': total_activity,
+                    'level': self._get_activity_level(total_activity),
+                })
+
+            return activity_data
+
+        except Exception as e:
+            self.logger.error(f"Error getting activity tracker: {e}")
+            return []
+
+    def _get_activity_level(self, count: int) -> int:
+        """
+        Convert activity count to level (0-4) for heatmap colors.
+
+        Args:
+            count: Number of activities
+
+        Returns:
+            Activity level (0-4):
+            - 0 = no activity (gray)
+            - 1 = low (light green)
+            - 2 = medium (green)
+            - 3 = high (dark green)
+            - 4 = very high (darkest green)
+        """
+        if count == 0:
+            return 0
+        elif count <= 2:
+            return 1
+        elif count <= 5:
+            return 2
+        elif count <= 10:
+            return 3
+        else:
+            return 4
+
+    def get_key_stats(self) -> Dict[str, Any]:
+        """
+        Get key statistics for overview.
+
+        Returns:
+            Dictionary with users, databases, apps counts
+
+        %%AI_HINT: Provides high-level system statistics%%
+        """
+        try:
+            User = self._get_user_model()
+
+            # Get database count
+            from django.db import connection
+            db_count = len(connection.settings_dict.get('DATABASES', {})) if hasattr(connection, 'settings_dict') else 1
+
+            # Get app count
+            from django.apps import apps
+            app_count = len(apps.get_app_configs())
+
+            return {
+                'users': User.objects.count(),
+                'databases': db_count,
+                'apps': app_count,
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting key stats: {e}")
+            return {
+                'users': 0,
+                'databases': 0,
+                'apps': 0,
+                'error': str(e)
+            }
+
+    def get_system_info(self) -> Dict[str, Any]:
+        """
+        Get system information.
+
+        Returns:
+            Dictionary with Python version and system metrics
+
+        %%AI_HINT: System-level information using psutil%%
+        """
+        import sys
+        import psutil
+
+        try:
+            return {
+                'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
+                'memory_percent': round(psutil.virtual_memory().percent, 1),
+                'disk_percent': round(psutil.disk_usage('/').percent, 1),
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting system info: {e}")
+            return {
+                'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                'cpu_percent': 0,
+                'memory_percent': 0,
+                'disk_percent': 0,
+                'error': str(e)
+            }