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

django_cfg/apps/maintenance/managers/cloudflare_site_manager.py

@@ -0,0 +1,192 @@
+"""
+CloudflareSite custom manager.
+
+Simplified manager with useful query methods for sites.
+"""
+
+from django.db import models
+from django.utils import timezone
+from typing import List
+from datetime import timedelta
+
+
+class CloudflareSiteQuerySet(models.QuerySet):
+    """Custom queryset for CloudflareSite with useful filters."""
+    
+    def active(self):
+        """Get active sites."""
+        return self.filter(is_active=True)
+    
+    def inactive(self):
+        """Get inactive sites."""
+        return self.filter(is_active=False)
+    
+    def in_maintenance(self):
+        """Get sites currently in maintenance mode."""
+        return self.filter(maintenance_active=True)
+    
+    def not_in_maintenance(self):
+        """Get sites not in maintenance mode."""
+        return self.filter(maintenance_active=False)
+    
+    def by_domain(self, domain: str):
+        """Filter by domain (exact or contains)."""
+        if '.' in domain:
+            return self.filter(domain__iexact=domain)
+        else:
+            return self.filter(domain__icontains=domain)
+    
+    def by_name(self, name: str):
+        """Filter by site name."""
+        return self.filter(name__icontains=name)
+    
+    def recent(self, days: int = 7):
+        """Get recently created sites."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(created_at__gte=cutoff)
+    
+    def recently_maintained(self, days: int = 7):
+        """Get sites that had maintenance recently."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(last_maintenance_at__gte=cutoff)
+    
+    def with_logs(self):
+        """Include related logs in query."""
+        return self.prefetch_related('logs')
+    
+    def with_recent_logs(self, limit: int = 5):
+        """Include recent logs in query."""
+        from django.db.models import Prefetch
+        return self.prefetch_related(
+            Prefetch(
+                'logs',
+                queryset=self.model.logs.rel.related_model.objects.order_by('-created_at')[:limit],
+                to_attr='recent_logs'
+            )
+        )
+    
+    def search(self, query: str):
+        """Search sites by name or domain."""
+        return self.filter(
+            models.Q(name__icontains=query) |
+            models.Q(domain__icontains=query)
+        )
+
+
+class CloudflareSiteManager(models.Manager):
+    """Custom manager for CloudflareSite."""
+    
+    def get_queryset(self):
+        """Return custom queryset."""
+        return CloudflareSiteQuerySet(self.model, using=self._db)
+    
+    def active(self):
+        """Get active sites."""
+        return self.get_queryset().active()
+    
+    def inactive(self):
+        """Get inactive sites."""
+        return self.get_queryset().inactive()
+    
+    def in_maintenance(self):
+        """Get sites in maintenance mode."""
+        return self.get_queryset().in_maintenance()
+    
+    def not_in_maintenance(self):
+        """Get sites not in maintenance mode."""
+        return self.get_queryset().not_in_maintenance()
+    
+    def by_domain(self, domain: str):
+        """Find site by domain."""
+        return self.get_queryset().by_domain(domain)
+    
+    def search(self, query: str):
+        """Search sites."""
+        return self.get_queryset().search(query)
+    
+    def recent(self, days: int = 7):
+        """Get recent sites."""
+        return self.get_queryset().recent(days)
+    
+    def recently_maintained(self, days: int = 7):
+        """Get recently maintained sites."""
+        return self.get_queryset().recently_maintained(days)
+    
+    def get_stats(self):
+        """Get site statistics."""
+        total = self.count()
+        active = self.active().count()
+        in_maintenance = self.in_maintenance().count()
+        
+        return {
+            'total': total,
+            'active': active,
+            'inactive': total - active,
+            'in_maintenance': in_maintenance,
+            'normal': active - in_maintenance,
+        }
+    
+    def bulk_sync_all(self):
+        """Bulk sync all sites with Cloudflare."""
+        from ..services import SiteSyncService
+        from ..models import CloudflareApiKey
+        import logging
+        
+        logger = logging.getLogger(__name__)
+        synced = 0
+        errors = 0
+        error_details = []
+        
+        # Get all active API keys
+        api_keys = CloudflareApiKey.objects.filter(is_active=True)
+        
+        if not api_keys.exists():
+            return {
+                'synced': 0,
+                'errors': 1,
+                'error_details': ['No active API keys found']
+            }
+        
+        for api_key in api_keys:
+            try:
+                sync_service = SiteSyncService(api_key)
+                result = sync_service.sync_zones()
+                # Count created + updated as synced
+                sync_count = result.get('created', 0) + result.get('updated', 0)
+                synced += sync_count
+                logger.info(f"Synced {sync_count} sites for API key: {api_key.name}")
+            except Exception as e:
+                errors += 1
+                error_msg = f"API key '{api_key.name}': {str(e)}"
+                error_details.append(error_msg)
+                logger.error(f"Sync failed for API key {api_key.name}: {e}")
+        
+        return {
+            'synced': synced,
+            'errors': errors,
+            'error_details': error_details
+        }
+    
+    def discover_all_sites(self):
+        """Discover new sites from all API keys."""
+        from ..services import SiteSyncService
+        from ..models import CloudflareApiKey
+        
+        discovered = 0
+        errors = 0
+        
+        # Get all active API keys
+        api_keys = CloudflareApiKey.objects.filter(is_active=True)
+        
+        for api_key in api_keys:
+            try:
+                sync_service = SiteSyncService(api_key)
+                result = sync_service.sync_zones(dry_run=False)
+                discovered += result.get('created', 0)  # Count only newly created sites
+            except Exception:
+                errors += 1
+        
+        return {
+            'discovered': discovered,
+            'errors': errors
+        }

django_cfg/apps/maintenance/managers/maintenance_log_manager.py

@@ -0,0 +1,151 @@
+"""
+MaintenanceLog custom manager.
+
+Simplified manager with useful query methods for logs.
+"""
+
+from django.db import models
+from django.utils import timezone
+from datetime import timedelta
+
+
+class MaintenanceLogQuerySet(models.QuerySet):
+    """Custom queryset for MaintenanceLog with useful filters."""
+    
+    def successful(self):
+        """Get successful operations."""
+        return self.filter(status='success')
+    
+    def failed(self):
+        """Get failed operations."""
+        return self.filter(status='failed')
+    
+    def pending(self):
+        """Get pending operations."""
+        return self.filter(status='pending')
+    
+    def by_action(self, action: str):
+        """Filter by action type."""
+        return self.filter(action=action)
+    
+    def enable_actions(self):
+        """Get enable maintenance actions."""
+        return self.filter(action='enable')
+    
+    def disable_actions(self):
+        """Get disable maintenance actions."""
+        return self.filter(action='disable')
+    
+    def sync_actions(self):
+        """Get sync actions."""
+        return self.filter(action='sync')
+    
+    def error_actions(self):
+        """Get error actions."""
+        return self.filter(action='error')
+    
+    def for_site(self, site):
+        """Get logs for specific site."""
+        return self.filter(site=site)
+    
+    def for_domain(self, domain: str):
+        """Get logs for specific domain."""
+        return self.filter(site__domain=domain)
+    
+    def recent(self, days: int = 7):
+        """Get recent logs."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(created_at__gte=cutoff)
+    
+    def today(self):
+        """Get today's logs."""
+        today = timezone.now().date()
+        return self.filter(created_at__date=today)
+    
+    def with_errors(self):
+        """Get logs that have error messages."""
+        return self.filter(error_message__isnull=False).exclude(error_message='')
+    
+    def with_cloudflare_response(self):
+        """Get logs that have Cloudflare response data."""
+        return self.filter(cloudflare_response__isnull=False)
+    
+    def fast_operations(self, max_seconds: int = 5):
+        """Get operations that completed quickly."""
+        return self.filter(duration_seconds__lte=max_seconds)
+    
+    def slow_operations(self, min_seconds: int = 30):
+        """Get operations that took a long time."""
+        return self.filter(duration_seconds__gte=min_seconds)
+    
+    def search(self, query: str):
+        """Search logs by reason or error message."""
+        return self.filter(
+            models.Q(reason__icontains=query) |
+            models.Q(error_message__icontains=query) |
+            models.Q(site__name__icontains=query) |
+            models.Q(site__domain__icontains=query)
+        )
+
+
+class MaintenanceLogManager(models.Manager):
+    """Custom manager for MaintenanceLog."""
+    
+    def get_queryset(self):
+        """Return custom queryset."""
+        return MaintenanceLogQuerySet(self.model, using=self._db)
+    
+    def successful(self):
+        """Get successful operations."""
+        return self.get_queryset().successful()
+    
+    def failed(self):
+        """Get failed operations."""
+        return self.get_queryset().failed()
+    
+    def pending(self):
+        """Get pending operations."""
+        return self.get_queryset().pending()
+    
+    def recent(self, days: int = 7):
+        """Get recent logs."""
+        return self.get_queryset().recent(days)
+    
+    def today(self):
+        """Get today's logs."""
+        return self.get_queryset().today()
+    
+    def for_site(self, site):
+        """Get logs for site."""
+        return self.get_queryset().for_site(site)
+    
+    def for_domain(self, domain: str):
+        """Get logs for domain."""
+        return self.get_queryset().for_domain(domain)
+    
+    def with_errors(self):
+        """Get logs with errors."""
+        return self.get_queryset().with_errors()
+    
+    def search(self, query: str):
+        """Search logs."""
+        return self.get_queryset().search(query)
+    
+    def get_stats(self):
+        """Get log statistics."""
+        total = self.count()
+        successful = self.successful().count()
+        failed = self.failed().count()
+        pending = self.pending().count()
+        
+        return {
+            'total': total,
+            'successful': successful,
+            'failed': failed,
+            'pending': pending,
+            'success_rate': (successful / total * 100) if total > 0 else 0,
+        }
+    
+    def get_recent_activity(self, days: int = 7, limit: int = 10):
+        """Get recent activity summary."""
+        return self.recent(days).order_by('-created_at')[:limit]