django-cfg 1.2.20__tar.gz → 1.2.22__tar.gz

{django_cfg-1.2.20 → django_cfg-1.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.2.20
+Version: 1.2.22
 Summary: 🚀 Next-gen Django configuration: type-safety, AI features, blazing-fast setup, and automated best practices — all in one.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://docs.djangocfg.com

{django_cfg-1.2.20 → django_cfg-1.2.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.2.20"
+version = "1.2.22"
 description = "🚀 Next-gen Django configuration: type-safety, AI features, blazing-fast setup, and automated best practices — all in one."
 readme = "README.md"
 license = {text = "MIT"}

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.2.20"
+__version__ = "1.2.22"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/apps/maintenance/admin/site_admin.py

@@ -73,6 +73,7 @@ class CloudflareSiteAdmin(ModelAdmin):
         'status_display',
         'name', 
         'domain',
+        'subdomain_config_badge',
         'maintenance_badge',
         'active_badge',
         'last_maintenance_at',
@@ -102,6 +103,10 @@ class CloudflareSiteAdmin(ModelAdmin):
         ('Basic Information', {
             'fields': ['name', 'domain']
         }),
+        ('Subdomain Configuration', {
+            'fields': ['include_subdomains', 'subdomain_list'],
+            'description': 'Configure which subdomains should be affected by maintenance mode'
+        }),
         ('Cloudflare Configuration', {
             'fields': ['zone_id', 'account_id', 'api_key'],
             'classes': ['collapse']
@@ -141,6 +146,32 @@ class CloudflareSiteAdmin(ModelAdmin):
     # Display methods
     
     @display(description="Status")
+    @display(description="Subdomains", ordering='include_subdomains')
+    def subdomain_config_badge(self, obj: CloudflareSite) -> str:
+        """Display subdomain configuration with badge."""
+        config = obj.get_subdomain_display()
+        
+        if obj.include_subdomains:
+            # All subdomains
+            badge_class = "badge-success"
+            icon = "🌐"
+        elif obj.subdomain_list.strip():
+            # Specific subdomains
+            badge_class = "badge-warning"  
+            icon = "📋"
+        else:
+            # Root only
+            badge_class = "badge-secondary"
+            icon = "🏠"
+        
+        return format_html(
+            '<span class="badge {}" title="{}">{} {}</span>',
+            badge_class,
+            config,
+            icon,
+            "All" if obj.include_subdomains else ("List" if obj.subdomain_list.strip() else "Root")
+        )
+    
     def status_display(self, obj: CloudflareSite) -> str:
         """Display status with emoji."""
         if obj.maintenance_active:
@@ -299,6 +330,7 @@ class CloudflareSiteAdmin(ModelAdmin):
     
     @action(
         description="🔄 Sync with Cloudflare",
+        url_path="sync-cloudflare",
         icon="refresh",
         variant=ActionVariant.INFO
     )
@@ -310,15 +342,20 @@ class CloudflareSiteAdmin(ModelAdmin):
                 messages.error(request, "Site not found.")
                 return redirect(request.META.get('HTTP_REFERER', '/admin/'))
             
-            # Use SiteSyncService for site synchronization
-            from ..services import SiteSyncService
-            sync_service = SiteSyncService(site.api_key)
-            sync_service.sync_zones()
+            # Use convenience function for single site sync
+            from ..services import sync_site_from_cloudflare
+            log_entry = sync_site_from_cloudflare(site)
             
-            messages.success(
-                request, 
-                f"Site '{site.name}' has been synchronized with Cloudflare."
-            )
+            if log_entry.status == log_entry.Status.SUCCESS:
+                messages.success(
+                    request, 
+                    f"Site '{site.name}' has been synchronized with Cloudflare."
+                )
+            else:
+                messages.error(
+                    request,
+                    f"Failed to sync site '{site.name}': {log_entry.error_message}"
+                )
             
         except Exception as e:
             messages.error(request, f"Failed to sync site: {str(e)}")
@@ -327,6 +364,7 @@ class CloudflareSiteAdmin(ModelAdmin):
     
     @action(
         description="🔧 Enable Maintenance",
+        url_path="enable-maintenance",
         icon="build",
         variant=ActionVariant.WARNING
     )
@@ -350,6 +388,7 @@ class CloudflareSiteAdmin(ModelAdmin):
     
     @action(
         description="✅ Disable Maintenance",
+        url_path="disable-maintenance",
         icon="check_circle",
         variant=ActionVariant.SUCCESS
     )

django_cfg-1.2.22/src/django_cfg/apps/maintenance/migrations/0003_cloudflaresite_include_subdomains_and_more.py

@@ -0,0 +1,27 @@
+# Generated by Django 5.2.6 on 2025-09-23 09:43
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("maintenance", "0002_cloudflaresite_maintenance_url"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="cloudflaresite",
+            name="include_subdomains",
+            field=models.BooleanField(
+                default=True, help_text="Apply maintenance rules to all subdomains (*.domain.com)"
+            ),
+        ),
+        migrations.AddField(
+            model_name="cloudflaresite",
+            name="subdomain_list",
+            field=models.TextField(
+                blank=True,
+                help_text="Comma-separated list of specific subdomains to include (e.g., api,www,app)",
+            ),
+        ),
+    ]

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/apps/maintenance/models/cloudflare_site.py

@@ -29,6 +29,16 @@ class CloudflareSite(models.Model):
         help_text="Domain name (e.g., vamcar.com)"
     )
     
+    # Subdomains configuration
+    include_subdomains = models.BooleanField(
+        default=True,
+        help_text="Apply maintenance rules to all subdomains (*.domain.com)"
+    )
+    subdomain_list = models.TextField(
+        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,
@@ -106,6 +116,37 @@ class CloudflareSite(models.Model):
             # 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}/*")
+            # Also include root domain explicitly
+            patterns.append(f"{self.domain}/*")
+        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:
+            return f"All subdomains (*.{self.domain})"
+        elif self.subdomain_list.strip():
+            subdomains = [sub.strip() for sub in self.subdomain_list.split(',') if sub.strip()]
+            return f"Specific: {', '.join(subdomains)}.{self.domain}"
+        else:
+            return f"Root domain only ({self.domain})"
+    
     def clean(self) -> None:
         """Validate model data."""
         super().clean()

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/apps/maintenance/services/maintenance_service.py

@@ -142,36 +142,87 @@ class MaintenanceService:
     
     @retry_on_failure(max_retries=3, base_delay=1.0)
     def _create_maintenance_page_rule(self) -> Dict[str, Any]:
-        """Create Page Rule to redirect all traffic to maintenance page."""
+        """Create Page Rules to redirect all traffic to maintenance page (including subdomains)."""
         maintenance_url = self.site.get_maintenance_url()
-        pattern = f"{self.site.domain}/*"
+        patterns = self.site.get_domain_patterns()
         
-        logger.info(f"Creating page rule: {pattern} → {maintenance_url}")
+        logger.info(f"Creating page rules for {self.site.domain}: {patterns} → {maintenance_url}")
         
-        response = self.client.page_rules.create(
+        # First, check if conflicting Page Rules already exist and delete them
+        try:
+            existing_rules = self.client.page_rules.list(zone_id=self.site.zone_id)
+            
+            # Handle different API response formats
+            if hasattr(existing_rules, 'result'):
+                rules = existing_rules.result
+            else:
+                rules = existing_rules
+            
+            # Look for conflicting rules with same patterns
+            for rule in rules:
+                if (hasattr(rule, 'targets') and rule.targets and 
+                    len(rule.targets) > 0 and 
+                    hasattr(rule.targets[0], 'constraint') and 
+                    hasattr(rule.targets[0].constraint, 'value')):
+                    
+                    rule_pattern = rule.targets[0].constraint.value
+                    if rule_pattern in patterns:
+                        logger.info(f"Found conflicting page rule {rule.id} with pattern {rule_pattern}, deleting...")
+                        self.client.page_rules.delete(
             zone_id=self.site.zone_id,
-            targets=[{
-                "target": "url",
-                "constraint": {
-                    "operator": "matches",
-                    "value": pattern
-                }
-            }],
-            actions=[{
-                "id": "forwarding_url",
-                "value": {
-                    "url": maintenance_url,
-                    "status_code": 302
-                }
-            }],
-            status="active"
-        )
-        return response.model_dump()
+                            pagerule_id=rule.id
+                        )
+                        logger.info(f"Deleted conflicting page rule {rule.id}")
+                    
+        except Exception as e:
+            logger.warning(f"Error checking existing page rules: {e}")
+            # Continue with creation anyway
+        
+        # Create Page Rules for each pattern
+        created_rules = []
+        for pattern in patterns:
+            try:
+                logger.info(f"Creating page rule: {pattern} → {maintenance_url}")
+                response = self.client.page_rules.create(
+                    zone_id=self.site.zone_id,
+                    targets=[{
+                        "target": "url",
+                        "constraint": {
+                            "operator": "matches",
+                            "value": pattern
+                        }
+                    }],
+                    actions=[{
+                        "id": "forwarding_url",
+                        "value": {
+                            "url": maintenance_url,
+                            "status_code": 302
+                        }
+                    }],
+                    status="active"
+                )
+                created_rules.append({
+                    "pattern": pattern,
+                    "rule_id": response.id if hasattr(response, 'id') else 'unknown',
+                    "response": response.model_dump()
+                })
+                logger.info(f"Created page rule for pattern {pattern}")
+                
+            except Exception as e:
+                logger.error(f"Failed to create page rule for pattern {pattern}: {e}")
+                # Continue with other patterns
+        
+        return {
+            "success": True,
+            "patterns": patterns,
+            "created_rules": created_rules,
+            "total_rules": len(created_rules)
+        }
     
     @retry_on_failure(max_retries=3, base_delay=1.0)
     def _delete_maintenance_page_rule(self) -> Dict[str, Any]:
-        """Delete maintenance Page Rule with retry logic."""
-        # Find the maintenance page rule
+        """Delete maintenance Page Rules with retry logic (including subdomains)."""
+        # Find the maintenance page rules
         page_rules_response = self.client.page_rules.list(zone_id=self.site.zone_id)
         
         # Handle different API response formats
@@ -180,37 +231,75 @@ class MaintenanceService:
         else:
             page_rules = page_rules_response
         
-        maintenance_pattern = f"{self.site.domain}/*"
+        patterns = self.site.get_domain_patterns()
         maintenance_url = self.site.get_maintenance_url()
         
-        logger.info(f"Looking for page rule to delete: pattern={maintenance_pattern}, url={maintenance_url}")
+        logger.info(f"Looking for page rules to delete: patterns={patterns}, url={maintenance_url}")
         logger.info(f"Found {len(page_rules)} page rules total")
         
+        deleted_rules = []
+        
         for rule in page_rules:
             logger.info(f"Checking rule {rule.id}: targets={getattr(rule, 'targets', None)}, actions={getattr(rule, 'actions', None)}")
             
-            # Simple check - look for forwarding_url action with maintenance URL
-            if (hasattr(rule, 'actions') and rule.actions and 
+            # Check if this rule matches our maintenance patterns
+            rule_matches = False
+            
+            # Check by pattern
+            if (hasattr(rule, 'targets') and rule.targets and 
+                len(rule.targets) > 0 and 
+                hasattr(rule.targets[0], 'constraint') and 
+                hasattr(rule.targets[0].constraint, 'value')):
+                
+                rule_pattern = rule.targets[0].constraint.value
+                if rule_pattern in patterns:
+                    rule_matches = True
+                    logger.info(f"Rule {rule.id} matches pattern: {rule_pattern}")
+            
+            # Also check by URL (fallback for older rules)
+            if not rule_matches and (hasattr(rule, 'actions') and rule.actions and 
                 len(rule.actions) > 0 and 
                 hasattr(rule.actions[0], 'id') and 
                 rule.actions[0].id == "forwarding_url"):
                 
-                # Check if URL contains maintenance.reforms.ai
                 action_value = getattr(rule.actions[0], 'value', {})
                 action_url = getattr(action_value, 'url', '')
                 
                 logger.info(f"Found forwarding rule with URL: {action_url}")
                 
-                if "maintenance.reforms.ai" in action_url:
+                if ("maintenance.reforms.ai" in action_url or 
+                    "djangocfg.com/maintenance" in action_url):
+                    rule_matches = True
+                    logger.info(f"Rule {rule.id} matches maintenance URL")
+            
+            # Delete matching rule
+            if rule_matches:
+                try:
                     logger.info(f"Deleting maintenance page rule: {rule.id}")
                     response = self.client.page_rules.delete(
                         zone_id=self.site.zone_id,
                         pagerule_id=rule.id
                     )
-                    return response.model_dump()
+                    deleted_rules.append({
+                        "rule_id": rule.id,
+                        "pattern": getattr(rule.targets[0].constraint, 'value', 'unknown') if hasattr(rule, 'targets') and rule.targets else 'unknown',
+                        "response": response.model_dump()
+                    })
+                    logger.info(f"Successfully deleted page rule: {rule.id}")
+                    
+                except Exception as e:
+                    logger.error(f"Failed to delete page rule {rule.id}: {e}")
         
-        logger.warning(f"No maintenance page rule found for {self.site.domain}")
-        return {"success": True, "message": "No page rule to delete"}
+        if deleted_rules:
+            logger.info(f"Deleted {len(deleted_rules)} maintenance page rules for {self.site.domain}")
+            return {
+                "success": True,
+                "deleted_rules": deleted_rules,
+                "total_deleted": len(deleted_rules)
+            }
+        else:
+            logger.warning(f"No maintenance page rules found for {self.site.domain}")
+            return {"success": True, "message": "No page rules to delete"}
     
 
 

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/apps/maintenance/services/site_sync_service.py

@@ -68,6 +68,7 @@ class SiteSyncService:
             logger.error(f"Failed to discover zones: {e}")
             raise CloudflareRetryError(f"Zone discovery failed: {e}")
     
+    
     def sync_zones(self, 
                    force_update: bool = False,
                    dry_run: bool = False) -> Dict[str, Any]:
@@ -163,9 +164,18 @@ class SiteSyncService:
                         'changes': self._get_site_changes(site, zone_data)
                     }
                 else:
-                    # Update existing site
+                    # Update existing site - preserve subdomain settings
                     site.domain = domain
                     site.account_id = zone_data.get('account_id', site.account_id)
+                    
+                    # Ensure subdomain fields are not reset to None during sync
+                    if site.include_subdomains is None:
+                        site.include_subdomains = True
+                    if site.subdomain_list is None:
+                        site.subdomain_list = ''
+                    if site.maintenance_url is None:
+                        site.maintenance_url = ''
+                    
                     site.save()
                     
                     # Log the sync
@@ -195,14 +205,18 @@ class SiteSyncService:
                     'zone_data': zone_data
                 }
             else:
-                # Create new site
+                # Create new site with default subdomain settings
                 site = CloudflareSite.objects.create(
                     name=self._generate_site_name(domain),
                     domain=domain,
                     zone_id=zone_id,
                     account_id=zone_data.get('account_id', ''),
                     api_key=self.api_key,
-                    is_active=not zone_data.get('paused', False)
+                    is_active=not zone_data.get('paused', False),
+                    # Use default values from model
+                    include_subdomains=True,  # Default: include all subdomains
+                    subdomain_list='',       # Default: empty list
+                    maintenance_url=''       # Default: empty URL
                 )
                 
                 # Log the creation
@@ -274,9 +288,18 @@ class SiteSyncService:
                 'last_checked': timezone.now().isoformat()
             }
             
-            # Update site status
+            # Update site status - preserve subdomain settings
             site.maintenance_active = maintenance_active
             site.is_active = not zone.paused
+            
+            # Ensure subdomain fields are not reset to None during status update
+            if site.include_subdomains is None:
+                site.include_subdomains = True
+            if site.subdomain_list is None:
+                site.subdomain_list = ''
+            if site.maintenance_url is None:
+                site.maintenance_url = ''
+                
             site.save()
             
             return status_info
@@ -373,14 +396,36 @@ def sync_site_from_cloudflare(site: CloudflareSite) -> MaintenanceLog:
     """
     try:
         sync_service = SiteSyncService(site.api_key)
-        status_info = sync_service.check_site_status(site)
         
-        return MaintenanceLog.log_success(
-            site=site,
-            action=MaintenanceLog.Action.SYNC,
-            reason="Manual site sync",
-            cloudflare_response=status_info
-        )
+        # Perform full zone sync to update site data from Cloudflare
+        sync_result = sync_service.sync_zones(force_update=True)
+        
+        # Find the specific site result
+        site_result = None
+        for site_info in sync_result.get('sites', []):
+            if site_info.get('domain') == site.domain:
+                site_result = site_info
+                break
+        
+        response_data = {
+            'sync_result': sync_result,
+            'site_result': site_result
+        }
+        
+        if sync_result.get('errors', 0) == 0:
+            return MaintenanceLog.log_success(
+                site=site,
+                action=MaintenanceLog.Action.SYNC,
+                reason="Manual site sync - force update from Cloudflare",
+                cloudflare_response=response_data
+            )
+        else:
+            return MaintenanceLog.log_failure(
+                site=site,
+                action=MaintenanceLog.Action.SYNC,
+                error_message=f"Sync completed with {sync_result['errors']} errors",
+                cloudflare_response=response_data
+            )
         
     except Exception as e:
         return MaintenanceLog.log_failure(

{django_cfg-1.2.20 → django_cfg-1.2.22}/src/django_cfg/apps/newsletter/signals.py

@@ -28,14 +28,15 @@ def newsletter_created(sender, instance, created, **kwargs):
 def subscription_created(sender, instance, created, **kwargs):
     """Handle newsletter subscription creation."""
     if created:
-        logger.info(f"New subscription: {instance.email} to newsletter {instance.newsletter.title}")
-        # Add logic for welcome email to new subscribers
-        try:
-            from .services.email_service import NewsletterEmailService
-            email_service = NewsletterEmailService()
-            email_service.send_subscription_welcome_email(instance)
-        except Exception as e:
-            logger.error(f"Failed to send welcome email to {instance.email}: {e}")
+        pass
+        # logger.info(f"New subscription: {instance.email} to newsletter {instance.newsletter.title}")
+        # # Add logic for welcome email to new subscribers
+        # try:
+        #     from .services.email_service import NewsletterEmailService
+        #     email_service = NewsletterEmailService()
+        #     email_service.send_subscription_welcome_email(instance)
+        # except Exception as e:
+        #     logger.error(f"Failed to send welcome email to {instance.email}: {e}")
 
 
 @receiver(pre_delete, sender=NewsletterSubscription)

django_cfg-1.2.22/src/django_cfg/apps/payments/__init__.py

@@ -0,0 +1,8 @@
+"""
+Universal payments app for Django.
+
+Provides reusable payment functionality with provider abstraction,
+subscription management, and comprehensive audit trails.
+"""
+
+default_app_config = 'django_cfg.apps.payments.apps.PaymentsConfig'

django_cfg-1.2.22/src/django_cfg/apps/payments/apps.py

@@ -0,0 +1,22 @@
+"""
+Django app configuration for universal payments.
+"""
+
+from django.apps import AppConfig
+
+
+class PaymentsConfig(AppConfig):
+    """Universal payments app configuration."""
+    
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.payments'
+    label = 'django_cfg_payments'
+    verbose_name = 'Universal Payments'
+    
+    def ready(self):
+        """Called when the app is ready."""
+        # Import signals if any
+        try:
+            from . import signals  # noqa
+        except ImportError:
+            pass

django_cfg-1.2.22/src/django_cfg/apps/payments/managers/__init__.py

@@ -0,0 +1,22 @@
+"""
+Django model managers for universal payments.
+"""
+
+from .payment_manager import UniversalPaymentManager
+from .balance_manager import UserBalanceManager
+from .subscription_manager import SubscriptionManager, EndpointGroupManager
+from .tariff_manager import TariffManager, TariffEndpointGroupManager
+from .api_key_manager import APIKeyManager
+from .currency_manager import CurrencyManager, CurrencyNetworkManager
+
+__all__ = [
+    'UniversalPaymentManager',
+    'UserBalanceManager',
+    'SubscriptionManager',
+    'EndpointGroupManager', 
+    'TariffManager',
+    'TariffEndpointGroupManager',
+    'APIKeyManager',
+    'CurrencyManager',
+    'CurrencyNetworkManager',
+]

django_cfg-1.2.22/src/django_cfg/apps/payments/managers/api_key_manager.py

@@ -0,0 +1,35 @@
+"""
+API key managers.
+"""
+
+from django.db import models
+from django.utils import timezone
+
+
+class APIKeyManager(models.Manager):
+    """Manager for APIKey model."""
+    
+    def get_active_keys(self, user=None):
+        """Get active API keys."""
+        queryset = self.filter(is_active=True)
+        if user:
+            queryset = queryset.filter(user=user)
+        return queryset
+    
+    def get_expired_keys(self):
+        """Get expired API keys."""
+        return self.filter(
+            expires_at__lte=timezone.now()
+        )
+    
+    def get_valid_keys(self, user=None):
+        """Get valid (active and not expired) API keys."""
+        now = timezone.now()
+        queryset = self.filter(
+            is_active=True
+        ).filter(
+            models.Q(expires_at__isnull=True) | models.Q(expires_at__gt=now)
+        )
+        if user:
+            queryset = queryset.filter(user=user)
+        return queryset