django-cfg 1.1.81__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/accounts/admin/registration_source.py

@@ -5,21 +5,14 @@ Registration Source admin configuration.
 from django.contrib import admin
 from django.contrib.humanize.templatetags.humanize import naturaltime
 from unfold.admin import ModelAdmin
-from import_export.admin import ImportExportModelAdmin
-from unfold.contrib.import_export.forms import ImportForm, ExportForm
 
 from ..models import RegistrationSource, UserRegistrationSource
 from .filters import RegistrationSourceStatusFilter
 from .inlines import RegistrationSourceInline
-from .resources import RegistrationSourceResource
 
 
 @admin.register(RegistrationSource)
-class RegistrationSourceAdmin(ModelAdmin, ImportExportModelAdmin):
-    # Import/Export configuration
-    resource_class = RegistrationSourceResource
-    import_form_class = ImportForm
-    export_form_class = ExportForm
+class RegistrationSourceAdmin(ModelAdmin):
     list_display = ["name", "url", "status", "users_count", "created"]
     list_display_links = ["name", "url"]
     list_filter = [RegistrationSourceStatusFilter, "is_active", "created_at"]

django_cfg/apps/accounts/admin/user.py

@@ -12,26 +12,18 @@ from unfold.admin import ModelAdmin
 from unfold.forms import AdminPasswordChangeForm, UserChangeForm, UserCreationForm
 from unfold.decorators import action
 from unfold.enums import ActionVariant
-from import_export.admin import ImportExportModelAdmin
-from unfold.contrib.import_export.forms import ImportForm, ExportForm
 
 from ..models import CustomUser
 from .filters import UserStatusFilter
 from .inlines import UserRegistrationSourceInline, UserActivityInline, UserEmailLogInline, UserSupportTicketsInline
-from .resources import CustomUserResource
 
 
 @admin.register(CustomUser)
-class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
+class CustomUserAdmin(BaseUserAdmin, ModelAdmin):
     # Forms loaded from `unfold.forms`
     form = UserChangeForm
     add_form = UserCreationForm
     change_password_form = AdminPasswordChangeForm
-    
-    # Import/Export configuration
-    resource_class = CustomUserResource
-    import_form_class = ImportForm
-    export_form_class = ExportForm
 
     list_display = [
         "avatar",
@@ -56,8 +48,8 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
         
         # Add email log inline if newsletter app is enabled
         try:
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             if base_module.is_newsletter_enabled():
                 inlines.append(UserEmailLogInline)
             if base_module.is_support_enabled():
@@ -80,7 +72,7 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
         (
             "Contact Information",
             {
-                "fields": ("company", "phone", "phone_verified", "position"),
+                "fields": ("company", "phone", "position"),
             },
         ),
         (
@@ -159,8 +151,8 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
     def emails_count(self, obj):
         """Show count of emails sent to user (if newsletter app is enabled)."""
         try:
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             
             if not base_module.is_newsletter_enabled():
                 return "—"
@@ -178,8 +170,8 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
     def tickets_count(self, obj):
         """Show count of support tickets for user (if support app is enabled)."""
         try:
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             
             if not base_module.is_support_enabled():
                 return "—"
@@ -241,8 +233,8 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
                 return redirect(request.META.get('HTTP_REFERER', '/admin/'))
             
             # Check if newsletter app is enabled
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             
             if not base_module.is_newsletter_enabled():
                 self.message_user(
@@ -279,8 +271,8 @@ class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
                 return redirect(request.META.get('HTTP_REFERER', '/admin/'))
             
             # Check if support app is enabled
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             
             if not base_module.is_support_enabled():
                 self.message_user(

django_cfg/apps/accounts/managers/user_manager.py

@@ -83,8 +83,8 @@ class UserManager(UserManager):
                 f"Attempting to get_or_create user with email: {email}, username: {username}"
             )
 
-            # Create or get user using self (the manager)
-            user, created = self.get_or_create(
+            # Create or get user using self.model instead of importing CustomUser
+            user, created = self.model.objects.get_or_create(
                 email=email, defaults=defaults
             )
 
@@ -287,130 +287,3 @@ class UserManager(UserManager):
         elif user.last_name:
             return user.last_name
         return user.email.split("@")[0].capitalize()
-
-    # === NOTIFICATION-AWARE USER OPERATIONS ===
-
-    def create_user_with_notifications(self, email, password=None, send_notifications=True, **extra_fields):
-        """
-        Create user with optional notifications.
-        
-        Args:
-            email: User's email address
-            password: User's password
-            send_notifications: Whether to send email/telegram notifications
-            **extra_fields: Additional fields for user creation
-            
-        Returns:
-            User: Created user instance
-        """
-        # Create user normally
-        user = self.create_user(email, password, **extra_fields)
-        
-        # Send notifications if requested
-        if send_notifications:
-            from ..utils.notifications import AccountNotifications
-            AccountNotifications.send_welcome_email(user)
-        
-        return user
-
-    def register_user_with_notifications(self, email, username=None, source_url=None, send_notifications=True, **extra_fields):
-        """
-        Register user with optional notifications (extends existing register_user method).
-        
-        Args:
-            email: User's email address
-            username: Optional username
-            source_url: Optional source URL for tracking
-            send_notifications: Whether to send notifications
-            **extra_fields: Additional fields for user creation
-            
-        Returns:
-            tuple: (user, created) where created is True if user was created
-        """
-        # Use existing register_user method
-        user, created = self.register_user(email, username, source_url, **extra_fields)
-        
-        # Send notifications only for new users if requested
-        if created and send_notifications:
-            from ..utils.notifications import AccountNotifications
-            AccountNotifications.send_welcome_email(user)
-        
-        return user, created
-
-    def update_user_profile(self, user, send_notifications=True, **update_fields):
-        """
-        Update user profile with optional notifications.
-        
-        Args:
-            user: User instance to update
-            send_notifications: Whether to send notifications for important changes
-            **update_fields: Fields to update
-            
-        Returns:
-            User: Updated user instance
-        """
-        if not update_fields:
-            return user
-        
-        # Track important changes for notifications
-        important_changes = []
-        old_values = {}
-        
-        if send_notifications:
-            # Store old values for comparison
-            for field in ['email', 'username', 'first_name', 'last_name']:
-                if field in update_fields:
-                    old_values[field] = getattr(user, field)
-        
-        # Update user fields
-        for field, value in update_fields.items():
-            setattr(user, field, value)
-        
-        user.save()
-        
-        # Check for important changes and send notifications
-        if send_notifications and old_values:
-            if 'email' in old_values and old_values['email'] != user.email:
-                important_changes.append("email address")
-            
-            if 'username' in old_values and old_values['username'] != user.username:
-                important_changes.append("username")
-            
-            if (('first_name' in old_values and old_values['first_name'] != user.first_name) or
-                ('last_name' in old_values and old_values['last_name'] != user.last_name)):
-                important_changes.append("name")
-            
-            # Send notifications if there were important changes
-            if important_changes:
-                from ..utils.notifications import AccountNotifications
-                AccountNotifications.send_profile_update_notification(user, important_changes)
-        
-        return user
-
-    def update_user_status(self, user, is_active=None, send_notifications=True, reason=None):
-        """
-        Update user active status with optional notifications.
-        
-        Args:
-            user: User instance to update
-            is_active: New active status (True/False)
-            send_notifications: Whether to send notifications
-            reason: Reason for status change
-            
-        Returns:
-            User: Updated user instance
-        """
-        if is_active is None:
-            return user
-        
-        old_status = user.is_active
-        user.is_active = is_active
-        user.save()
-        
-        # Send notifications if status changed
-        if send_notifications and old_status != is_active:
-            from ..utils.notifications import AccountNotifications
-            status_type = "activated" if is_active else "deactivated"
-            AccountNotifications.send_account_status_change(user, status_type, reason)
-        
-        return user

django_cfg/apps/accounts/migrations/0006_remove_twilioresponse_otp_secret_and_more.py

@@ -0,0 +1,46 @@
+# Generated by Django 5.2.6 on 2025-09-20 16:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django_cfg_accounts', '0005_twilioresponse'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='twilioresponse',
+            name='otp_secret',
+        ),
+        migrations.RemoveIndex(
+            model_name='otpsecret',
+            name='django_cfg__recipie_f9f5aa_idx',
+        ),
+        migrations.RemoveField(
+            model_name='customuser',
+            name='phone_verified',
+        ),
+        migrations.RemoveField(
+            model_name='otpsecret',
+            name='channel_type',
+        ),
+        migrations.RemoveField(
+            model_name='otpsecret',
+            name='recipient',
+        ),
+        migrations.AddField(
+            model_name='otpsecret',
+            name='email',
+            field=models.EmailField(db_index=True, default=1, max_length=254),
+            preserve_default=False,
+        ),
+        migrations.AddIndex(
+            model_name='otpsecret',
+            index=models.Index(fields=['email', 'is_used', 'expires_at'], name='django_cfg__email_f595c8_idx'),
+        ),
+        migrations.DeleteModel(
+            name='TwilioResponse',
+        ),
+    ]

django_cfg/apps/accounts/models.py

@@ -71,7 +71,6 @@ class CustomUser(AbstractUser):
     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)
-    phone_verified = models.BooleanField(default=False, help_text="Whether the phone number has been verified")
     position = models.CharField(max_length=100, blank=True)
     avatar = models.ImageField(upload_to=user_avatar_path, blank=True, null=True)
 
@@ -83,12 +82,6 @@ class CustomUser(AbstractUser):
 
     USERNAME_FIELD = "email"
     REQUIRED_FIELDS = ["username"]
-    
-    def get_identifier_for_otp(self, channel='email'):
-        """Get identifier for OTP based on channel."""
-        if channel == 'phone':
-            return self.phone
-        return self.email
 
     def __str__(self):
         return self.email
@@ -135,16 +128,8 @@ class CustomUser(AbstractUser):
 
 class OTPSecret(models.Model):
     """Stores One-Time Passwords for authentication."""
-    
-    CHANNEL_CHOICES = [
-        ('email', 'Email'),
-        ('phone', 'Phone'),
-    ]
 
-    # Unified fields
-    channel_type = models.CharField(max_length=10, choices=CHANNEL_CHOICES, default='email')
-    recipient = models.CharField(max_length=255, db_index=True, blank=True, help_text="Email address or phone number")
-    
+    email = models.EmailField(db_index=True)
     secret = models.CharField(max_length=6)
     created_at = models.DateTimeField(auto_now_add=True)
     expires_at = models.DateTimeField()
@@ -153,34 +138,12 @@ class OTPSecret(models.Model):
     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))
-    
-    @classmethod
-    def create_for_email(cls, email, **kwargs):
-        """Create OTP for email channel."""
-        return cls.objects.create(
-            channel_type='email',
-            recipient=email,
-            secret=cls.generate_otp(),
-            **kwargs
-        )
-    
-    @classmethod
-    def create_for_phone(cls, phone, **kwargs):
-        """Create OTP for phone channel."""
-        return cls.objects.create(
-            channel_type='phone',
-            recipient=phone,
-            secret=cls.generate_otp(),
-            **kwargs
-        )
 
     @property
     def is_valid(self):
@@ -193,13 +156,13 @@ class OTPSecret(models.Model):
         self.save(update_fields=["is_used"])
 
     def __str__(self):
-        return f"OTP for {self.recipient} ({self.channel_type})"
+        return f"OTP for {self.email}"
 
     class Meta:
         app_label = 'django_cfg_accounts'
         ordering = ["-created_at"]
         indexes = [
-            models.Index(fields=["recipient", "channel_type", "is_used", "expires_at"]),
+            models.Index(fields=["email", "is_used", "expires_at"]),
         ]
 
 
@@ -237,86 +200,3 @@ class UserActivity(models.Model):
     
     def __str__(self):
         return f"{self.user.username} - {self.get_activity_type_display()}"
-
-
-class TwilioResponse(models.Model):
-    """Model for storing Twilio API responses and webhook data."""
-    
-    class ResponseType(models.TextChoices):
-        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 ServiceType(models.TextChoices):
-        WHATSAPP = 'whatsapp', 'WhatsApp'
-        SMS = 'sms', 'SMS'
-        VOICE = 'voice', 'Voice'
-        EMAIL = 'email', 'Email'
-        VERIFY = 'verify', 'Verify API'
-    
-    # Response metadata
-    response_type = models.CharField(max_length=20, choices=ResponseType.choices)
-    service_type = models.CharField(max_length=10, choices=ServiceType.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 information
-    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 information
-    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):
-        identifier = self.message_sid or self.verification_sid or f"#{self.id}"
-        return f"{self.get_service_type_display()} {self.get_response_type_display()} - {identifier}"
-    
-    @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/serializers/otp.py

@@ -8,12 +8,12 @@ class OTPSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = OTPSecret
-        fields = ["recipient", "channel_type", "secret"]
+        fields = ["email", "secret"]
         read_only_fields = ["secret"]
 
 
 class OTPRequestSerializer(serializers.Serializer):
-    """Serializer for OTP request supporting both email and phone."""
+    """Serializer for OTP request."""
 
     identifier = serializers.CharField(
         help_text="Email address or phone number for OTP delivery"
@@ -21,38 +21,36 @@ class OTPRequestSerializer(serializers.Serializer):
     channel = serializers.ChoiceField(
         choices=[('email', 'Email'), ('phone', 'Phone')],
         required=False,
-        help_text="Delivery channel - auto-detected if not specified"
+        help_text="Delivery channel: 'email' or 'phone'. Auto-detected if not provided."
     )
     source_url = serializers.URLField(
         required=False,
         allow_blank=True,
-        help_text="Source URL for tracking registration (e.g., https://unrealos.com)",
+        help_text="Source URL for tracking registration (e.g., https://dashboard.unrealon.com)",
     )
 
     def validate_identifier(self, value):
         """Validate identifier format."""
         if not value:
-            raise serializers.ValidationError("Identifier (email or phone) is required.")
+            raise serializers.ValidationError("Identifier is required.")
         
-        # Auto-detect if it's email
+        value = value.strip()
+        if not value:
+            raise serializers.ValidationError("Identifier cannot be empty.")
+            
+        # Auto-detect if it's email or phone
         if '@' in value:
+            # Basic email validation
+            if not value.count('@') == 1:
+                raise serializers.ValidationError("Invalid email format.")
             return value.lower()
-        return value
-    
-    def validate(self, attrs):
-        """Auto-detect channel if not specified."""
-        identifier = attrs.get('identifier')
-        
-        # Auto-detect channel if not specified
-        if not attrs.get('channel'):
-            if '@' in identifier:
-                attrs['channel'] = 'email'
-            elif identifier.startswith('+') or identifier.replace(' ', '').replace('-', '').isdigit():
-                attrs['channel'] = 'phone'
-            else:
-                attrs['channel'] = 'email'  # Default
-        
-        return attrs
+        else:
+            # Assume it's a phone number - basic validation
+            # Remove common phone number characters for validation
+            clean_phone = ''.join(c for c in value if c.isdigit() or c in '+')
+            if len(clean_phone) < 10:
+                raise serializers.ValidationError("Phone number must be at least 10 digits.")
+            return value
 
     def validate_source_url(self, value):
         """Validate source URL format."""
@@ -62,7 +60,7 @@ class OTPRequestSerializer(serializers.Serializer):
 
 
 class OTPVerifySerializer(serializers.Serializer):
-    """Serializer for OTP verification supporting both email and phone."""
+    """Serializer for OTP verification."""
 
     identifier = serializers.CharField(
         help_text="Email address or phone number used for OTP request"
@@ -71,44 +69,42 @@ class OTPVerifySerializer(serializers.Serializer):
     channel = serializers.ChoiceField(
         choices=[('email', 'Email'), ('phone', 'Phone')],
         required=False,
-        help_text="Delivery channel - auto-detected if not specified"
+        help_text="Delivery channel: 'email' or 'phone'. Auto-detected if not provided."
     )
     source_url = serializers.URLField(
         required=False,
         allow_blank=True,
-        help_text="Source URL for tracking login (e.g., https://unrealos.com)",
+        help_text="Source URL for tracking login (e.g., https://dashboard.unrealon.com)",
     )
 
     def validate_identifier(self, value):
         """Validate identifier format."""
         if not value:
-            raise serializers.ValidationError("Identifier (email or phone) is required.")
+            raise serializers.ValidationError("Identifier is required.")
         
-        # Auto-detect if it's email
+        value = value.strip()
+        if not value:
+            raise serializers.ValidationError("Identifier cannot be empty.")
+            
+        # Auto-detect if it's email or phone
         if '@' in value:
+            # Basic email validation
+            if not value.count('@') == 1:
+                raise serializers.ValidationError("Invalid email format.")
             return value.lower()
-        return value
+        else:
+            # Assume it's a phone number - basic validation
+            # Remove common phone number characters for validation
+            clean_phone = ''.join(c for c in value if c.isdigit() or c in '+')
+            if len(clean_phone) < 10:
+                raise serializers.ValidationError("Phone number must be at least 10 digits.")
+            return value
 
     def validate_otp(self, value):
         """Validate OTP format."""
         if not value.isdigit():
             raise serializers.ValidationError("OTP must contain only digits.")
         return value
-    
-    def validate(self, attrs):
-        """Auto-detect channel if not specified."""
-        identifier = attrs.get('identifier')
-        
-        # Auto-detect channel if not specified
-        if not attrs.get('channel'):
-            if '@' in identifier:
-                attrs['channel'] = 'email'
-            elif identifier.startswith('+') or identifier.replace(' ', '').replace('-', '').isdigit():
-                attrs['channel'] = 'phone'
-            else:
-                attrs['channel'] = 'email'  # Default
-        
-        return attrs
 
     def validate_source_url(self, value):
         """Validate source URL format."""
@@ -134,4 +130,4 @@ class OTPRequestResponseSerializer(serializers.Serializer):
 class OTPErrorResponseSerializer(serializers.Serializer):
     """Error response for OTP operations."""
 
-    error = serializers.CharField(help_text="Error message")
+    error = serializers.CharField(help_text="Error message")

django_cfg/apps/accounts/serializers/profile.py

@@ -23,7 +23,6 @@ class UserSerializer(serializers.ModelSerializer):
             "display_username",
             "company",
             "phone",
-            "phone_verified",
             "position",
             "avatar",
             "is_staff",
@@ -35,7 +34,6 @@ class UserSerializer(serializers.ModelSerializer):
         read_only_fields = [
             "id",
             "email",
-            "phone_verified",
             "is_staff",
             "is_superuser",
             "date_joined",