django-cfg 1.4.82__py3-none-any.whl → 1.4.84__py3-none-any.whl

django_cfg/apps/dashboard/api/viewsets.py

@@ -0,0 +1,257 @@
+"""
+Dashboard API ViewSets
+
+Provides RESTful endpoints for dashboard data.
+No ORM dependencies - uses services for data collection.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict
+
+from drf_spectacular.utils import OpenApiParameter, OpenApiResponse, extend_schema, inline_serializer
+from drf_spectacular.types import OpenApiTypes
+from rest_framework import serializers, status, viewsets
+from rest_framework.authentication import BasicAuthentication, SessionAuthentication
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAdminUser
+from rest_framework.response import Response
+
+from ..services import StatisticsService, SystemHealthService
+from .serializers import (
+    ActivityEntrySerializer,
+    APIResponseSerializer,
+    AppStatisticsSerializer,
+    DashboardOverviewSerializer,
+    QuickActionSerializer,
+    StatCardSerializer,
+    SystemHealthItemSerializer,
+    SystemHealthSerializer,
+    SystemMetricsSerializer,
+    UserStatisticsSerializer,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class DashboardViewSet(viewsets.GenericViewSet):
+    """
+    Dashboard Data ViewSet
+
+    Provides comprehensive dashboard endpoints for Next.js frontend.
+    All data is collected via services without ORM dependencies.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: Main entry point for dashboard API%%
+
+    TAGS: dashboard, api, viewset
+    USED_BY: Next.js admin panel
+    """
+
+    authentication_classes = [SessionAuthentication, BasicAuthentication]
+    permission_classes = [IsAdminUser]
+    serializer_class = DashboardOverviewSerializer
+
+    @action(detail=False, methods=['get'], url_path='overview')
+    @extend_schema(
+        summary="Get dashboard overview",
+        description="Retrieve complete dashboard data including stats, health, actions, and metrics",
+        responses={200: DashboardOverviewSerializer},
+        tags=["Dashboard"]
+    )
+    def overview(self, request):
+        """
+        Get complete dashboard overview.
+
+        Returns all dashboard data in a single request:
+        - Statistics cards
+        - System health status
+        - Quick actions
+        - Recent activity
+        - System metrics
+        - User statistics
+        """
+        try:
+            stats_service = StatisticsService()
+            health_service = SystemHealthService()
+
+            data = {
+                'stat_cards': stats_service.get_stat_cards(),
+                'system_health': health_service.get_all_health_checks(),
+                'quick_actions': health_service.get_quick_actions(),
+                'recent_activity': stats_service.get_recent_activity(limit=10),
+                'system_metrics': stats_service.get_system_metrics(),
+                'user_statistics': stats_service.get_user_statistics(),
+                'timestamp': datetime.now().isoformat(),
+            }
+
+            return Response(data)
+
+        except Exception as e:
+            logger.error(f"Dashboard overview API error: {e}", exc_info=True)
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get statistics cards",
+        description="Retrieve dashboard statistics cards with key metrics",
+        responses=StatCardSerializer(many=True),
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='stats/cards', pagination_class=None, serializer_class=StatCardSerializer)
+    def stat_cards(self, request):
+        """Get dashboard statistics cards."""
+        try:
+            stats_service = StatisticsService()
+            cards = stats_service.get_stat_cards()
+
+            return Response(cards)
+
+        except Exception as e:
+            logger.error(f"Stat cards API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get system health status",
+        description="Retrieve overall system health including all component checks",
+        responses={200: SystemHealthSerializer},
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='health', serializer_class=SystemHealthSerializer)
+    def system_health(self, request):
+        """Get overall system health status."""
+        try:
+            health_service = SystemHealthService()
+            health_data = health_service.get_overall_health_status()
+
+            return Response(health_data)
+
+        except Exception as e:
+            logger.error(f"System health API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get quick actions",
+        description="Retrieve quick action buttons for dashboard",
+        responses=QuickActionSerializer(many=True),
+        tags=["Dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='actions', pagination_class=None, serializer_class=QuickActionSerializer)
+    def quick_actions(self, request):
+        """Get quick action buttons."""
+        try:
+            health_service = SystemHealthService()
+            actions = health_service.get_quick_actions()
+
+            return Response(actions)
+
+        except Exception as e:
+            logger.error(f"Quick actions API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get recent activity",
+        description="Retrieve recent system activity entries",
+        parameters=[
+            OpenApiParameter(
+                name='limit',
+                description='Maximum number of entries to return',
+                required=False,
+                type=int,
+                default=10
+            ),
+        ],
+        responses=ActivityEntrySerializer(many=True),
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='activity', pagination_class=None, serializer_class=ActivityEntrySerializer)
+    def recent_activity(self, request):
+        """Get recent activity entries."""
+        try:
+            limit = int(request.query_params.get('limit', 10))
+            stats_service = StatisticsService()
+            activity = stats_service.get_recent_activity(limit=limit)
+
+            return Response(activity)
+
+        except Exception as e:
+            logger.error(f"Recent activity API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get system metrics",
+        description="Retrieve system performance metrics (CPU, memory, disk, etc.)",
+        responses={200: SystemMetricsSerializer},
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='metrics', serializer_class=SystemMetricsSerializer)
+    def system_metrics(self, request):
+        """Get system performance metrics."""
+        try:
+            stats_service = StatisticsService()
+            metrics = stats_service.get_system_metrics()
+
+            return Response(metrics)
+
+        except Exception as e:
+            logger.error(f"System metrics API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get user statistics",
+        description="Retrieve user-related statistics",
+        responses={200: UserStatisticsSerializer},
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='stats/users', serializer_class=UserStatisticsSerializer)
+    def user_statistics(self, request):
+        """Get user statistics."""
+        try:
+            stats_service = StatisticsService()
+            user_stats = stats_service.get_user_statistics()
+
+            return Response(user_stats)
+
+        except Exception as e:
+            logger.error(f"User statistics API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get application statistics",
+        description="Retrieve statistics for all enabled django-cfg applications",
+        responses=AppStatisticsSerializer(many=True),
+        tags=["dashboard"]
+    )
+    @action(detail=False, methods=['get'], url_path='stats/apps', pagination_class=None, serializer_class=AppStatisticsSerializer)
+    def app_statistics(self, request):
+        """Get application-specific statistics."""
+        try:
+            stats_service = StatisticsService()
+            app_stats = stats_service.get_app_statistics()
+
+            # Convert dict to list of {app_name, statistics} objects
+            data = [
+                {'app_name': app_name, 'statistics': stats}
+                for app_name, stats in app_stats.items()
+            ]
+
+            return Response(data)
+
+        except Exception as e:
+            logger.error(f"App statistics API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

django_cfg/apps/dashboard/apps.py

@@ -0,0 +1,23 @@
+"""
+Dashboard App Configuration
+"""
+
+from django.apps import AppConfig
+
+
+class DashboardConfig(AppConfig):
+    """Configuration for Dashboard application."""
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.dashboard'
+    label = 'dashboard'
+    verbose_name = 'Dashboard'
+
+    def ready(self):
+        """
+        Application initialization.
+
+        Called when Django starts. Import signals or perform
+        other initialization tasks here.
+        """
+        pass

django_cfg/apps/dashboard/services/__init__.py

@@ -0,0 +1,11 @@
+"""
+Dashboard Services
+
+Business logic for collecting and aggregating dashboard data.
+Services are separated from views/API layer for better testability and reusability.
+"""
+
+from .statistics_service import StatisticsService
+from .system_health_service import SystemHealthService
+
+__all__ = ['StatisticsService', 'SystemHealthService']

django_cfg/apps/dashboard/services/statistics_service.py

@@ -0,0 +1,235 @@
+"""
+Statistics Service
+
+Collects and aggregates statistics for dashboard display.
+No ORM dependencies - can work with any data source.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class StatisticsService:
+    """
+    Service for collecting dashboard statistics.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: This service collects data from various sources without ORM%%
+
+    TAGS: statistics, dashboard, service
+    """
+
+    def __init__(self):
+        """Initialize statistics service."""
+        self.logger = logger
+
+    def get_user_statistics(self) -> Dict[str, Any]:
+        """
+        Get user-related statistics.
+
+        Returns:
+            Dictionary containing user stats:
+            - total_users: Total number of users
+            - active_users: Number of active users (last 30 days)
+            - new_users: New users in last 7 days
+            - superusers: Number of superusers
+
+        %%AI_HINT: Currently returns mock data. Replace with real data source%%
+        """
+        try:
+            # TODO: Replace with real data collection
+            # Example: from django.contrib.auth import get_user_model
+            # User = get_user_model()
+            # total_users = User.objects.count()
+
+            return {
+                'total_users': 1250,
+                'active_users': 892,
+                'new_users': 45,
+                'superusers': 3,
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting user statistics: {e}")
+            return {
+                'total_users': 0,
+                'active_users': 0,
+                'new_users': 0,
+                'superusers': 0,
+                'error': str(e)
+            }
+
+    def get_app_statistics(self) -> Dict[str, Dict[str, int]]:
+        """
+        Get application-specific statistics.
+
+        Returns:
+            Dictionary with app names as keys and their stats as values.
+            Example:
+            {
+                'leads': {'total': 450, 'active': 120},
+                'tasks': {'total': 1200, 'completed': 890},
+                ...
+            }
+
+        %%AI_HINT: Aggregates statistics from different django-cfg apps%%
+        """
+        try:
+            # TODO: Collect real statistics from enabled apps
+            return {
+                'leads': {
+                    'total': 450,
+                    'active': 120,
+                    'converted': 85,
+                },
+                'tasks': {
+                    'total': 1200,
+                    'completed': 890,
+                    'pending': 310,
+                },
+                'support': {
+                    'total': 340,
+                    'open': 45,
+                    'closed': 295,
+                },
+                'newsletter': {
+                    'subscribers': 2500,
+                    'campaigns': 12,
+                    'sent': 28000,
+                }
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting app statistics: {e}")
+            return {'error': str(e)}
+
+    def get_stat_cards(self) -> List[Dict[str, Any]]:
+        """
+        Get statistics cards for dashboard overview.
+
+        Returns:
+            List of stat card dictionaries ready for serialization.
+            Each card contains: title, value, icon, change, change_type
+
+        USED_BY: DashboardViewSet.overview endpoint
+        """
+        try:
+            user_stats = self.get_user_statistics()
+
+            cards = [
+                {
+                    'title': 'Total Users',
+                    'value': str(user_stats['total_users']),
+                    'icon': 'people',
+                    'change': '+12%',
+                    'change_type': 'positive',
+                    'color': 'primary',
+                },
+                {
+                    'title': 'Active Users',
+                    'value': str(user_stats['active_users']),
+                    'icon': 'person',
+                    'change': '+5%',
+                    'change_type': 'positive',
+                    'color': 'success',
+                },
+                {
+                    'title': 'New Users (7d)',
+                    'value': str(user_stats['new_users']),
+                    'icon': 'person_add',
+                    'change': '-2%',
+                    'change_type': 'negative',
+                    'color': 'warning',
+                },
+                {
+                    'title': 'System Health',
+                    'value': '98%',
+                    'icon': 'health_and_safety',
+                    'change': '+1%',
+                    'change_type': 'positive',
+                    'color': 'success',
+                },
+            ]
+
+            return cards
+
+        except Exception as e:
+            self.logger.error(f"Error generating stat cards: {e}")
+            return []
+
+    def get_recent_activity(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent activity entries for dashboard.
+
+        Args:
+            limit: Maximum number of activity entries to return
+
+        Returns:
+            List of recent activity entries
+
+        %%AI_HINT: Can be connected to django-auditlog or custom activity tracking%%
+        """
+        try:
+            # TODO: Connect to real activity logging system
+            now = datetime.now()
+
+            activities = [
+                {
+                    'id': 1,
+                    'user': 'john@example.com',
+                    'action': 'created',
+                    'resource': 'Lead #1234',
+                    'timestamp': (now - timedelta(minutes=5)).isoformat(),
+                    'icon': 'add_circle',
+                    'color': 'success',
+                },
+                {
+                    'id': 2,
+                    'user': 'admin@example.com',
+                    'action': 'updated',
+                    'resource': 'User Settings',
+                    'timestamp': (now - timedelta(minutes=15)).isoformat(),
+                    'icon': 'edit',
+                    'color': 'primary',
+                },
+                {
+                    'id': 3,
+                    'user': 'sarah@example.com',
+                    'action': 'completed',
+                    'resource': 'Task #456',
+                    'timestamp': (now - timedelta(hours=1)).isoformat(),
+                    'icon': 'check_circle',
+                    'color': 'success',
+                },
+            ]
+
+            return activities[:limit]
+
+        except Exception as e:
+            self.logger.error(f"Error getting recent activity: {e}")
+            return []
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """
+        Get system performance metrics.
+
+        Returns:
+            Dictionary with system metrics (CPU, memory, disk, etc.)
+
+        %%AI_HINT: Can use psutil or similar for real system metrics%%
+        """
+        try:
+            # TODO: Collect real system metrics
+            return {
+                'cpu_usage': 45.2,
+                'memory_usage': 62.8,
+                'disk_usage': 38.5,
+                'network_in': '125 MB/s',
+                'network_out': '89 MB/s',
+                'response_time': '245 ms',
+                'uptime': '15 days, 3 hours',
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting system metrics: {e}")
+            return {'error': str(e)}