django-cfg 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

django_cfg/apps/maintenance/views/base.py

@@ -0,0 +1,61 @@
+"""
+Base views for maintenance app.
+
+Common functionality and mixins for maintenance views.
+"""
+
+import logging
+from rest_framework import permissions
+from rest_framework.response import Response
+from rest_framework import status
+
+logger = logging.getLogger(__name__)
+
+
+class MaintenancePermissionMixin:
+    """Mixin for maintenance app permissions."""
+    
+    permission_classes = [permissions.IsAuthenticated]
+    
+    def get_user_queryset(self, model_class, owner_field='owner'):
+        """Get queryset filtered by user permissions."""
+        if getattr(self, 'swagger_fake_view', False):
+            return model_class.objects.none()
+        
+        user = self.request.user
+        if user.is_staff:
+            return model_class.objects.all()
+        
+        # Use dynamic field lookup
+        filter_kwargs = {owner_field: user}
+        return model_class.objects.filter(**filter_kwargs)
+
+
+class MaintenanceResponseMixin:
+    """Mixin for standardized API responses."""
+    
+    def success_response(self, message, data=None):
+        """Return standardized success response."""
+        response_data = {
+            'success': True,
+            'message': message
+        }
+        if data is not None:
+            response_data['data'] = data
+        return Response(response_data)
+    
+    def error_response(self, error, status_code=status.HTTP_500_INTERNAL_SERVER_ERROR):
+        """Return standardized error response."""
+        logger.error(f"API Error: {error}")
+        return Response({
+            'success': False,
+            'error': str(error)
+        }, status=status_code)
+    
+    def validation_error_response(self, errors):
+        """Return standardized validation error response."""
+        return Response({
+            'success': False,
+            'error': 'Validation failed',
+            'errors': errors
+        }, status=status.HTTP_400_BAD_REQUEST)

django_cfg/apps/maintenance/views/deployments.py

@@ -0,0 +1,175 @@
+"""
+Cloudflare deployment views.
+
+ViewSets for CloudflareDeployment management.
+"""
+
+import logging
+from rest_framework import viewsets
+from rest_framework.decorators import action
+from drf_spectacular.utils import extend_schema, extend_schema_view
+
+from ..models import CloudflareDeployment
+from ..serializers import (
+    CloudflareDeploymentSerializer, CloudflareDeploymentListSerializer
+)
+from .base import MaintenancePermissionMixin, MaintenanceResponseMixin
+
+logger = logging.getLogger(__name__)
+
+
+@extend_schema_view(
+    list=extend_schema(
+        summary="List Cloudflare deployments",
+        description="Get list of Cloudflare deployments"
+    ),
+    retrieve=extend_schema(
+        summary="Get Cloudflare deployment",
+        description="Get detailed information about a Cloudflare deployment"
+    ),
+    destroy=extend_schema(
+        summary="Delete Cloudflare deployment",
+        description="Delete a Cloudflare deployment record"
+    )
+)
+class CloudflareDeploymentViewSet(MaintenancePermissionMixin, MaintenanceResponseMixin, viewsets.ReadOnlyModelViewSet):
+    """ViewSet for managing Cloudflare deployments (read-only)."""
+    
+    serializer_class = CloudflareDeploymentSerializer
+    lookup_field = 'id'
+    filterset_fields = ['deployment_type', 'status']
+    ordering = ['-deployed_at']
+    
+    def get_queryset(self):
+        """Get queryset filtered by user permissions."""
+        # CloudflareDeployment is related to CloudflareSite via site.owner
+        if getattr(self, 'swagger_fake_view', False):
+            return CloudflareDeployment.objects.none()
+        
+        user = self.request.user
+        if user.is_staff:
+            return CloudflareDeployment.objects.all()
+        
+        return CloudflareDeployment.objects.filter(site__owner=user)
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'list':
+            return CloudflareDeploymentListSerializer
+        return CloudflareDeploymentSerializer
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Rollback deployment",
+        description="Rollback this Cloudflare deployment"
+    )
+    def rollback(self, request, id=None):
+        """Rollback a deployment."""
+        try:
+            deployment = self.get_object()
+            
+            if deployment.status != CloudflareDeployment.Status.ACTIVE:
+                return self.error_response(
+                    f'Cannot rollback deployment with status: {deployment.status}',
+                    status_code=400
+                )
+            
+            # Import Cloudflare service
+            from ..services.cloudflare_service import CloudflareService
+            
+            cloudflare_service = CloudflareService()
+            success = cloudflare_service.rollback_deployment(deployment)
+            
+            if success:
+                deployment.status = CloudflareDeployment.Status.ROLLED_BACK
+                deployment.save()
+                
+                return self.success_response(f'Deployment {deployment.id} rolled back successfully')
+            else:
+                return self.error_response('Failed to rollback deployment')
+                
+        except Exception as e:
+            return self.error_response(f"Rollback deployment error: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Get deployment logs",
+        description="Get logs for this deployment"
+    )
+    def logs(self, request, id=None):
+        """Get logs for a deployment."""
+        try:
+            deployment = self.get_object()
+            
+            # Import Cloudflare service
+            from ..services.cloudflare_service import CloudflareService
+            
+            cloudflare_service = CloudflareService()
+            logs = cloudflare_service.get_deployment_logs(deployment)
+            
+            return self.success_response(
+                f'Retrieved logs for deployment {deployment.id}',
+                data={'logs': logs}
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Get deployment logs error: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Get deployment status",
+        description="Get current status of this deployment from Cloudflare"
+    )
+    def status(self, request, id=None):
+        """Get current deployment status from Cloudflare."""
+        try:
+            deployment = self.get_object()
+            
+            # Import Cloudflare service
+            from ..services.cloudflare_service import CloudflareService
+            
+            cloudflare_service = CloudflareService()
+            status_info = cloudflare_service.get_deployment_status(deployment)
+            
+            return self.success_response(
+                f'Retrieved status for deployment {deployment.id}',
+                data=status_info
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Get deployment status error: {e}")
+    
+    @action(detail=False, methods=['get'])
+    @extend_schema(
+        summary="Get deployment statistics",
+        description="Get deployment statistics for user's sites"
+    )
+    def statistics(self, request):
+        """Get deployment statistics."""
+        try:
+            deployments = self.get_queryset()
+            
+            stats = {
+                'total_deployments': deployments.count(),
+                'active_deployments': deployments.filter(status=CloudflareDeployment.Status.ACTIVE).count(),
+                'failed_deployments': deployments.filter(status=CloudflareDeployment.Status.FAILED).count(),
+                'rolled_back_deployments': deployments.filter(status=CloudflareDeployment.Status.ROLLED_BACK).count(),
+                'by_type': {},
+                'recent_deployments': []
+            }
+            
+            # Count by deployment type
+            for deployment_type in CloudflareDeployment.DeploymentType.choices:
+                type_value = deployment_type[0]
+                count = deployments.filter(deployment_type=type_value).count()
+                stats['by_type'][type_value] = count
+            
+            # Get recent deployments
+            recent = deployments.order_by('-deployed_at')[:10]
+            serializer = CloudflareDeploymentListSerializer(recent, many=True)
+            stats['recent_deployments'] = serializer.data
+            
+            return self.success_response('Deployment statistics retrieved', data=stats)
+            
+        except Exception as e:
+            return self.error_response(f"Get deployment statistics error: {e}")

django_cfg/apps/maintenance/views/events.py

@@ -0,0 +1,204 @@
+"""
+Maintenance event views.
+
+ViewSets for MaintenanceEvent management.
+"""
+
+import logging
+from rest_framework import viewsets
+from rest_framework.decorators import action
+from drf_spectacular.utils import extend_schema, extend_schema_view
+
+from ..models import MaintenanceEvent
+from ..serializers import (
+    MaintenanceEventSerializer, MaintenanceEventCreateSerializer, MaintenanceEventListSerializer,
+    MaintenanceEventUpdateSerializer
+)
+from .base import MaintenancePermissionMixin, MaintenanceResponseMixin
+
+logger = logging.getLogger(__name__)
+
+
+@extend_schema_view(
+    list=extend_schema(
+        summary="List maintenance events",
+        description="Get list of maintenance events"
+    ),
+    create=extend_schema(
+        summary="Create maintenance event",
+        description="Create a new maintenance event"
+    ),
+    retrieve=extend_schema(
+        summary="Get maintenance event",
+        description="Get detailed information about a maintenance event"
+    ),
+    update=extend_schema(
+        summary="Update maintenance event",
+        description="Update maintenance event details"
+    ),
+    destroy=extend_schema(
+        summary="Delete maintenance event",
+        description="Delete a maintenance event"
+    )
+)
+class MaintenanceEventViewSet(MaintenancePermissionMixin, MaintenanceResponseMixin, viewsets.ModelViewSet):
+    """ViewSet for managing maintenance events."""
+    
+    serializer_class = MaintenanceEventSerializer
+    lookup_field = 'id'
+    filterset_fields = ['status', 'reason']
+    ordering = ['-created_at']
+    
+    def get_queryset(self):
+        """Get queryset filtered by user permissions."""
+        return self.get_user_queryset(MaintenanceEvent, 'initiated_by')
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return MaintenanceEventCreateSerializer
+        elif self.action == 'list':
+            return MaintenanceEventListSerializer
+        elif self.action in ['update', 'partial_update']:
+            return MaintenanceEventUpdateSerializer
+        return MaintenanceEventSerializer
+    
+    def perform_create(self, serializer):
+        """Set initiated_by when creating event."""
+        serializer.save(initiated_by=self.request.user)
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Complete maintenance event",
+        description="Mark maintenance event as completed"
+    )
+    def complete(self, request, id=None):
+        """Complete a maintenance event."""
+        try:
+            event = self.get_object()
+            
+            if event.status != MaintenanceEvent.Status.ACTIVE:
+                return self.error_response(
+                    f'Cannot complete event with status: {event.status}',
+                    status_code=400
+                )
+            
+            event.complete(request.user)
+            
+            return self.success_response(f'Maintenance event "{event.title}" completed')
+            
+        except Exception as e:
+            return self.error_response(f"Complete maintenance event error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Cancel maintenance event",
+        description="Cancel maintenance event"
+    )
+    def cancel(self, request, id=None):
+        """Cancel a maintenance event."""
+        try:
+            event = self.get_object()
+            
+            if event.status not in [MaintenanceEvent.Status.ACTIVE, MaintenanceEvent.Status.SCHEDULED]:
+                return self.error_response(
+                    f'Cannot cancel event with status: {event.status}',
+                    status_code=400
+                )
+            
+            event.cancel(request.user)
+            
+            return self.success_response(f'Maintenance event "{event.title}" cancelled')
+            
+        except Exception as e:
+            return self.error_response(f"Cancel maintenance event error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Fail maintenance event",
+        description="Mark maintenance event as failed"
+    )
+    def fail(self, request, id=None):
+        """Mark a maintenance event as failed."""
+        try:
+            event = self.get_object()
+            error_message = request.data.get('error_message', 'Maintenance failed')
+            
+            if event.status != MaintenanceEvent.Status.ACTIVE:
+                return self.error_response(
+                    f'Cannot fail event with status: {event.status}',
+                    status_code=400
+                )
+            
+            event.fail(error_message)
+            
+            return self.success_response(f'Maintenance event "{event.title}" marked as failed')
+            
+        except Exception as e:
+            return self.error_response(f"Fail maintenance event error: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Get event logs",
+        description="Get logs for this maintenance event"
+    )
+    def logs(self, request, id=None):
+        """Get logs for a maintenance event."""
+        try:
+            event = self.get_object()
+            logs = event.logs.order_by('-timestamp')
+            
+            # Simple pagination
+            page_size = int(request.query_params.get('page_size', 50))
+            page = int(request.query_params.get('page', 1))
+            start = (page - 1) * page_size
+            end = start + page_size
+            
+            paginated_logs = logs[start:end]
+            
+            from ..serializers import MaintenanceLogSerializer
+            serializer = MaintenanceLogSerializer(paginated_logs, many=True)
+            
+            return self.success_response(
+                f'Retrieved {len(serializer.data)} logs',
+                data={
+                    'logs': serializer.data,
+                    'total': logs.count(),
+                    'page': page,
+                    'page_size': page_size
+                }
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Get event logs error: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Get event statistics",
+        description="Get statistics for this maintenance event"
+    )
+    def statistics(self, request, id=None):
+        """Get statistics for a maintenance event."""
+        try:
+            event = self.get_object()
+            
+            stats = {
+                'event_id': event.id,
+                'title': event.title,
+                'status': event.status,
+                'duration': event.duration.total_seconds() if event.duration else None,
+                'affected_sites': event.affected_sites_count,
+                'success_count': event.success_count,
+                'error_count_before': event.error_count_before,
+                'error_count_during': event.error_count_during,
+                'is_active': event.is_active,
+                'is_scheduled': event.is_scheduled,
+                'started_at': event.started_at.isoformat() if event.started_at else None,
+                'ended_at': event.ended_at.isoformat() if event.ended_at else None,
+                'logs_count': event.logs.count()
+            }
+            
+            return self.success_response('Event statistics retrieved', data=stats)
+            
+        except Exception as e:
+            return self.error_response(f"Get event statistics error: {e}")

django_cfg/apps/maintenance/views/monitoring.py

@@ -0,0 +1,213 @@
+"""
+Monitoring views.
+
+ViewSets for MonitoringTarget management.
+"""
+
+import logging
+from rest_framework import viewsets
+from rest_framework.decorators import action
+from drf_spectacular.utils import extend_schema, extend_schema_view
+
+from ..models import MonitoringTarget
+from ..serializers import (
+    MonitoringTargetSerializer, MonitoringTargetCreateSerializer,
+    HealthCheckResultSerializer
+)
+from .base import MaintenancePermissionMixin, MaintenanceResponseMixin
+
+logger = logging.getLogger(__name__)
+
+
+@extend_schema_view(
+    list=extend_schema(
+        summary="List monitoring targets",
+        description="Get list of monitoring targets"
+    ),
+    create=extend_schema(
+        summary="Create monitoring target",
+        description="Create a new monitoring target"
+    ),
+    retrieve=extend_schema(
+        summary="Get monitoring target",
+        description="Get detailed information about a monitoring target"
+    ),
+    update=extend_schema(
+        summary="Update monitoring target",
+        description="Update monitoring target configuration"
+    ),
+    destroy=extend_schema(
+        summary="Delete monitoring target",
+        description="Delete a monitoring target"
+    )
+)
+class MonitoringTargetViewSet(MaintenancePermissionMixin, MaintenanceResponseMixin, viewsets.ModelViewSet):
+    """ViewSet for managing monitoring targets."""
+    
+    serializer_class = MonitoringTargetSerializer
+    lookup_field = 'id'
+    filterset_fields = ['is_active', 'check_type']
+    ordering = ['-created_at']
+    
+    def get_queryset(self):
+        """Get queryset filtered by user permissions."""
+        # MonitoringTarget is related to CloudflareSite via site.owner
+        if getattr(self, 'swagger_fake_view', False):
+            return MonitoringTarget.objects.none()
+        
+        user = self.request.user
+        if user.is_staff:
+            return MonitoringTarget.objects.all()
+        
+        return MonitoringTarget.objects.filter(site__owner=user)
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return MonitoringTargetCreateSerializer
+        return MonitoringTargetSerializer
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Run health check",
+        description="Run health check for this monitoring target",
+        responses={
+            200: HealthCheckResultSerializer
+        }
+    )
+    def health_check(self, request, id=None):
+        """Run health check for a monitoring target."""
+        try:
+            target = self.get_object()
+            
+            # Import monitoring service
+            from ..services.monitoring_service import MonitoringService
+            
+            monitoring_service = MonitoringService()
+            result = monitoring_service.check_target_health(target)
+            
+            # Serialize the result
+            serializer = HealthCheckResultSerializer(result)
+            
+            return self.success_response(
+                f'Health check completed for {target.site.domain}',
+                data=serializer.data
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Health check error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Enable monitoring",
+        description="Enable monitoring for this target"
+    )
+    def enable(self, request, id=None):
+        """Enable monitoring for a target."""
+        try:
+            target = self.get_object()
+            target.is_active = True
+            target.save()
+            
+            return self.success_response(f'Monitoring enabled for {target.site.domain}')
+            
+        except Exception as e:
+            return self.error_response(f"Enable monitoring error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Disable monitoring",
+        description="Disable monitoring for this target"
+    )
+    def disable(self, request, id=None):
+        """Disable monitoring for a target."""
+        try:
+            target = self.get_object()
+            target.is_active = False
+            target.save()
+            
+            return self.success_response(f'Monitoring disabled for {target.site.domain}')
+            
+        except Exception as e:
+            return self.error_response(f"Disable monitoring error: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Get monitoring statistics",
+        description="Get monitoring statistics for this target"
+    )
+    def statistics(self, request, id=None):
+        """Get monitoring statistics for a target."""
+        try:
+            target = self.get_object()
+            
+            stats = {
+                'target_id': target.id,
+                'site_domain': target.site.domain,
+                'is_active': target.is_active,
+                'check_type': target.check_type,
+                'check_interval': target.check_interval,
+                'timeout': target.timeout,
+                'retry_count': target.retry_count,
+                'last_check': target.last_check.isoformat() if target.last_check else None,
+                'last_status': target.last_status,
+                'consecutive_failures': target.consecutive_failures,
+                'total_checks': target.total_checks,
+                'total_failures': target.total_failures,
+                'uptime_percentage': target.uptime_percentage,
+                'created_at': target.created_at.isoformat(),
+                'updated_at': target.updated_at.isoformat()
+            }
+            
+            return self.success_response('Monitoring statistics retrieved', data=stats)
+            
+        except Exception as e:
+            return self.error_response(f"Get monitoring statistics error: {e}")
+    
+    @action(detail=False, methods=['post'])
+    @extend_schema(
+        summary="Run bulk health checks",
+        description="Run health checks for multiple monitoring targets"
+    )
+    def bulk_health_check(self, request):
+        """Run health checks for multiple targets."""
+        try:
+            target_ids = request.data.get('target_ids', [])
+            
+            if not target_ids:
+                return self.error_response('No target IDs provided', status_code=400)
+            
+            # Get targets (filtered by user permissions)
+            targets = self.get_queryset().filter(id__in=target_ids)
+            
+            # Import monitoring service
+            from ..services.monitoring_service import MonitoringService
+            
+            monitoring_service = MonitoringService()
+            results = []
+            
+            for target in targets:
+                try:
+                    result = monitoring_service.check_target_health(target)
+                    serializer = HealthCheckResultSerializer(result)
+                    results.append({
+                        'target_id': target.id,
+                        'domain': target.site.domain,
+                        'success': True,
+                        'result': serializer.data
+                    })
+                except Exception as e:
+                    results.append({
+                        'target_id': target.id,
+                        'domain': target.site.domain,
+                        'success': False,
+                        'error': str(e)
+                    })
+            
+            return self.success_response(
+                f'Bulk health check completed for {len(results)} targets',
+                data={'results': results}
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Bulk health check error: {e}")