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

django_cfg/apps/maintenance/models/cloudflare.py

@@ -1,316 +0,0 @@
-"""
-Cloudflare integration models.
-
-Models for tracking Cloudflare deployments and configurations.
-Following CRITICAL_REQUIREMENTS - proper typing, no raw Dict usage.
-"""
-
-from django.db import models
-from django.utils import timezone
-from django.core.exceptions import ValidationError
-from typing import Optional, Dict, Any
-from datetime import timedelta
-import json
-
-
-class CloudflareDeployment(models.Model):
-    """
-    Cloudflare Worker deployment tracking.
-    
-    Tracks deployment of maintenance mode Workers to Cloudflare
-    with full audit trail and rollback capabilities.
-    """
-    
-    class Status(models.TextChoices):
-        """Deployment status choices."""
-        PENDING = "pending", "Pending"
-        DEPLOYING = "deploying", "Deploying"
-        DEPLOYED = "deployed", "Deployed"
-        FAILED = "failed", "Failed"
-        ROLLED_BACK = "rolled_back", "Rolled Back"
-    
-    class DeploymentType(models.TextChoices):
-        """Type of deployment."""
-        WORKER = "worker", "Cloudflare Worker"
-        PAGE_RULE = "page_rule", "Page Rule"
-        DNS_RECORD = "dns_record", "DNS Record"
-        SSL_SETTING = "ssl_setting", "SSL Setting"
-        CUSTOM_ERROR_PAGE = "custom_error_page", "Custom Error Page"
-    
-    # === Basic Information ===
-    site = models.ForeignKey(
-        'django_cfg_maintenance.CloudflareSite',
-        on_delete=models.CASCADE,
-        related_name='deployments',
-        help_text="Site this deployment belongs to"
-    )
-    deployment_type = models.CharField(
-        max_length=50,
-        choices=DeploymentType.choices,
-        default=DeploymentType.WORKER,
-        help_text="Type of Cloudflare resource being deployed"
-    )
-    
-    # === Deployment Details ===
-    resource_name = models.CharField(
-        max_length=200,
-        help_text="Name of the deployed resource (Worker name, Page Rule, etc.)"
-    )
-    resource_id = models.CharField(
-        max_length=100,
-        blank=True,
-        help_text="Cloudflare resource ID after deployment"
-    )
-    
-    # === Status Tracking ===
-    status = models.CharField(
-        max_length=20,
-        choices=Status.choices,
-        default=Status.PENDING,
-        help_text="Current deployment status"
-    )
-    
-    # === Timing ===
-    created_at = models.DateTimeField(
-        auto_now_add=True,
-        help_text="When deployment was initiated"
-    )
-    deployed_at = models.DateTimeField(
-        null=True,
-        blank=True,
-        help_text="When deployment completed successfully"
-    )
-    failed_at = models.DateTimeField(
-        null=True,
-        blank=True,
-        help_text="When deployment failed"
-    )
-    
-    # === Configuration ===
-    configuration = models.JSONField(
-        default=dict,
-        help_text="Deployment configuration (Worker script, Page Rule settings, etc.)"
-    )
-    
-    # === Results ===
-    cloudflare_response = models.JSONField(
-        default=dict,
-        blank=True,
-        help_text="Full response from Cloudflare API"
-    )
-    error_message = models.TextField(
-        blank=True,
-        help_text="Error message if deployment failed"
-    )
-    
-    # === Rollback Support ===
-    previous_deployment = models.ForeignKey(
-        'self',
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name='rollback_deployments',
-        help_text="Previous deployment for rollback"
-    )
-    rollback_data = models.JSONField(
-        default=dict,
-        blank=True,
-        help_text="Data needed for rollback (previous configuration, etc.)"
-    )
-    
-    # === Maintenance Event Link ===
-    maintenance_event = models.ForeignKey(
-        'django_cfg_maintenance.MaintenanceEvent',
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name='cloudflare_deployments',
-        help_text="Related maintenance event"
-    )
-    
-    # === Custom Manager ===
-    from ..managers.deployments import CloudflareDeploymentManager
-    objects = CloudflareDeploymentManager()
-    
-    class Meta:
-        ordering = ['-created_at']
-        verbose_name = "Cloudflare Deployment"
-        verbose_name_plural = "Cloudflare Deployments"
-        indexes = [
-            models.Index(fields=['site', '-created_at']),
-            models.Index(fields=['status', '-created_at']),
-            models.Index(fields=['deployment_type', '-created_at']),
-            models.Index(fields=['resource_id']),
-        ]
-    
-    def __str__(self) -> str:
-        return f"{self.get_deployment_type_display()}: {self.resource_name} ({self.get_status_display()})"
-    
-    @property
-    def is_active(self) -> bool:
-        """Check if deployment is currently active."""
-        return self.status == self.Status.DEPLOYED
-    
-    @property
-    def is_pending(self) -> bool:
-        """Check if deployment is pending."""
-        return self.status in [self.Status.PENDING, self.Status.DEPLOYING]
-    
-    @property
-    def deployment_duration(self) -> Optional[timedelta]:
-        """Calculate deployment duration."""
-        if self.deployed_at:
-            return self.deployed_at - self.created_at
-        elif self.failed_at:
-            return self.failed_at - self.created_at
-        elif self.status == self.Status.DEPLOYING:
-            return timezone.now() - self.created_at
-        return None
-    
-    @property
-    def can_rollback(self) -> bool:
-        """Check if deployment can be rolled back."""
-        return (
-            self.status == self.Status.DEPLOYED and
-            (self.previous_deployment is not None or self.rollback_data)
-        )
-    
-    def mark_deploying(self) -> None:
-        """Mark deployment as in progress."""
-        self.status = self.Status.DEPLOYING
-        self.save(update_fields=['status'])
-    
-    def mark_deployed(self, resource_id: str, cloudflare_response: Dict[str, Any]) -> None:
-        """Mark deployment as successful."""
-        self.status = self.Status.DEPLOYED
-        self.resource_id = resource_id
-        self.deployed_at = timezone.now()
-        self.cloudflare_response = cloudflare_response
-        self.save(update_fields=[
-            'status', 
-            'resource_id', 
-            'deployed_at', 
-            'cloudflare_response'
-        ])
-    
-    def mark_failed(self, error_message: str, cloudflare_response: Optional[Dict[str, Any]] = None) -> None:
-        """Mark deployment as failed."""
-        self.status = self.Status.FAILED
-        self.failed_at = timezone.now()
-        self.error_message = error_message
-        if cloudflare_response:
-            self.cloudflare_response = cloudflare_response
-        
-        self.save(update_fields=[
-            'status', 
-            'failed_at', 
-            'error_message', 
-            'cloudflare_response'
-        ])
-    
-    def rollback(self) -> bool:
-        """Attempt to rollback this deployment."""
-        if not self.can_rollback:
-            return False
-        
-        try:
-            # Create rollback deployment record
-            rollback_deployment = CloudflareDeployment.objects.create(
-                site=self.site,
-                deployment_type=self.deployment_type,
-                resource_name=f"rollback-{self.resource_name}",
-                configuration=self.rollback_data,
-                previous_deployment=self,
-                maintenance_event=self.maintenance_event
-            )
-            
-            # Mark this deployment as rolled back
-            self.status = self.Status.ROLLED_BACK
-            self.save(update_fields=['status'])
-            
-            return True
-            
-        except Exception:
-            return False
-    
-    def get_configuration_summary(self) -> str:
-        """Get human-readable configuration summary."""
-        if not self.configuration:
-            return "No configuration"
-        
-        if self.deployment_type == self.DeploymentType.WORKER:
-            return f"Worker script ({len(str(self.configuration.get('script', '')))} chars)"
-        elif self.deployment_type == self.DeploymentType.PAGE_RULE:
-            actions = self.configuration.get('actions', [])
-            return f"Page Rule with {len(actions)} actions"
-        elif self.deployment_type == self.DeploymentType.DNS_RECORD:
-            record_type = self.configuration.get('type', 'Unknown')
-            content = self.configuration.get('content', 'Unknown')
-            return f"{record_type} record: {content}"
-        else:
-            return f"{len(self.configuration)} configuration items"
-    
-    def get_error_summary(self) -> str:
-        """Get concise error summary."""
-        if not self.error_message:
-            return "No error"
-        
-        # Extract first line of error message
-        first_line = self.error_message.split('\n')[0]
-        return first_line[:200] if len(first_line) > 200 else first_line
-    
-    def clean(self) -> None:
-        """Validate model data."""
-        super().clean()
-        
-        # Validate resource name
-        if not self.resource_name.strip():
-            raise ValidationError({'resource_name': 'Resource name cannot be empty'})
-        
-        # Validate timing
-        if self.deployed_at and self.failed_at:
-            raise ValidationError("Deployment cannot be both successful and failed")
-        
-        if self.deployed_at and self.deployed_at < self.created_at:
-            raise ValidationError({'deployed_at': 'Deployed time cannot be before created time'})
-        
-        if self.failed_at and self.failed_at < self.created_at:
-            raise ValidationError({'failed_at': 'Failed time cannot be before created time'})
-    
-    @classmethod
-    def create_worker_deployment(cls, 
-                                site: 'CloudflareSite', 
-                                worker_name: str, 
-                                script_content: str,
-                                maintenance_event: Optional['MaintenanceEvent'] = None) -> 'CloudflareDeployment':
-        """Create Worker deployment record."""
-        return cls.objects.create(
-            site=site,
-            deployment_type=cls.DeploymentType.WORKER,
-            resource_name=worker_name,
-            configuration={
-                'script': script_content,
-                'name': worker_name
-            },
-            maintenance_event=maintenance_event
-        )
-    
-    @classmethod
-    def create_page_rule_deployment(cls,
-                                   site: 'CloudflareSite',
-                                   rule_name: str,
-                                   pattern: str,
-                                   actions: Dict[str, Any],
-                                   maintenance_event: Optional['MaintenanceEvent'] = None) -> 'CloudflareDeployment':
-        """Create Page Rule deployment record."""
-        return cls.objects.create(
-            site=site,
-            deployment_type=cls.DeploymentType.PAGE_RULE,
-            resource_name=rule_name,
-            configuration={
-                'targets': [{'target': 'url', 'constraint': {'operator': 'matches', 'value': pattern}}],
-                'actions': actions,
-                'status': 'active'
-            },
-            maintenance_event=maintenance_event
-        )

django_cfg/apps/maintenance/models/maintenance.py

@@ -1,334 +0,0 @@
-"""
-Maintenance event models.
-
-Core models for tracking maintenance events and logs.
-Following CRITICAL_REQUIREMENTS - no raw Dict usage, proper typing.
-"""
-
-from django.db import models
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-from django.core.exceptions import ValidationError
-from typing import Optional
-from datetime import timedelta
-
-User = get_user_model()
-
-
-class MaintenanceEvent(models.Model):
-    """
-    Main maintenance event tracking model.
-    
-    Tracks maintenance events with full audit trail and Cloudflare integration.
-    """
-    
-    class Status(models.TextChoices):
-        """Maintenance event status choices."""
-        SCHEDULED = "scheduled", "Scheduled"
-        ACTIVE = "active", "Active"
-        COMPLETED = "completed", "Completed"
-        FAILED = "failed", "Failed"
-        CANCELLED = "cancelled", "Cancelled"
-    
-    class Reason(models.TextChoices):
-        """Maintenance reason choices."""
-        MANUAL = "manual", "Manual Activation"
-        SERVER_DOWN = "server_down", "Server Unreachable"
-        HIGH_ERROR_RATE = "high_error_rate", "High Error Rate"
-        DATABASE_ISSUES = "database_issues", "Database Issues"
-        DEPLOYMENT = "deployment", "Deployment"
-        SECURITY_UPDATE = "security_update", "Security Update"
-        SCHEDULED = "scheduled", "Scheduled Maintenance"
-        EMERGENCY = "emergency", "Emergency Maintenance"
-    
-    # === Basic Information ===
-    title = models.CharField(
-        max_length=200,
-        help_text="Human-readable maintenance event title"
-    )
-    description = models.TextField(
-        blank=True,
-        help_text="Detailed description of maintenance work"
-    )
-    reason = models.CharField(
-        max_length=50,
-        choices=Reason.choices,
-        default=Reason.MANUAL,
-        help_text="Reason for maintenance activation"
-    )
-    status = models.CharField(
-        max_length=20,
-        choices=Status.choices,
-        default=Status.ACTIVE,
-        help_text="Current maintenance status"
-    )
-    
-    # === Timing ===
-    started_at = models.DateTimeField(
-        default=timezone.now,
-        help_text="When maintenance was started"
-    )
-    ended_at = models.DateTimeField(
-        null=True,
-        blank=True,
-        help_text="When maintenance was completed"
-    )
-    estimated_duration = models.DurationField(
-        null=True,
-        blank=True,
-        help_text="Estimated maintenance duration"
-    )
-    
-    # === User Tracking ===
-    initiated_by = models.ForeignKey(
-        User,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name='initiated_maintenance_events',
-        help_text="User who initiated maintenance"
-    )
-    completed_by = models.ForeignKey(
-        User,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name='completed_maintenance_events',
-        help_text="User who completed maintenance"
-    )
-    
-    # === Cloudflare Integration ===
-    cloudflare_worker_deployed = models.BooleanField(
-        default=False,
-        help_text="Whether Cloudflare Worker was deployed"
-    )
-    cloudflare_deployment_id = models.CharField(
-        max_length=100,
-        blank=True,
-        help_text="Cloudflare deployment identifier"
-    )
-    worker_deployment_success = models.BooleanField(
-        default=False,
-        help_text="Whether Worker deployment was successful"
-    )
-    
-    # === Metrics ===
-    affected_requests = models.PositiveIntegerField(
-        default=0,
-        help_text="Number of requests affected during maintenance"
-    )
-    error_count_before = models.PositiveIntegerField(
-        default=0,
-        help_text="Error count before maintenance"
-    )
-    error_count_during = models.PositiveIntegerField(
-        default=0,
-        help_text="Error count during maintenance"
-    )
-    
-    # === Sites (Many-to-Many relationship) ===
-    sites = models.ManyToManyField(
-        'django_cfg_maintenance.CloudflareSite',
-        blank=True,
-        related_name='maintenance_events',
-        help_text="Sites affected by this maintenance event"
-    )
-    
-    # === Metadata ===
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    
-    # === Custom Manager ===
-    from ..managers.events import MaintenanceEventManager
-    objects = MaintenanceEventManager()
-    
-    class Meta:
-        ordering = ['-started_at']
-        verbose_name = "Maintenance Event"
-        verbose_name_plural = "Maintenance Events"
-        indexes = [
-            models.Index(fields=['status', '-started_at']),
-            models.Index(fields=['reason', '-started_at']),
-            models.Index(fields=['initiated_by', '-started_at']),
-        ]
-    
-    def __str__(self) -> str:
-        return f"{self.title} ({self.get_status_display()})"
-    
-    @property
-    def duration(self) -> Optional[timedelta]:
-        """Calculate actual maintenance duration."""
-        if self.ended_at:
-            return self.ended_at - self.started_at
-        elif self.status == self.Status.ACTIVE:
-            return timezone.now() - self.started_at
-        return None
-    
-    @property
-    def is_active(self) -> bool:
-        """Check if maintenance is currently active."""
-        return self.status == self.Status.ACTIVE
-    
-    @property
-    def is_scheduled(self) -> bool:
-        """Check if maintenance is scheduled for future."""
-        return self.status == self.Status.SCHEDULED
-    
-    @property
-    def affected_sites_count(self) -> int:
-        """Count of affected sites."""
-        return self.sites.count()
-    
-    def complete(self, user: Optional[User] = None) -> None:
-        """Mark maintenance as completed."""
-        self.status = self.Status.COMPLETED
-        self.ended_at = timezone.now()
-        self.completed_by = user
-        self.save(update_fields=['status', 'ended_at', 'completed_by', 'updated_at'])
-    
-    def cancel(self, user: Optional[User] = None) -> None:
-        """Cancel maintenance event."""
-        self.status = self.Status.CANCELLED
-        self.ended_at = timezone.now()
-        self.completed_by = user
-        self.save(update_fields=['status', 'ended_at', 'completed_by', 'updated_at'])
-    
-    def fail(self, error_message: str = "") -> None:
-        """Mark maintenance as failed."""
-        self.status = self.Status.FAILED
-        self.ended_at = timezone.now()
-        self.save(update_fields=['status', 'ended_at', 'updated_at'])
-        
-        # Create failure log
-        MaintenanceLog.objects.create(
-            event=self,
-            level=MaintenanceLog.Level.ERROR,
-            message=f"Maintenance failed: {error_message}",
-            details={'error': error_message}
-        )
-    
-    def clean(self) -> None:
-        """Validate model data."""
-        super().clean()
-        
-        # Validate timing
-        if self.ended_at and self.ended_at < self.started_at:
-            raise ValidationError("End time cannot be before start time")
-        
-        # Validate estimated duration
-        if self.estimated_duration and self.estimated_duration.total_seconds() <= 0:
-            raise ValidationError("Estimated duration must be positive")
-
-
-class MaintenanceLog(models.Model):
-    """
-    Detailed logging for maintenance events.
-    
-    Provides audit trail and debugging information for maintenance operations.
-    """
-    
-    class Level(models.TextChoices):
-        """Log level choices."""
-        DEBUG = "debug", "Debug"
-        INFO = "info", "Info"
-        WARNING = "warning", "Warning"
-        ERROR = "error", "Error"
-        CRITICAL = "critical", "Critical"
-    
-    # === Relationships ===
-    event = models.ForeignKey(
-        MaintenanceEvent,
-        on_delete=models.CASCADE,
-        related_name='logs',
-        help_text="Related maintenance event"
-    )
-    
-    # === Log Data ===
-    level = models.CharField(
-        max_length=20,
-        choices=Level.choices,
-        default=Level.INFO,
-        help_text="Log level"
-    )
-    message = models.TextField(
-        help_text="Log message"
-    )
-    details = models.JSONField(
-        default=dict,
-        blank=True,
-        help_text="Additional log details (JSON)"
-    )
-    
-    # === Context ===
-    component = models.CharField(
-        max_length=100,
-        blank=True,
-        help_text="Component that generated the log (e.g., 'cloudflare', 'monitoring')"
-    )
-    operation = models.CharField(
-        max_length=100,
-        blank=True,
-        help_text="Operation being performed (e.g., 'deploy_worker', 'health_check')"
-    )
-    
-    # === User Context ===
-    user = models.ForeignKey(
-        User,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        help_text="User associated with this log entry"
-    )
-    
-    # === Metadata ===
-    timestamp = models.DateTimeField(
-        default=timezone.now,
-        help_text="When the log entry was created"
-    )
-    
-    # === Custom Manager ===
-    from ..managers.events import MaintenanceLogManager
-    objects = MaintenanceLogManager()
-    
-    class Meta:
-        ordering = ['-timestamp']
-        verbose_name = "Maintenance Log"
-        verbose_name_plural = "Maintenance Logs"
-        indexes = [
-            models.Index(fields=['event', '-timestamp']),
-            models.Index(fields=['level', '-timestamp']),
-            models.Index(fields=['component', '-timestamp']),
-        ]
-    
-    def __str__(self) -> str:
-        return f"{self.get_level_display()}: {self.message[:100]}"
-    
-    @classmethod
-    def log_info(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
-        """Create info log entry."""
-        return cls.objects.create(
-            event=event,
-            level=cls.Level.INFO,
-            message=message,
-            **kwargs
-        )
-    
-    @classmethod
-    def log_error(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
-        """Create error log entry."""
-        return cls.objects.create(
-            event=event,
-            level=cls.Level.ERROR,
-            message=message,
-            **kwargs
-        )
-    
-    @classmethod
-    def log_warning(cls, event: MaintenanceEvent, message: str, **kwargs) -> 'MaintenanceLog':
-        """Create warning log entry."""
-        return cls.objects.create(
-            event=event,
-            level=cls.Level.WARNING,
-            message=message,
-            **kwargs
-        )