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

django_cfg/apps/maintenance/managers/deployments.py

@@ -1,287 +0,0 @@
-"""
-Custom managers for deployment models.
-
-Provides enhanced querying capabilities for CloudflareDeployment model.
-"""
-
-from django.db import models
-from django.utils import timezone
-from typing import Optional, Dict, Any
-from datetime import timedelta
-
-
-class CloudflareDeploymentQuerySet(models.QuerySet):
-    """Custom queryset for CloudflareDeployment."""
-    
-    def for_user(self, user):
-        """Filter deployments for sites owned by specific user."""
-        return self.filter(site__owner=user)
-    
-    def by_status(self, status: str):
-        """Filter by deployment status."""
-        return self.filter(status=status)
-    
-    def by_type(self, deployment_type: str):
-        """Filter by deployment type."""
-        return self.filter(deployment_type=deployment_type)
-    
-    def active(self):
-        """Get active deployments."""
-        return self.filter(status='active')
-    
-    def failed(self):
-        """Get failed deployments."""
-        return self.filter(status='failed')
-    
-    def rolled_back(self):
-        """Get rolled back deployments."""
-        return self.filter(status='rolled_back')
-    
-    def pending(self):
-        """Get pending deployments."""
-        return self.filter(status='pending')
-    
-    def worker_deployments(self):
-        """Get Worker deployments."""
-        return self.filter(deployment_type='worker')
-    
-    def page_rule_deployments(self):
-        """Get Page Rule deployments."""
-        return self.filter(deployment_type='page_rule')
-    
-    def custom_page_deployments(self):
-        """Get Custom Page deployments."""
-        return self.filter(deployment_type='custom_page')
-    
-    def dns_deployments(self):
-        """Get DNS deployments."""
-        return self.filter(deployment_type='dns')
-    
-    def recent(self, days: int = 7):
-        """Get recent deployments."""
-        cutoff = timezone.now() - timedelta(days=days)
-        return self.filter(deployed_at__gte=cutoff)
-    
-    def successful(self):
-        """Get successful deployments (active status)."""
-        return self.filter(status='active')
-    
-    def by_environment(self, environment: str):
-        """Filter by site environment."""
-        return self.filter(site__environment=environment)
-    
-    def production(self):
-        """Get deployments for production sites."""
-        return self.filter(site__environment='production')
-    
-    def staging(self):
-        """Get deployments for staging sites."""
-        return self.filter(site__environment='staging')
-    
-    def for_maintenance_event(self, event):
-        """Get deployments for specific maintenance event."""
-        return self.filter(maintenance_event=event)
-    
-    def can_rollback(self):
-        """Get deployments that can be rolled back."""
-        return self.filter(
-            status='active',
-            deployment_type__in=['worker', 'page_rule']
-        )
-    
-    def with_site(self):
-        """Include related site in query."""
-        return self.select_related('site')
-    
-    def with_maintenance_event(self):
-        """Include related maintenance event."""
-        return self.select_related('maintenance_event')
-    
-    def with_full_relations(self):
-        """Include all related objects."""
-        return self.select_related('site', 'maintenance_event')
-
-
-class CloudflareDeploymentManager(models.Manager):
-    """Custom manager for CloudflareDeployment."""
-    
-    def get_queryset(self):
-        return CloudflareDeploymentQuerySet(self.model, using=self._db)
-    
-    def for_user(self, user):
-        """Get deployments for specific user."""
-        return self.get_queryset().for_user(user)
-    
-    def by_status(self, status: str):
-        """Get deployments by status."""
-        return self.get_queryset().by_status(status)
-    
-    def by_type(self, deployment_type: str):
-        """Get deployments by type."""
-        return self.get_queryset().by_type(deployment_type)
-    
-    def active(self):
-        """Get active deployments."""
-        return self.get_queryset().active()
-    
-    def failed(self):
-        """Get failed deployments."""
-        return self.get_queryset().failed()
-    
-    def rolled_back(self):
-        """Get rolled back deployments."""
-        return self.get_queryset().rolled_back()
-    
-    def pending(self):
-        """Get pending deployments."""
-        return self.get_queryset().pending()
-    
-    def worker_deployments(self):
-        """Get Worker deployments."""
-        return self.get_queryset().worker_deployments()
-    
-    def page_rule_deployments(self):
-        """Get Page Rule deployments."""
-        return self.get_queryset().page_rule_deployments()
-    
-    def custom_page_deployments(self):
-        """Get Custom Page deployments."""
-        return self.get_queryset().custom_page_deployments()
-    
-    def dns_deployments(self):
-        """Get DNS deployments."""
-        return self.get_queryset().dns_deployments()
-    
-    def recent(self, days: int = 7):
-        """Get recent deployments."""
-        return self.get_queryset().recent(days)
-    
-    def successful(self):
-        """Get successful deployments."""
-        return self.get_queryset().successful()
-    
-    def by_environment(self, environment: str):
-        """Get deployments by environment."""
-        return self.get_queryset().by_environment(environment)
-    
-    def production(self):
-        """Get production deployments."""
-        return self.get_queryset().production()
-    
-    def staging(self):
-        """Get staging deployments."""
-        return self.get_queryset().staging()
-    
-    def for_maintenance_event(self, event):
-        """Get deployments for maintenance event."""
-        return self.get_queryset().for_maintenance_event(event)
-    
-    def can_rollback(self):
-        """Get deployments that can be rolled back."""
-        return self.get_queryset().can_rollback()
-    
-    def with_site(self):
-        """Get deployments with site."""
-        return self.get_queryset().with_site()
-    
-    def with_maintenance_event(self):
-        """Get deployments with maintenance event."""
-        return self.get_queryset().with_maintenance_event()
-    
-    def with_full_relations(self):
-        """Get deployments with all relations."""
-        return self.get_queryset().with_full_relations()
-    
-    def create_deployment(
-        self,
-        site,
-        deployment_type: str,
-        cloudflare_id: str,
-        config: Optional[Dict] = None,
-        maintenance_event=None,
-        **kwargs
-    ):
-        """Create a new Cloudflare deployment."""
-        return self.create(
-            site=site,
-            deployment_type=deployment_type,
-            cloudflare_id=cloudflare_id,
-            config=config or {},
-            maintenance_event=maintenance_event,
-            deployed_at=timezone.now(),
-            **kwargs
-        )
-    
-    def get_stats_for_user(self, user) -> Dict[str, Any]:
-        """Get deployment statistics for user."""
-        deployments = self.for_user(user)
-        
-        return {
-            'total': deployments.count(),
-            'active': deployments.active().count(),
-            'failed': deployments.failed().count(),
-            'rolled_back': deployments.rolled_back().count(),
-            'pending': deployments.pending().count(),
-            'worker_deployments': deployments.worker_deployments().count(),
-            'page_rule_deployments': deployments.page_rule_deployments().count(),
-            'custom_page_deployments': deployments.custom_page_deployments().count(),
-            'dns_deployments': deployments.dns_deployments().count(),
-            'production': deployments.production().count(),
-            'staging': deployments.staging().count(),
-            'recent': deployments.recent().count(),
-            'can_rollback': deployments.can_rollback().count(),
-            'success_rate': self._get_success_rate(deployments),
-        }
-    
-    def get_deployment_summary(self, user) -> Dict[str, Any]:
-        """Get deployment summary for user."""
-        deployments = self.for_user(user)
-        total = deployments.count()
-        
-        if total == 0:
-            return {
-                'total_deployments': 0,
-                'success_rate': 0,
-                'active_count': 0,
-                'failed_count': 0,
-                'recent_activity': [],
-            }
-        
-        active = deployments.active().count()
-        failed = deployments.failed().count()
-        success_rate = self._get_success_rate(deployments)
-        
-        # Get recent activity
-        recent_activity = []
-        recent_deployments = deployments.recent(7).with_site().order_by('-deployed_at')[:10]
-        
-        for deployment in recent_deployments:
-            recent_activity.append({
-                'id': deployment.id,
-                'site': deployment.site.domain,
-                'type': deployment.deployment_type,
-                'status': deployment.status,
-                'deployed_at': deployment.deployed_at,
-                'can_rollback': deployment.can_rollback,
-            })
-        
-        return {
-            'total_deployments': total,
-            'success_rate': success_rate,
-            'active_count': active,
-            'failed_count': failed,
-            'recent_activity': recent_activity,
-        }
-    
-    def get_rollback_candidates(self, user) -> 'CloudflareDeploymentQuerySet':
-        """Get deployments that can be rolled back for user."""
-        return self.for_user(user).can_rollback().with_site().order_by('-deployed_at')
-    
-    def _get_success_rate(self, queryset) -> float:
-        """Calculate success rate percentage."""
-        total = queryset.count()
-        if total == 0:
-            return 0.0
-        
-        successful = queryset.successful().count()
-        return (successful / total) * 100

django_cfg/apps/maintenance/managers/events.py

@@ -1,374 +0,0 @@
-"""
-Custom managers for maintenance event models.
-
-Provides enhanced querying capabilities for MaintenanceEvent and MaintenanceLog models.
-"""
-
-from django.db import models
-from django.utils import timezone
-from typing import Optional, Dict, Any, List
-from datetime import timedelta
-
-
-class MaintenanceEventQuerySet(models.QuerySet):
-    """Custom queryset for MaintenanceEvent."""
-    
-    def for_user(self, user):
-        """Filter events initiated by specific user."""
-        return self.filter(initiated_by=user)
-    
-    def by_status(self, status: str):
-        """Filter by event status."""
-        return self.filter(status=status)
-    
-    def by_reason(self, reason: str):
-        """Filter by maintenance reason."""
-        return self.filter(reason__icontains=reason)
-    
-    def active(self):
-        """Get currently active maintenance events."""
-        return self.filter(status='active')
-    
-    def completed(self):
-        """Get completed maintenance events."""
-        return self.filter(status='completed')
-    
-    def failed(self):
-        """Get failed maintenance events."""
-        return self.filter(status='failed')
-    
-    def cancelled(self):
-        """Get cancelled maintenance events."""
-        return self.filter(status='cancelled')
-    
-    def scheduled(self):
-        """Get scheduled maintenance events."""
-        return self.filter(status='scheduled')
-    
-    def recent(self, days: int = 7):
-        """Get recent maintenance events."""
-        cutoff = timezone.now() - timedelta(days=days)
-        return self.filter(created_at__gte=cutoff)
-    
-    def long_running(self, hours: int = 2):
-        """Get long-running maintenance events."""
-        cutoff = timezone.now() - timedelta(hours=hours)
-        return self.filter(
-            status='active',
-            started_at__lte=cutoff
-        )
-    
-    def with_sites(self):
-        """Include related sites in query."""
-        return self.prefetch_related('sites')
-    
-    def with_logs(self):
-        """Include related logs in query."""
-        return self.prefetch_related('logs')
-    
-    def with_deployments(self):
-        """Include related Cloudflare deployments."""
-        return self.prefetch_related('cloudflare_deployments')
-    
-    def with_full_relations(self):
-        """Include all related objects."""
-        return self.select_related('initiated_by').prefetch_related(
-            'sites', 'logs', 'cloudflare_deployments'
-        )
-    
-    def affecting_production(self):
-        """Get events affecting production sites."""
-        return self.filter(sites__environment='production').distinct()
-    
-    def affecting_staging(self):
-        """Get events affecting staging sites."""
-        return self.filter(sites__environment='staging').distinct()
-    
-    def by_duration_range(self, min_minutes: Optional[int] = None, max_minutes: Optional[int] = None):
-        """Filter by event duration."""
-        queryset = self.filter(ended_at__isnull=False)
-        
-        if min_minutes is not None:
-            min_duration = timedelta(minutes=min_minutes)
-            queryset = queryset.extra(
-                where=["ended_at - started_at >= %s"],
-                params=[min_duration]
-            )
-        
-        if max_minutes is not None:
-            max_duration = timedelta(minutes=max_minutes)
-            queryset = queryset.extra(
-                where=["ended_at - started_at <= %s"],
-                params=[max_duration]
-            )
-        
-        return queryset
-
-
-class MaintenanceEventManager(models.Manager):
-    """Custom manager for MaintenanceEvent."""
-    
-    def get_queryset(self):
-        return MaintenanceEventQuerySet(self.model, using=self._db)
-    
-    def for_user(self, user):
-        """Get events for specific user."""
-        return self.get_queryset().for_user(user)
-    
-    def by_status(self, status: str):
-        """Get events by status."""
-        return self.get_queryset().by_status(status)
-    
-    def by_reason(self, reason: str):
-        """Get events by reason."""
-        return self.get_queryset().by_reason(reason)
-    
-    def active(self):
-        """Get active events."""
-        return self.get_queryset().active()
-    
-    def completed(self):
-        """Get completed events."""
-        return self.get_queryset().completed()
-    
-    def failed(self):
-        """Get failed events."""
-        return self.get_queryset().failed()
-    
-    def cancelled(self):
-        """Get cancelled events."""
-        return self.get_queryset().cancelled()
-    
-    def scheduled(self):
-        """Get scheduled events."""
-        return self.get_queryset().scheduled()
-    
-    def recent(self, days: int = 7):
-        """Get recent events."""
-        return self.get_queryset().recent(days)
-    
-    def long_running(self, hours: int = 2):
-        """Get long-running events."""
-        return self.get_queryset().long_running(hours)
-    
-    def with_sites(self):
-        """Get events with sites."""
-        return self.get_queryset().with_sites()
-    
-    def with_logs(self):
-        """Get events with logs."""
-        return self.get_queryset().with_logs()
-    
-    def with_deployments(self):
-        """Get events with deployments."""
-        return self.get_queryset().with_deployments()
-    
-    def with_full_relations(self):
-        """Get events with all relations."""
-        return self.get_queryset().with_full_relations()
-    
-    def affecting_production(self):
-        """Get events affecting production."""
-        return self.get_queryset().affecting_production()
-    
-    def affecting_staging(self):
-        """Get events affecting staging."""
-        return self.get_queryset().affecting_staging()
-    
-    def by_duration_range(self, min_minutes: Optional[int] = None, max_minutes: Optional[int] = None):
-        """Get events by duration range."""
-        return self.get_queryset().by_duration_range(min_minutes, max_minutes)
-    
-    def create_event(
-        self,
-        title: str,
-        initiated_by,
-        reason: str,
-        site_ids: Optional[List[int]] = None,
-        estimated_duration: Optional[timedelta] = None,
-        maintenance_message: Optional[str] = None,
-        **kwargs
-    ):
-        """Create a new maintenance event."""
-        event = self.create(
-            title=title,
-            initiated_by=initiated_by,
-            reason=reason,
-            estimated_duration=estimated_duration,
-            maintenance_message=maintenance_message or f"Maintenance in progress: {reason}",
-            **kwargs
-        )
-        
-        if site_ids:
-            # Add sites to the event
-            from ..models import CloudflareSite
-            sites = CloudflareSite.objects.filter(id__in=site_ids)
-            event.sites.add(*sites)
-        
-        return event
-    
-    def get_stats_for_user(self, user) -> Dict[str, Any]:
-        """Get maintenance event statistics for user."""
-        events = self.for_user(user)
-        
-        return {
-            'total': events.count(),
-            'active': events.active().count(),
-            'completed': events.completed().count(),
-            'failed': events.failed().count(),
-            'cancelled': events.cancelled().count(),
-            'scheduled': events.scheduled().count(),
-            'recent': events.recent().count(),
-            'long_running': events.long_running().count(),
-            'affecting_production': events.affecting_production().count(),
-            'avg_duration_minutes': self._get_avg_duration_minutes(events),
-            'success_rate': self._get_success_rate(events),
-        }
-    
-    def get_maintenance_calendar(self, user, days: int = 30) -> List[Dict[str, Any]]:
-        """Get maintenance calendar for user."""
-        cutoff = timezone.now() - timedelta(days=days)
-        events = self.for_user(user).filter(
-            created_at__gte=cutoff
-        ).with_sites().order_by('created_at')
-        
-        calendar = []
-        for event in events:
-            calendar.append({
-                'id': event.id,
-                'title': event.title,
-                'status': event.status,
-                'reason': event.reason,
-                'created_at': event.created_at,
-                'started_at': event.started_at,
-                'ended_at': event.ended_at,
-                'duration': event.duration,
-                'sites_count': event.sites.count(),
-                'sites': [site.domain for site in event.sites.all()[:5]],  # Limit to 5
-            })
-        
-        return calendar
-    
-    def _get_avg_duration_minutes(self, queryset) -> Optional[float]:
-        """Calculate average duration in minutes."""
-        completed = queryset.completed().filter(
-            started_at__isnull=False,
-            ended_at__isnull=False
-        )
-        
-        if not completed.exists():
-            return None
-        
-        total_seconds = 0
-        count = 0
-        
-        for event in completed:
-            if event.duration:
-                total_seconds += event.duration.total_seconds()
-                count += 1
-        
-        return (total_seconds / count / 60) if count > 0 else None
-    
-    def _get_success_rate(self, queryset) -> float:
-        """Calculate success rate percentage."""
-        total = queryset.filter(status__in=['completed', 'failed']).count()
-        if total == 0:
-            return 0.0
-        
-        successful = queryset.completed().count()
-        return (successful / total) * 100
-
-
-class MaintenanceLogQuerySet(models.QuerySet):
-    """Custom queryset for MaintenanceLog."""
-    
-    def for_event(self, event):
-        """Filter logs for specific maintenance event."""
-        return self.filter(maintenance_event=event)
-    
-    def by_level(self, level: str):
-        """Filter by log level."""
-        return self.filter(level=level)
-    
-    def info(self):
-        """Get info level logs."""
-        return self.filter(level='info')
-    
-    def warning(self):
-        """Get warning level logs."""
-        return self.filter(level='warning')
-    
-    def error(self):
-        """Get error level logs."""
-        return self.filter(level='error')
-    
-    def recent(self, minutes: int = 60):
-        """Get recent logs."""
-        cutoff = timezone.now() - timedelta(minutes=minutes)
-        return self.filter(timestamp__gte=cutoff)
-    
-    def with_event(self):
-        """Include related maintenance event."""
-        return self.select_related('maintenance_event')
-
-
-class MaintenanceLogManager(models.Manager):
-    """Custom manager for MaintenanceLog."""
-    
-    def get_queryset(self):
-        return MaintenanceLogQuerySet(self.model, using=self._db)
-    
-    def for_event(self, event):
-        """Get logs for specific event."""
-        return self.get_queryset().for_event(event)
-    
-    def by_level(self, level: str):
-        """Get logs by level."""
-        return self.get_queryset().by_level(level)
-    
-    def info(self):
-        """Get info logs."""
-        return self.get_queryset().info()
-    
-    def warning(self):
-        """Get warning logs."""
-        return self.get_queryset().warning()
-    
-    def error(self):
-        """Get error logs."""
-        return self.get_queryset().error()
-    
-    def recent(self, minutes: int = 60):
-        """Get recent logs."""
-        return self.get_queryset().recent(minutes)
-    
-    def with_event(self):
-        """Get logs with event."""
-        return self.get_queryset().with_event()
-    
-    def log_info(self, event, message: str, **kwargs):
-        """Create info log entry."""
-        return self.create(
-            maintenance_event=event,
-            level='info',
-            message=message,
-            **kwargs
-        )
-    
-    def log_warning(self, event, message: str, **kwargs):
-        """Create warning log entry."""
-        return self.create(
-            maintenance_event=event,
-            level='warning',
-            message=message,
-            **kwargs
-        )
-    
-    def log_error(self, event, message: str, **kwargs):
-        """Create error log entry."""
-        return self.create(
-            maintenance_event=event,
-            level='error',
-            message=message,
-            **kwargs
-        )