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

django_cfg/apps/maintenance/views/base.py

@@ -1,61 +0,0 @@
-"""
-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

@@ -1,175 +0,0 @@
-"""
-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

@@ -1,204 +0,0 @@
-"""
-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

@@ -1,213 +0,0 @@
-"""
-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}")