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

django_cfg/__init__.py

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

django_cfg/apps/accounts/models/__init__.py

@@ -0,0 +1,68 @@
+"""
+Django CFG Accounts Models
+
+This module provides all the models for the accounts app.
+Models are organized by functionality:
+
+- base: Base utilities and functions
+- user: User model and related functionality  
+- registration: Registration and source tracking models
+- auth: Authentication models (OTP, etc.)
+- activity: User activity tracking models
+- integrations: Third-party integrations models (Twilio, etc.)
+"""
+
+# Import base utilities
+from .base import user_avatar_path
+
+# Import choices
+from .choices import (
+    ActivityType,
+    TwilioResponseType,
+    TwilioServiceType,
+)
+
+# Import user models
+from .user import CustomUser
+
+# Import registration models
+from .registration import (
+    RegistrationSource,
+    UserRegistrationSource,
+)
+
+# Import authentication models
+from .auth import OTPSecret
+
+# Import activity models
+from .activity import UserActivity
+
+# Import integration models
+from .integrations import TwilioResponse
+
+# Export all models
+__all__ = [
+    # Base utilities
+    'user_avatar_path',
+    
+    # Choices
+    'ActivityType',
+    'TwilioResponseType',
+    'TwilioServiceType',
+    
+    # User models
+    'CustomUser',
+    
+    # Registration models
+    'RegistrationSource',
+    'UserRegistrationSource',
+    
+    # Authentication models
+    'OTPSecret',
+    
+    # Activity models
+    'UserActivity',
+    
+    # Integration models
+    'TwilioResponse',
+]

django_cfg/apps/accounts/models/activity.py

@@ -0,0 +1,34 @@
+"""
+User activity tracking models.
+"""
+
+from django.db import models
+
+from .choices import ActivityType
+
+
+class UserActivity(models.Model):
+    """
+    User activity log.
+    """
+    
+    user = models.ForeignKey('CustomUser', on_delete=models.CASCADE, related_name='activities')
+    activity_type = models.CharField(max_length=20, choices=ActivityType.choices)
+    description = models.TextField(blank=True)
+    ip_address = models.GenericIPAddressField(null=True, blank=True)
+    user_agent = models.TextField(blank=True)
+    
+    # Related objects (generic foreign key could be used here)
+    object_id = models.PositiveIntegerField(null=True, blank=True)
+    object_type = models.CharField(max_length=50, blank=True)
+    
+    created_at = models.DateTimeField(auto_now_add=True)
+    
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        verbose_name = 'User Activity'
+        verbose_name_plural = 'User Activities'
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return f"{self.user.username} - {self.get_activity_type_display()}"

django_cfg/apps/accounts/models/auth.py

@@ -0,0 +1,50 @@
+"""
+Authentication models (OTP, etc.).
+"""
+
+import random
+import string
+from datetime import timedelta
+
+from django.db import models
+from django.utils import timezone
+
+
+class OTPSecret(models.Model):
+    """Stores One-Time Passwords for authentication."""
+
+    email = models.EmailField(db_index=True)
+    secret = models.CharField(max_length=6)
+    created_at = models.DateTimeField(auto_now_add=True)
+    expires_at = models.DateTimeField()
+    is_used = models.BooleanField(default=False)
+
+    def save(self, *args, **kwargs):
+        if not self.expires_at:
+            self.expires_at = timezone.now() + timedelta(minutes=10)
+        super().save(*args, **kwargs)
+
+    @staticmethod
+    def generate_otp(length=6):
+        """Generate random numeric OTP."""
+        return "".join(random.choices(string.digits, k=length))
+
+    @property
+    def is_valid(self):
+        """Check if OTP is still valid."""
+        return not self.is_used and timezone.now() < self.expires_at
+
+    def mark_used(self):
+        """Mark OTP as used."""
+        self.is_used = True
+        self.save(update_fields=["is_used"])
+
+    def __str__(self):
+        return f"OTP for {self.email}"
+
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        ordering = ["-created_at"]
+        indexes = [
+            models.Index(fields=["email", "is_used", "expires_at"]),
+        ]

django_cfg/apps/accounts/models/base.py

@@ -0,0 +1,8 @@
+"""
+Base utilities and functions for accounts models.
+"""
+
+
+def user_avatar_path(instance, filename):
+    """Generate file path for user avatar."""
+    return f"avatars/{instance.id}/{filename}"

django_cfg/apps/accounts/models/choices.py

@@ -0,0 +1,32 @@
+"""
+Model choices constants for accounts app.
+"""
+
+from django.db import models
+
+
+class ActivityType(models.TextChoices):
+    """User activity types."""
+    LOGIN = 'login', 'Login'
+    LOGOUT = 'logout', 'Logout'
+    OTP_REQUESTED = 'otp_requested', 'OTP Requested'
+    OTP_VERIFIED = 'otp_verified', 'OTP Verified'
+    PROFILE_UPDATED = 'profile_updated', 'Profile Updated'
+    REGISTRATION = 'registration', 'Registration'
+
+
+class TwilioResponseType(models.TextChoices):
+    """Twilio response types."""
+    API_SEND = 'api_send', 'API Send Request'
+    API_VERIFY = 'api_verify', 'API Verify Request'
+    WEBHOOK_STATUS = 'webhook_status', 'Webhook Status Update'
+    WEBHOOK_DELIVERY = 'webhook_delivery', 'Webhook Delivery Report'
+
+
+class TwilioServiceType(models.TextChoices):
+    """Twilio service types."""
+    WHATSAPP = 'whatsapp', 'WhatsApp'
+    SMS = 'sms', 'SMS'
+    VOICE = 'voice', 'Voice'
+    EMAIL = 'email', 'Email'
+    VERIFY = 'verify', 'Verify API'

django_cfg/apps/accounts/models/integrations.py

@@ -0,0 +1,75 @@
+"""
+Third-party integrations models (Twilio, etc.).
+"""
+
+from django.db import models
+
+from .choices import TwilioResponseType, TwilioServiceType
+
+
+class TwilioResponse(models.Model):
+    """Model for storing Twilio API responses and webhook data."""
+    
+    response_type = models.CharField(max_length=20, choices=TwilioResponseType.choices)
+    service_type = models.CharField(max_length=10, choices=TwilioServiceType.choices)
+    
+    # Twilio identifiers
+    message_sid = models.CharField(max_length=34, blank=True, help_text="Twilio Message SID")
+    verification_sid = models.CharField(max_length=34, blank=True, help_text="Twilio Verification SID")
+    
+    # Request/Response data
+    request_data = models.JSONField(default=dict, help_text="Original request parameters")
+    response_data = models.JSONField(default=dict, help_text="Twilio API response")
+    
+    # Status and error handling
+    status = models.CharField(max_length=20, blank=True, help_text="Message/Verification status")
+    error_code = models.CharField(max_length=10, blank=True, help_text="Twilio error code")
+    error_message = models.TextField(blank=True, help_text="Error description")
+    
+    # Contact information
+    to_number = models.CharField(max_length=20, blank=True, help_text="Recipient phone/email")
+    from_number = models.CharField(max_length=20, blank=True, help_text="Sender phone/email")
+    
+    # Pricing
+    price = models.DecimalField(max_digits=10, decimal_places=6, null=True, blank=True)
+    price_unit = models.CharField(max_length=3, blank=True, help_text="Currency code")
+    
+    # Timestamps
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    twilio_created_at = models.DateTimeField(null=True, blank=True, help_text="Timestamp from Twilio")
+    
+    # Relations
+    otp_secret = models.ForeignKey(
+        'OTPSecret', 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank=True,
+        related_name='twilio_responses',
+        help_text="Related OTP if applicable"
+    )
+    
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        verbose_name = 'Twilio Response'
+        verbose_name_plural = 'Twilio Responses'
+        ordering = ['-created_at']
+        indexes = [
+            models.Index(fields=['message_sid']),
+            models.Index(fields=['verification_sid']),
+            models.Index(fields=['status', 'created_at']),
+            models.Index(fields=['response_type', 'service_type']),
+        ]
+    
+    def __str__(self):
+        return f"{self.get_response_type_display()} - {self.get_service_type_display()}"
+    
+    @property
+    def has_error(self):
+        """Check if response has error."""
+        return bool(self.error_code or self.error_message)
+    
+    @property
+    def is_successful(self):
+        """Check if response is successful."""
+        return not self.has_error and self.status in ['sent', 'delivered', 'approved']

django_cfg/apps/accounts/models/registration.py

@@ -0,0 +1,52 @@
+"""
+Registration and source tracking models.
+"""
+
+from django.db import models
+from urllib.parse import urlparse
+
+
+class RegistrationSource(models.Model):
+    """Model for tracking user registration sources/projects."""
+    url = models.URLField(unique=True, help_text="Source URL (e.g., https://unrealon.com)")
+    name = models.CharField(max_length=100, blank=True, help_text="Display name for the source")
+    description = models.TextField(blank=True, help_text="Optional description")
+    is_active = models.BooleanField(default=True, help_text="Whether this source is active")
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.name or self.get_domain()
+
+    def get_domain(self):
+        """Extract domain from URL."""
+        try:
+            parsed = urlparse(self.url)
+            return parsed.netloc
+        except:
+            return self.url
+
+    def get_display_name(self):
+        """Get display name or domain."""
+        return self.name or self.get_domain()
+
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        verbose_name = "Registration Source"
+        verbose_name_plural = "Registration Sources"
+        ordering = ['-created_at']
+
+
+class UserRegistrationSource(models.Model):
+    """Many-to-many relationship between users and registration sources."""
+    user = models.ForeignKey('CustomUser', on_delete=models.CASCADE, related_name='user_registration_sources')
+    source = models.ForeignKey(RegistrationSource, on_delete=models.CASCADE, related_name='user_registration_sources')
+    first_registration = models.BooleanField(default=True, help_text="Whether this was the first registration from this source")
+    registration_date = models.DateTimeField(auto_now_add=True)
+    
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        unique_together = ['user', 'source']
+        verbose_name = "User Registration Source"
+        verbose_name_plural = "User Registration Sources"
+        ordering = ['-registration_date']

django_cfg/apps/accounts/models/user.py

@@ -0,0 +1,80 @@
+"""
+User model and related functionality.
+"""
+
+from typing import Optional, List
+from django.contrib.auth.models import AbstractUser
+from django.db import models
+
+from ..managers.user_manager import UserManager
+from .base import user_avatar_path
+
+
+class CustomUser(AbstractUser):
+    """Simplified user model for OTP-only authentication."""
+
+    email = models.EmailField(unique=True)
+
+    # Profile fields
+    first_name = models.CharField(max_length=50, blank=True)
+    last_name = models.CharField(max_length=50, blank=True)
+    company = models.CharField(max_length=100, blank=True)
+    phone = models.CharField(max_length=20, blank=True)
+    position = models.CharField(max_length=100, blank=True)
+    avatar = models.ImageField(upload_to=user_avatar_path, blank=True, null=True)
+
+    # Profile metadata
+    updated_at = models.DateTimeField(auto_now=True)
+
+    # Managers
+    objects: UserManager = UserManager()
+
+    USERNAME_FIELD = "email"
+    REQUIRED_FIELDS = ["username"]
+
+    def __str__(self):
+        return self.email
+
+    @property
+    def is_admin(self) -> bool:
+        return self.is_superuser
+
+    @property
+    def full_name(self) -> str:
+        """Get user's full name."""
+        return self.__class__.objects.get_full_name(self)
+
+    @property
+    def initials(self) -> str:
+        """Get user's initials for avatar fallback."""
+        return self.__class__.objects.get_initials(self)
+
+    @property
+    def display_username(self) -> str:
+        """Get formatted username for display."""
+        return self.__class__.objects.get_display_username(self)
+
+    @property
+    def unanswered_messages_count(self) -> int:
+        """Get count of unanswered messages for the user."""
+        return self.__class__.objects.get_unanswered_messages_count(self)
+
+    def get_sources(self) -> List['RegistrationSource']:
+        """Get all sources associated with this user."""
+        from .registration import RegistrationSource
+        return RegistrationSource.objects.filter(user_registration_sources__user=self)
+
+    @property
+    def primary_source(self) -> Optional['RegistrationSource']:
+        """Get the first source where user registered."""
+        from .registration import UserRegistrationSource
+        user_source = UserRegistrationSource.objects.filter(
+            user=self, 
+            first_registration=True
+        ).first()
+        return user_source.source if user_source else None
+
+    class Meta:
+        app_label = 'django_cfg_accounts'
+        verbose_name = "User"
+        verbose_name_plural = "Users"

django_cfg/apps/maintenance/__init__.py

@@ -1,27 +1,56 @@
 """
-Django-CFG Maintenance Application
-
-Multi-site maintenance mode management with Cloudflare integration.
-Provides zero-configuration setup and ORM-like interface for managing
-maintenance mode across multiple sites.
-
-Key Features:
-- Zero-configuration Cloudflare setup
-- Multi-site management with ORM-like queries
-- External monitoring for automatic maintenance mode
-- Rich Django admin interface
-- Scheduled maintenance support
-- Full audit trail and logging
-
-Example Usage:
-    # Zero-config setup
-    CLOUDFLARE_API_TOKEN = "your_token"
-    CLOUDFLARE_DOMAIN = "example.com"
-    
-    # Multi-site management
-    sites = multi_site_manager.sites(user)
-    await sites.production().enable_maintenance()
-    await sites.filter(project='client-a').disable_maintenance()
+Simplified Django-CFG Maintenance Application.
+
+A simple maintenance mode management app with Cloudflare integration.
+Refactored from 119 files to ~10 files following KISS principles.
+
+Proper structure:
+- models/ - CloudflareSite and MaintenanceLog models
+- services/ - MaintenanceService for Cloudflare operations
+- admin/ - Simple admin interfaces
+- management/commands/ - CLI commands
 """
 
-default_app_config = 'django_cfg.apps.maintenance.apps.MaintenanceConfig'
+__version__ = "2.0.0"
+__author__ = "Django-CFG Team"
+
+# Lazy import registry to avoid Django initialization issues
+_LAZY_IMPORTS = {
+    # Models
+    'CloudflareApiKey': ('django_cfg.apps.maintenance.models', 'CloudflareApiKey'),
+    'CloudflareSite': ('django_cfg.apps.maintenance.models', 'CloudflareSite'),
+    'MaintenanceLog': ('django_cfg.apps.maintenance.models', 'MaintenanceLog'),
+    'ScheduledMaintenance': ('django_cfg.apps.maintenance.models', 'ScheduledMaintenance'),
+    
+    # Services
+    'MaintenanceService': ('django_cfg.apps.maintenance.services', 'MaintenanceService'),
+    'SiteSyncService': ('django_cfg.apps.maintenance.services', 'SiteSyncService'),
+    'BulkOperationsService': ('django_cfg.apps.maintenance.services', 'BulkOperationsService'),
+    'ScheduledMaintenanceService': ('django_cfg.apps.maintenance.services', 'ScheduledMaintenanceService'),
+    'bulk_operations': ('django_cfg.apps.maintenance.services', 'bulk_operations'),
+    'scheduled_maintenance_service': ('django_cfg.apps.maintenance.services', 'scheduled_maintenance_service'),
+    'enable_maintenance_for_domain': ('django_cfg.apps.maintenance.services', 'enable_maintenance_for_domain'),
+    'disable_maintenance_for_domain': ('django_cfg.apps.maintenance.services', 'disable_maintenance_for_domain'),
+    'sync_site_from_cloudflare': ('django_cfg.apps.maintenance.services', 'sync_site_from_cloudflare'),
+    'enable_maintenance_for_domains': ('django_cfg.apps.maintenance.services', 'enable_maintenance_for_domains'),
+    'disable_maintenance_for_domains': ('django_cfg.apps.maintenance.services', 'disable_maintenance_for_domains'),
+    'bulk_sync_all_sites': ('django_cfg.apps.maintenance.services', 'bulk_sync_all_sites'),
+    'get_maintenance_status_report': ('django_cfg.apps.maintenance.services', 'get_maintenance_status_report'),
+    'schedule_maintenance_for_sites': ('django_cfg.apps.maintenance.services', 'schedule_maintenance_for_sites'),
+    'process_scheduled_maintenances': ('django_cfg.apps.maintenance.services', 'process_scheduled_maintenances'),
+}
+
+
+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}'")
+
+
+__all__ = list(_LAZY_IMPORTS.keys())

django_cfg/apps/maintenance/admin/__init__.py

@@ -1,28 +1,17 @@
 """
 Maintenance admin interfaces.
 
-Rich Django admin interfaces for multi-site maintenance management.
-Following django-cfg patterns with Unfold optimization.
+Decomposed admin interfaces with Unfold styling and action buttons.
 """
 
-# Import all admin classes to register them
-from .sites_admin import CloudflareSiteAdmin, SiteGroupAdmin
-from .events_admin import MaintenanceEventAdmin, MaintenanceLogAdmin
-from .monitoring_admin import MonitoringTargetAdmin
-from .deployments_admin import CloudflareDeploymentAdmin
+from .api_key_admin import CloudflareApiKeyAdmin
+from .site_admin import CloudflareSiteAdmin
+from .log_admin import MaintenanceLogAdmin
+from .scheduled_admin import ScheduledMaintenanceAdmin
 
 __all__ = [
-    # Site management
+    'CloudflareApiKeyAdmin',
     'CloudflareSiteAdmin',
-    'SiteGroupAdmin',
-    
-    # Maintenance tracking
-    'MaintenanceEventAdmin', 
     'MaintenanceLogAdmin',
-    
-    # Monitoring
-    'MonitoringTargetAdmin',
-    
-    # Cloudflare integration
-    'CloudflareDeploymentAdmin',
+    'ScheduledMaintenanceAdmin',
 ]