django-cfg 1.2.14__py3-none-any.whl → 1.2.16__py3-none-any.whl

django_cfg/apps/maintenance/serializers/events.py

@@ -0,0 +1,210 @@
+"""
+Maintenance event serializers.
+
+Serializers for MaintenanceEvent and MaintenanceLog models.
+"""
+
+from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_serializer, OpenApiExample
+
+from ..models import MaintenanceEvent, MaintenanceLog, CloudflareSite
+from .base import UserSerializer
+from .sites import CloudflareSiteListSerializer
+
+
+class MaintenanceLogSerializer(serializers.ModelSerializer):
+    """Serializer for MaintenanceLog model."""
+    
+    user = UserSerializer(read_only=True)
+    
+    class Meta:
+        model = MaintenanceLog
+        fields = [
+            'id', 'event', 'level', 'message', 'component', 'operation',
+            'user', 'metadata', 'timestamp'
+        ]
+        read_only_fields = fields
+        extra_kwargs = {
+            'level': {
+                'help_text': 'Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)'
+            },
+            'message': {
+                'help_text': 'Log message content'
+            },
+            'component': {
+                'help_text': 'Component that generated the log (e.g., cloudflare, monitoring)'
+            },
+            'operation': {
+                'help_text': 'Operation being performed (e.g., deploy_worker, health_check)'
+            }
+        }
+
+
+@extend_schema_serializer(
+    examples=[
+        OpenApiExample(
+            'Scheduled Maintenance',
+            summary='A scheduled maintenance event',
+            description='Example of a scheduled maintenance event for multiple sites',
+            value={
+                'title': 'Database Migration',
+                'description': 'Upgrading database to PostgreSQL 14',
+                'reason': 'scheduled',
+                'estimated_duration': '02:00:00',
+                'maintenance_message': 'We are performing scheduled maintenance. Please try again in 2 hours.',
+                'sites': [1, 2, 3]
+            }
+        ),
+        OpenApiExample(
+            'Emergency Maintenance',
+            summary='An emergency maintenance event',
+            description='Example of an emergency maintenance event',
+            value={
+                'title': 'Security Patch',
+                'description': 'Applying critical security updates',
+                'reason': 'emergency',
+                'estimated_duration': '00:30:00',
+                'maintenance_message': 'Emergency maintenance in progress. Service will be restored shortly.',
+                'sites': [1]
+            }
+        )
+    ]
+)
+class MaintenanceEventSerializer(serializers.ModelSerializer):
+    """Serializer for MaintenanceEvent model with full details."""
+    
+    initiated_by = UserSerializer(read_only=True)
+    completed_by = UserSerializer(read_only=True)
+    sites = CloudflareSiteListSerializer(many=True, read_only=True)
+    logs = MaintenanceLogSerializer(many=True, read_only=True)
+    duration = serializers.ReadOnlyField()
+    is_active = serializers.ReadOnlyField()
+    is_scheduled = serializers.ReadOnlyField()
+    affected_sites_count = serializers.ReadOnlyField()
+    
+    class Meta:
+        model = MaintenanceEvent
+        fields = [
+            'id', 'title', 'description', 'reason', 'status', 'initiated_by',
+            'completed_by', 'sites', 'logs', 'started_at', 'ended_at',
+            'estimated_duration', 'maintenance_message', 'duration',
+            'is_active', 'is_scheduled', 'affected_sites_count',
+            'success_count', 'error_count_before', 'error_count_during',
+            'created_at', 'updated_at'
+        ]
+        read_only_fields = [
+            'id', 'initiated_by', 'completed_by', 'sites', 'logs', 'duration',
+            'is_active', 'is_scheduled', 'affected_sites_count', 'success_count',
+            'error_count_before', 'error_count_during', 'created_at', 'updated_at'
+        ]
+        extra_kwargs = {
+            'title': {
+                'help_text': 'Brief title describing the maintenance'
+            },
+            'description': {
+                'help_text': 'Detailed description of the maintenance work'
+            },
+            'reason': {
+                'help_text': 'Reason for maintenance (manual, scheduled, automatic, emergency)'
+            },
+            'maintenance_message': {
+                'help_text': 'Message to display to users during maintenance'
+            },
+            'estimated_duration': {
+                'help_text': 'Estimated duration in HH:MM:SS format'
+            }
+        }
+
+
+class MaintenanceEventCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating MaintenanceEvent."""
+    
+    sites = serializers.PrimaryKeyRelatedField(
+        queryset=CloudflareSite.objects.all(),
+        many=True,
+        help_text="List of site IDs to include in maintenance"
+    )
+    
+    class Meta:
+        model = MaintenanceEvent
+        fields = [
+            'title', 'description', 'reason', 'sites', 'started_at',
+            'estimated_duration', 'maintenance_message'
+        ]
+        extra_kwargs = {
+            'title': {
+                'help_text': 'Brief title describing the maintenance'
+            },
+            'description': {
+                'help_text': 'Detailed description of the maintenance work'
+            },
+            'maintenance_message': {
+                'help_text': 'Custom message to display during maintenance (optional)'
+            }
+        }
+    
+    def validate_sites(self, value):
+        """Validate that user has access to selected sites."""
+        user = self.context['request'].user
+        if not user.is_staff:
+            # Non-staff users can only select their own sites
+            user_sites = CloudflareSite.objects.filter(owner=user)
+            invalid_sites = [site for site in value if site not in user_sites]
+            if invalid_sites:
+                raise serializers.ValidationError(
+                    f"You don't have access to sites: {[s.domain for s in invalid_sites]}"
+                )
+        return value
+    
+    def validate_estimated_duration(self, value):
+        """Validate estimated duration is reasonable."""
+        if value and value.total_seconds() > 24 * 3600:  # 24 hours
+            raise serializers.ValidationError(
+                "Estimated duration cannot exceed 24 hours"
+            )
+        if value and value.total_seconds() < 60:  # 1 minute
+            raise serializers.ValidationError(
+                "Estimated duration must be at least 1 minute"
+            )
+        return value
+
+
+class MaintenanceEventListSerializer(serializers.ModelSerializer):
+    """Lightweight serializer for event lists."""
+    
+    initiated_by = serializers.StringRelatedField(read_only=True)
+    affected_sites_count = serializers.ReadOnlyField()
+    duration = serializers.ReadOnlyField()
+    is_active = serializers.ReadOnlyField()
+    
+    class Meta:
+        model = MaintenanceEvent
+        fields = [
+            'id', 'title', 'reason', 'status', 'initiated_by',
+            'affected_sites_count', 'duration', 'is_active',
+            'started_at', 'ended_at', 'created_at'
+        ]
+        read_only_fields = fields
+
+
+class MaintenanceEventUpdateSerializer(serializers.ModelSerializer):
+    """Serializer for updating MaintenanceEvent."""
+    
+    class Meta:
+        model = MaintenanceEvent
+        fields = [
+            'title', 'description', 'maintenance_message', 'estimated_duration'
+        ]
+        
+    def validate(self, data):
+        """Validate that event can be updated."""
+        instance = self.instance
+        if instance and instance.status in [
+            MaintenanceEvent.Status.COMPLETED,
+            MaintenanceEvent.Status.CANCELLED,
+            MaintenanceEvent.Status.FAILED
+        ]:
+            raise serializers.ValidationError(
+                "Cannot update completed, cancelled, or failed maintenance events"
+            )
+        return data

django_cfg/apps/maintenance/serializers/monitoring.py

@@ -0,0 +1,278 @@
+"""
+Monitoring serializers.
+
+Serializers for MonitoringTarget and HealthCheckResult models.
+"""
+
+from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_serializer, OpenApiExample
+
+from ..models import MonitoringTarget, HealthCheckResult
+from .sites import CloudflareSiteListSerializer
+
+
+class HealthCheckResultSerializer(serializers.ModelSerializer):
+    """Serializer for HealthCheckResult model."""
+    
+    class Meta:
+        model = HealthCheckResult
+        fields = [
+            'id', 'target', 'success', 'status_code', 'response_time_ms',
+            'error_message', 'response_headers', 'timestamp'
+        ]
+        read_only_fields = fields
+        extra_kwargs = {
+            'success': {
+                'help_text': 'Whether the health check was successful'
+            },
+            'status_code': {
+                'help_text': 'HTTP status code returned'
+            },
+            'response_time_ms': {
+                'help_text': 'Response time in milliseconds'
+            },
+            'error_message': {
+                'help_text': 'Error message if check failed'
+            },
+            'response_headers': {
+                'help_text': 'Response headers as JSON'
+            }
+        }
+
+
+class HealthCheckResultListSerializer(serializers.ModelSerializer):
+    """Lightweight serializer for health check result lists."""
+    
+    class Meta:
+        model = HealthCheckResult
+        fields = [
+            'id', 'success', 'status_code', 'response_time_ms', 'timestamp'
+        ]
+        read_only_fields = fields
+
+
+@extend_schema_serializer(
+    examples=[
+        OpenApiExample(
+            'Basic Monitoring Target',
+            summary='A basic monitoring configuration',
+            description='Example of a basic monitoring target for a production site',
+            value={
+                'check_url': 'https://example.com/health/',
+                'expected_status_codes': [200, 201],
+                'timeout_seconds': 10,
+                'check_interval_seconds': 60,
+                'failure_threshold': 3,
+                'recovery_threshold': 2
+            }
+        ),
+        OpenApiExample(
+            'Advanced Monitoring Target',
+            summary='An advanced monitoring configuration',
+            description='Example with custom headers and SSL verification',
+            value={
+                'check_url': 'https://api.example.com/status',
+                'expected_status_codes': [200],
+                'timeout_seconds': 15,
+                'check_interval_seconds': 30,
+                'failure_threshold': 5,
+                'recovery_threshold': 3,
+                'custom_headers': {
+                    'Authorization': 'Bearer token123',
+                    'User-Agent': 'Maintenance-Monitor/1.0'
+                },
+                'follow_redirects': True,
+                'verify_ssl': True,
+                'expected_response_time_ms': 2000
+            }
+        )
+    ]
+)
+class MonitoringTargetSerializer(serializers.ModelSerializer):
+    """Serializer for MonitoringTarget model."""
+    
+    site = CloudflareSiteListSerializer(read_only=True)
+    results = HealthCheckResultListSerializer(many=True, read_only=True)
+    recent_results = serializers.SerializerMethodField()
+    uptime_percentage = serializers.SerializerMethodField()
+    average_response_time = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = MonitoringTarget
+        fields = [
+            'id', 'site', 'status', 'check_url', 'expected_status_codes',
+            'timeout_seconds', 'check_interval_seconds', 'failure_threshold',
+            'recovery_threshold', 'custom_headers', 'follow_redirects',
+            'verify_ssl', 'expected_response_time_ms', 'results',
+            'recent_results', 'uptime_percentage', 'average_response_time',
+            'last_check_at', 'consecutive_failures', 'consecutive_successes',
+            'created_at', 'updated_at'
+        ]
+        read_only_fields = [
+            'id', 'site', 'results', 'recent_results', 'uptime_percentage',
+            'average_response_time', 'last_check_at', 'consecutive_failures',
+            'consecutive_successes', 'created_at', 'updated_at'
+        ]
+        extra_kwargs = {
+            'check_url': {
+                'help_text': 'URL to monitor for health checks'
+            },
+            'expected_status_codes': {
+                'help_text': 'List of HTTP status codes considered successful'
+            },
+            'timeout_seconds': {
+                'help_text': 'Request timeout in seconds'
+            },
+            'check_interval_seconds': {
+                'help_text': 'Interval between checks in seconds'
+            },
+            'failure_threshold': {
+                'help_text': 'Number of consecutive failures before marking as down'
+            },
+            'recovery_threshold': {
+                'help_text': 'Number of consecutive successes before marking as up'
+            },
+            'custom_headers': {
+                'help_text': 'Custom HTTP headers to send with requests'
+            },
+            'expected_response_time_ms': {
+                'help_text': 'Expected response time threshold in milliseconds'
+            }
+        }
+    
+    def get_recent_results(self, obj):
+        """Get recent health check results (last 10)."""
+        recent = obj.results.order_by('-timestamp')[:10]
+        return HealthCheckResultListSerializer(recent, many=True).data
+    
+    def get_uptime_percentage(self, obj):
+        """Calculate uptime percentage over last 24 hours."""
+        from django.utils import timezone
+        from datetime import timedelta
+        
+        # Get results from last 24 hours
+        since = timezone.now() - timedelta(hours=24)
+        recent_results = obj.results.filter(timestamp__gte=since)
+        
+        if not recent_results.exists():
+            return None
+        
+        total_checks = recent_results.count()
+        successful_checks = recent_results.filter(success=True).count()
+        
+        return round((successful_checks / total_checks) * 100, 2)
+    
+    def get_average_response_time(self, obj):
+        """Calculate average response time over last 24 hours."""
+        from django.utils import timezone
+        from datetime import timedelta
+        from django.db.models import Avg
+        
+        # Get results from last 24 hours
+        since = timezone.now() - timedelta(hours=24)
+        recent_results = obj.results.filter(
+            timestamp__gte=since,
+            success=True,
+            response_time_ms__isnull=False
+        )
+        
+        if not recent_results.exists():
+            return None
+        
+        avg_time = recent_results.aggregate(
+            avg=Avg('response_time_ms')
+        )['avg']
+        
+        return round(avg_time, 2) if avg_time else None
+
+
+class MonitoringTargetCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating MonitoringTarget."""
+    
+    class Meta:
+        model = MonitoringTarget
+        fields = [
+            'check_url', 'expected_status_codes', 'timeout_seconds',
+            'check_interval_seconds', 'failure_threshold', 'recovery_threshold',
+            'custom_headers', 'follow_redirects', 'verify_ssl',
+            'expected_response_time_ms'
+        ]
+    
+    def validate_check_url(self, value):
+        """Validate check URL format."""
+        if not value.startswith(('http://', 'https://')):
+            raise serializers.ValidationError(
+                "Check URL must start with http:// or https://"
+            )
+        return value
+    
+    def validate_expected_status_codes(self, value):
+        """Validate status codes."""
+        if not value:
+            raise serializers.ValidationError(
+                "At least one expected status code is required"
+            )
+        
+        for code in value:
+            if not (100 <= code <= 599):
+                raise serializers.ValidationError(
+                    f"Invalid HTTP status code: {code}"
+                )
+        
+        return value
+    
+    def validate_timeout_seconds(self, value):
+        """Validate timeout is reasonable."""
+        if value < 1:
+            raise serializers.ValidationError(
+                "Timeout must be at least 1 second"
+            )
+        if value > 300:
+            raise serializers.ValidationError(
+                "Timeout cannot exceed 300 seconds"
+            )
+        return value
+    
+    def validate_check_interval_seconds(self, value):
+        """Validate check interval is reasonable."""
+        if value < 10:
+            raise serializers.ValidationError(
+                "Check interval must be at least 10 seconds"
+            )
+        if value > 3600:
+            raise serializers.ValidationError(
+                "Check interval cannot exceed 3600 seconds (1 hour)"
+            )
+        return value
+
+
+class MonitoringTargetListSerializer(serializers.ModelSerializer):
+    """Lightweight serializer for monitoring target lists."""
+    
+    site = serializers.StringRelatedField(read_only=True)
+    uptime_percentage = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = MonitoringTarget
+        fields = [
+            'id', 'site', 'status', 'check_url', 'uptime_percentage',
+            'last_check_at', 'consecutive_failures', 'consecutive_successes'
+        ]
+        read_only_fields = fields
+    
+    def get_uptime_percentage(self, obj):
+        """Calculate uptime percentage over last 24 hours."""
+        from django.utils import timezone
+        from datetime import timedelta
+        
+        # Get results from last 24 hours
+        since = timezone.now() - timedelta(hours=24)
+        recent_results = obj.results.filter(timestamp__gte=since)
+        
+        if not recent_results.exists():
+            return None
+        
+        total_checks = recent_results.count()
+        successful_checks = recent_results.filter(success=True).count()
+        
+        return round((successful_checks / total_checks) * 100, 2)