django-cfg 1.4.21__py3-none-any.whl → 1.4.24__py3-none-any.whl

django_cfg/apps/maintenance/managers/cloudflare_site_manager.py

@@ -4,56 +4,56 @@ CloudflareSite custom manager.
 Simplified manager with useful query methods for sites.
 """
 
+from datetime import timedelta
+
 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
@@ -64,7 +64,7 @@ class CloudflareSiteQuerySet(models.QuerySet):
                 to_attr='recent_logs'
             )
         )
-    
+
     def search(self, query: str):
         """Search sites by name or domain."""
         return self.filter(
@@ -75,49 +75,49 @@ class CloudflareSiteQuerySet(models.QuerySet):
 
 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,
@@ -125,28 +125,29 @@ class CloudflareSiteManager(models.Manager):
             '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
-        
+
+        from ..models import CloudflareApiKey
+        from ..services import SiteSyncService
+
         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)
@@ -160,24 +161,24 @@ class CloudflareSiteManager(models.Manager):
                 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
-        
+        from ..services import SiteSyncService
+
         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)
@@ -185,7 +186,7 @@ class CloudflareSiteManager(models.Manager):
                 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

@@ -4,80 +4,81 @@ MaintenanceLog custom manager.
 Simplified manager with useful query methods for logs.
 """
 
+from datetime import timedelta
+
 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(
@@ -90,54 +91,54 @@ class MaintenanceLogQuerySet(models.QuerySet):
 
 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,
@@ -145,7 +146,7 @@ class MaintenanceLogManager(models.Manager):
             '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]

django_cfg/apps/maintenance/migrations/0001_initial.py

@@ -1,6 +1,7 @@
 # Generated by Django 5.2.6 on 2025-09-23 07:44
 
 import datetime
+
 import django.db.models.deletion
 from django.db import migrations, models
 

django_cfg/apps/maintenance/models/__init__.py

@@ -18,11 +18,11 @@ def __getattr__(name: str):
     """Lazy import mechanism to avoid Django initialization issues."""
     if name in _LAZY_IMPORTS:
         module_path, attr_name = _LAZY_IMPORTS[name]
-        
+
         import importlib
         module = importlib.import_module(module_path)
         return getattr(module, attr_name)
-    
+
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 

django_cfg/apps/maintenance/models/cloudflare_api_key.py

@@ -4,8 +4,8 @@ CloudflareApiKey model.
 Store Cloudflare API keys for different accounts/domains.
 """
 
-from django.db import models
 from django.core.exceptions import ValidationError
+from django.db import models
 
 
 class CloudflareApiKey(models.Model):
@@ -14,7 +14,7 @@ class CloudflareApiKey(models.Model):
     
     Allows managing multiple Cloudflare accounts with different API tokens.
     """
-    
+
     # Basic info
     name = models.CharField(
         max_length=100,
@@ -24,7 +24,7 @@ class CloudflareApiKey(models.Model):
         blank=True,
         help_text="Optional description of what this key is used for"
     )
-    
+
     # Cloudflare credentials
     api_token = models.CharField(
         max_length=255,
@@ -35,7 +35,7 @@ class CloudflareApiKey(models.Model):
         blank=True,
         help_text="Cloudflare Account ID (auto-discovered if empty)"
     )
-    
+
     # Settings
     is_active = models.BooleanField(
         default=True,
@@ -45,7 +45,7 @@ class CloudflareApiKey(models.Model):
         default=False,
         help_text="Whether this is the default API key to use"
     )
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -54,7 +54,7 @@ class CloudflareApiKey(models.Model):
         blank=True,
         help_text="When this API key was last used"
     )
-    
+
     class Meta:
         ordering = ['-is_default', 'name']
         verbose_name = "Cloudflare API Key"
@@ -63,32 +63,32 @@ class CloudflareApiKey(models.Model):
             models.Index(fields=['is_active']),
             models.Index(fields=['is_default']),
         ]
-    
+
     def __str__(self) -> str:
         status = "🔑" if self.is_active else "🔒"
         default = " (Default)" if self.is_default else ""
         return f"{status} {self.name}{default}"
-    
+
     def clean(self) -> None:
         """Validate model data."""
         super().clean()
-        
+
         # Validate API token format (basic check)
         if not self.api_token.strip():
             raise ValidationError({'api_token': 'API token cannot be empty'})
-        
+
         # Validate account_id format if provided
         if self.account_id and len(self.account_id) != 32:
             raise ValidationError({'account_id': 'Account ID must be 32 characters'})
-    
+
     def save(self, *args, **kwargs):
         """Override save to ensure only one default key."""
         if self.is_default:
             # Set all other keys to non-default
             self.__class__.objects.filter(is_default=True).exclude(pk=self.pk).update(is_default=False)
-        
+
         super().save(*args, **kwargs)
-    
+
     @classmethod
     def get_default(cls):
         """Get the default API key."""
@@ -96,12 +96,12 @@ class CloudflareApiKey(models.Model):
             return cls.objects.filter(is_active=True, is_default=True).first()
         except cls.DoesNotExist:
             return None
-    
+
     @classmethod
     def get_active_keys(cls):
         """Get all active API keys."""
         return cls.objects.filter(is_active=True)
-    
+
     def mark_used(self):
         """Mark this key as recently used."""
         from django.utils import timezone

django_cfg/apps/maintenance/models/cloudflare_site.py

@@ -4,20 +4,22 @@ CloudflareSite model.
 Simplified model for storing Cloudflare sites for synchronization and maintenance.
 """
 
-from django.db import models
-from django.core.validators import URLValidator
+import re
+
 from django.core.exceptions import ValidationError
+from django.db import models
 from django.utils import timezone
-import re
+
 from django_cfg.config import get_maintenance_url
 
+
 class CloudflareSite(models.Model):
     """
     Store Cloudflare sites for synchronization and maintenance.
     
     Simplified from 30+ fields to just 11 essential fields.
     """
-    
+
     # Basic info
     name = models.CharField(
         max_length=100,
@@ -28,7 +30,7 @@ class CloudflareSite(models.Model):
         unique=True,
         help_text="Domain name (e.g., vamcar.com)"
     )
-    
+
     # Subdomains configuration
     include_subdomains = models.BooleanField(
         default=True,
@@ -38,7 +40,7 @@ class CloudflareSite(models.Model):
         blank=True,
         help_text="Comma-separated list of specific subdomains to include (e.g., api,www,app)"
     )
-    
+
     # Cloudflare IDs (auto-discovered during sync)
     zone_id = models.CharField(
         max_length=32,
@@ -54,7 +56,7 @@ class CloudflareSite(models.Model):
         on_delete=models.PROTECT,
         help_text="API key to use for this site"
     )
-    
+
     # Simple status
     maintenance_active = models.BooleanField(
         default=False,
@@ -69,7 +71,7 @@ class CloudflareSite(models.Model):
         default=True,
         help_text="Whether this site is active in our system"
     )
-    
+
     # Timestamps
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -78,11 +80,11 @@ class CloudflareSite(models.Model):
         blank=True,
         help_text="When maintenance was last activated"
     )
-    
+
     # Custom manager
     from ..managers.cloudflare_site_manager import CloudflareSiteManager
     objects = CloudflareSiteManager()
-    
+
     class Meta:
         ordering = ['name']
         verbose_name = "Cloudflare Site"
@@ -92,22 +94,22 @@ class CloudflareSite(models.Model):
             models.Index(fields=['maintenance_active']),
             models.Index(fields=['is_active']),
         ]
-    
+
     def __str__(self) -> str:
         status_emoji = "🔧" if self.maintenance_active else "🟢"
         return f"{status_emoji} {self.name} ({self.domain})"
-    
+
     def enable_maintenance(self) -> None:
         """Enable maintenance mode for this site."""
         self.maintenance_active = True
         self.last_maintenance_at = timezone.now()
         self.save(update_fields=['maintenance_active', 'last_maintenance_at', 'updated_at'])
-    
+
     def disable_maintenance(self) -> None:
         """Disable maintenance mode for this site."""
         self.maintenance_active = False
         self.save(update_fields=['maintenance_active', 'updated_at'])
-    
+
     def get_maintenance_url(self) -> str:
         """Get the maintenance URL for this site."""
         if self.maintenance_url:
@@ -115,11 +117,11 @@ class CloudflareSite(models.Model):
         else:
             # Default maintenance page with site parameter
             return get_maintenance_url(self.domain)
-    
+
     def get_domain_patterns(self) -> list[str]:
         """Get list of domain patterns for Page Rules based on subdomain configuration."""
         patterns = []
-        
+
         if self.include_subdomains:
             # Include all subdomains with wildcard
             patterns.append(f"*{self.domain}/*")
@@ -128,15 +130,15 @@ class CloudflareSite(models.Model):
         else:
             # Only root domain
             patterns.append(f"{self.domain}/*")
-            
+
             # Add specific subdomains if specified
             if self.subdomain_list.strip():
                 subdomains = [sub.strip() for sub in self.subdomain_list.split(',') if sub.strip()]
                 for subdomain in subdomains:
                     patterns.append(f"{subdomain}.{self.domain}/*")
-        
+
         return patterns
-    
+
     def get_subdomain_display(self) -> str:
         """Get human-readable subdomain configuration."""
         if self.include_subdomains:
@@ -146,11 +148,11 @@ class CloudflareSite(models.Model):
             return f"Specific: {', '.join(subdomains)}.{self.domain}"
         else:
             return f"Root domain only ({self.domain})"
-    
+
     def clean(self) -> None:
         """Validate model data."""
         super().clean()
-        
+
         # Validate domain format
         domain_pattern = re.compile(
             r'^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?'
@@ -158,7 +160,7 @@ class CloudflareSite(models.Model):
         )
         if not domain_pattern.match(self.domain):
             raise ValidationError({'domain': 'Invalid domain format'})
-        
+
         # Validate zone_id format (Cloudflare zone IDs are 32 chars)
         if len(self.zone_id) != 32:
             raise ValidationError({'zone_id': 'Zone ID must be 32 characters'})