django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/apps/accounts/managers/user_manager.py

@@ -1,299 +0,0 @@
-import logging
-import random
-import re
-import traceback
-from urllib.parse import urlparse
-
-from coolname import generate_slug
-from django.contrib.auth.models import UserManager
-from django.utils import timezone
-
-logger = logging.getLogger(__name__)
-
-
-class UserManager(UserManager):
-    """
-    Custom manager for user statistics and data calculations.
-    """
-
-    def create_user(self, email, password=None, **extra_fields):
-        """
-        Create and save a regular user with the given email and password.
-        """
-        if not email:
-            raise ValueError("The email must be set")
-
-        email = self.normalize_email(email)
-
-        # Generate username if not provided
-        if "username" not in extra_fields:
-            extra_fields["username"] = self._generate_unique_username()
-
-        user = self.model(email=email, **extra_fields)
-        user.set_password(password)
-        user.save(using=self._db)
-        return user
-
-    def create_superuser(self, email, password=None, **extra_fields):
-        """
-        Create a superuser with the given email and password
-        """
-        extra_fields.setdefault("is_staff", True)
-        extra_fields.setdefault("is_superuser", True)
-        extra_fields.setdefault("is_active", True)
-
-        if extra_fields.get("is_staff") is not True:
-            raise ValueError("Superuser must have is_staff=True.")
-        if extra_fields.get("is_superuser") is not True:
-            raise ValueError("Superuser must have is_superuser=True.")
-
-        return self.create_user(email, password, **extra_fields)
-
-    def register_user(self, email, username=None, source_url=None, **extra_fields):
-        """
-        Register a new user with OTP authentication.
-
-        Args:
-            email: User's email address
-            username: Optional username (will be generated if not provided)
-            source_url: Optional source URL for tracking registration
-            **extra_fields: Additional fields for user creation
-
-        Returns:
-            tuple: (user, created) where created is True if user was created
-        """
-        try:
-            # Clean email
-            email = email.strip().lower()
-
-            # Generate username if not provided
-            if not username:
-                username = self._generate_unique_username()
-
-            # Set default values
-            defaults = {
-                "username": username,
-                "is_active": True,
-                "date_joined": timezone.now(),
-                **extra_fields,
-            }
-
-            logger.info(
-                f"Attempting to get_or_create user with email: {email}, username: {username}"
-            )
-
-            # Create or get user using self.model instead of importing CustomUser
-            user, created = self.model.objects.get_or_create(
-                email=email, defaults=defaults
-            )
-
-            # Handle source tracking
-            if source_url:
-                self._link_user_to_source(user, source_url, created)
-
-            logger.info(
-                f"User {'created' if created else 'found'} successfully: {email}"
-            )
-            return user, created
-
-        except Exception as e:
-            logger.error(f"Error in register_user for email {email}: {str(e)}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise
-
-    def _link_user_to_source(self, user, source_url, is_new_user=False):
-        """
-        Link user to a source, creating the source if it doesn't exist.
-
-        Args:
-            user: User instance
-            source_url: Source URL
-            is_new_user: Whether this is a new user registration
-        """
-        try:
-            from django_cfg.apps.accounts.models import RegistrationSource, UserRegistrationSource
-
-            # Get or create source
-            source, source_created = RegistrationSource.objects.get_or_create(
-                url=source_url,
-                defaults={
-                    "name": self._extract_domain_name(source_url),
-                    "is_active": True,
-                },
-            )
-
-            # Check if user is already linked to this source
-            user_source, user_source_created = (
-                UserRegistrationSource.objects.get_or_create(
-                    user=user,
-                    source=source,
-                    defaults={"first_registration": is_new_user},
-                )
-            )
-
-            if user_source_created:
-                logger.info(f"Linked user {user.email} to source {source.url}")
-            else:
-                logger.info(f"User {user.email} already linked to source {source.url}")
-
-        except Exception as e:
-            logger.error(f"Error linking user to source: {e}")
-            # Don't raise exception to avoid breaking user registration
-
-    def _extract_domain_name(self, url):
-        """Extract full hostname from URL including subdomains."""
-        try:
-            hostname = urlparse(url).netloc
-
-            # Remove www. prefix if present (but keep other subdomains)
-            if hostname.startswith("www."):
-                hostname = hostname[4:]
-
-            return hostname
-        except:
-            return url
-
-    def _generate_unique_username(self):
-        """
-        Generate a unique username.
-        """
-        try:
-            # Use self.model instead of importing CustomUser
-            # Try different username generation strategies
-            strategies = [
-                self._generate_coolname_username,
-                self._generate_timestamp_username,
-            ]
-
-            for strategy in strategies:
-                try:
-                    username = strategy()
-                    if (
-                        username
-                        and not self.model.objects.filter(username=username).exists()
-                    ):
-                        return username
-                except Exception as e:
-                    logger.warning(
-                        f"Username generation strategy {strategy.__name__} failed: {e}"
-                    )
-                    continue
-
-            # Final fallback
-            return f"user{timezone.now().strftime('%m%d%H%M%S')}"
-        except Exception as e:
-            logger.error(f"Error in _generate_unique_username: {str(e)}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            # Return a simple fallback
-            return f"user{timezone.now().strftime('%m%d%H%M%S')}"
-
-    def _generate_coolname_username(self):
-        """Generate username using coolname library."""
-        try:
-
-            # Generate and clean
-            raw_username = generate_slug()
-            username = re.sub(r"[^a-zA-Z0-9_]", "", raw_username)
-
-            # Shorten if too long
-            if len(username) > 12:
-                username = username[:8] + str(random.randint(10, 99))
-
-            return username if len(username) <= 12 else None
-
-        except ImportError:
-            logger.warning(
-                "coolname library not available, skipping coolname username generation"
-            )
-            return None
-        except Exception as e:
-            logger.warning(f"Error generating coolname username: {e}")
-            return None
-
-    def _generate_timestamp_username(self):
-        """Generate username with timestamp."""
-        try:
-            timestamp = timezone.now().strftime("%m%d%H%M")
-            return f"user{timestamp}"
-        except Exception as e:
-            logger.warning(f"Error generating timestamp username: {e}")
-            return None
-
-    def get_unanswered_messages_count(self, user) -> int:
-        """
-        Get the count of unanswered messages for the user.
-        Args:
-            user: User instance to get count for
-        Returns:
-            int: Count of unanswered messages
-        """
-        from django_cfg.modules.base import BaseCfgModule
-
-        # Get config and check if support app is enabled
-        config = BaseCfgModule.get_config()
-        if not config or not getattr(config, 'enable_support', False):
-            return 0
-
-        try:
-            from django_cfg.apps.support.models import Ticket
-            count = Ticket.objects.get_unanswered_messages_count(user)
-            return count
-        except (ImportError, Exception):
-            # If support app is not installed or any error occurs, return 0
-            return 0
-
-    def get_full_name(self, user) -> str:
-        """
-        Get user's full name.
-        Args:
-            user: User instance
-        Returns:
-            str: User's full name
-        """
-        if user.first_name and user.last_name:
-            return f"{user.first_name} {user.last_name}"
-        elif user.first_name:
-            return user.first_name
-        elif user.last_name:
-            return user.last_name
-        return user.email
-
-    def get_initials(self, user) -> str:
-        """
-        Get user's initials for avatar fallback.
-        Args:
-            user: User instance
-        Returns:
-            str: User's initials
-        """
-        if user.first_name and user.last_name:
-            return f"{user.first_name[0]}{user.last_name[0]}".upper()
-        elif user.first_name:
-            return user.first_name[0].upper()
-        elif user.last_name:
-            return user.last_name[0].upper()
-        return user.email[0].upper()
-
-    def get_display_username(self, user) -> str:
-        """
-        Get formatted username for display.
-        Args:
-            user: User instance
-        Returns:
-            str: Formatted display username
-        """
-        if user.username:
-            # Remove special characters and format nicely
-            clean_username = (
-                user.username.replace("_", " ").replace("-", " ").replace(".", " ")
-            )
-            # Capitalize first letter of each word
-            formatted = " ".join(word.capitalize() for word in clean_username.split())
-            return formatted
-        elif user.first_name and user.last_name:
-            return f"{user.first_name} {user.last_name}"
-        elif user.first_name:
-            return user.first_name
-        elif user.last_name:
-            return user.last_name
-        return user.email.split("@")[0].capitalize()

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

@@ -1,119 +0,0 @@
-# Generated by Django 5.2.5 on 2025-09-07 05:09
-
-import django.contrib.auth.validators
-import django.db.models.deletion
-import django.utils.timezone
-from django.conf import settings
-from django.db import migrations, models
-
-import django_cfg.apps.accounts.managers.user_manager
-import django_cfg.apps.accounts.models
-
-
-class Migration(migrations.Migration):
-
-    initial = True
-
-    dependencies = [
-        ('auth', '0012_alter_user_first_name_max_length'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='RegistrationSource',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('url', models.URLField(help_text='Source URL (e.g., https://unrealon.com)', unique=True)),
-                ('name', models.CharField(blank=True, help_text='Display name for the source', max_length=100)),
-                ('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)),
-            ],
-            options={
-                'verbose_name': 'Registration Source',
-                'verbose_name_plural': 'Registration Sources',
-                'ordering': ['-created_at'],
-            },
-        ),
-        migrations.CreateModel(
-            name='CustomUser',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('password', models.CharField(max_length=128, verbose_name='password')),
-                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
-                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
-                ('username', models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username')),
-                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
-                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
-                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
-                ('email', models.EmailField(max_length=254, unique=True)),
-                ('first_name', models.CharField(blank=True, max_length=50)),
-                ('last_name', models.CharField(blank=True, max_length=50)),
-                ('company', models.CharField(blank=True, max_length=100)),
-                ('phone', models.CharField(blank=True, max_length=20)),
-                ('position', models.CharField(blank=True, max_length=100)),
-                ('avatar', models.ImageField(blank=True, null=True, upload_to=django_cfg.apps.accounts.models.user_avatar_path)),
-                ('updated_at', models.DateTimeField(auto_now=True)),
-                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
-                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
-            ],
-            options={
-                'verbose_name': 'User',
-                'verbose_name_plural': 'Users',
-            },
-            managers=[
-                ('objects', django_cfg.apps.accounts.managers.user_manager.UserManager()),
-            ],
-        ),
-        migrations.CreateModel(
-            name='OTPSecret',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('email', models.EmailField(db_index=True, max_length=254)),
-                ('secret', models.CharField(max_length=6)),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('expires_at', models.DateTimeField()),
-                ('is_used', models.BooleanField(default=False)),
-            ],
-            options={
-                'ordering': ['-created_at'],
-                'indexes': [models.Index(fields=['email', 'is_used', 'expires_at'], name='django_cfg__email_f595c8_idx')],
-            },
-        ),
-        migrations.CreateModel(
-            name='UserActivity',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('activity_type', models.CharField(choices=[('login', 'Login'), ('logout', 'Logout'), ('otp_requested', 'OTP Requested'), ('otp_verified', 'OTP Verified'), ('profile_updated', 'Profile Updated'), ('registration', 'Registration')], max_length=20)),
-                ('description', models.TextField(blank=True)),
-                ('ip_address', models.GenericIPAddressField(blank=True, null=True)),
-                ('user_agent', models.TextField(blank=True)),
-                ('object_id', models.PositiveIntegerField(blank=True, null=True)),
-                ('object_type', models.CharField(blank=True, max_length=50)),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='activities', to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'verbose_name': 'User Activity',
-                'verbose_name_plural': 'User Activities',
-                'ordering': ['-created_at'],
-            },
-        ),
-        migrations.CreateModel(
-            name='UserRegistrationSource',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('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)),
-                ('source', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_registration_sources', to='django_cfg_accounts.registrationsource')),
-                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_registration_sources', to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'verbose_name': 'User Registration Source',
-                'verbose_name_plural': 'User Registration Sources',
-                'ordering': ['-registration_date'],
-                'unique_together': {('user', 'source')},
-            },
-        ),
-    ]

django_cfg/apps/accounts/models/__init__.py

@@ -1,67 +0,0 @@
-"""
-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
-# Import activity models
-from .activity import UserActivity
-
-# Import authentication models
-from .auth import OTPSecret
-from .base import user_avatar_path
-
-# Import choices
-from .choices import (
-    ActivityType,
-    TwilioResponseType,
-    TwilioServiceType,
-)
-
-# Import integration models
-from .integrations import TwilioResponse
-
-# Import registration models
-from .registration import (
-    RegistrationSource,
-    UserRegistrationSource,
-)
-
-# Import user models
-from .user import CustomUser
-
-# 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/choices.py

@@ -1,32 +0,0 @@
-"""
-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

@@ -1,75 +0,0 @@
-"""
-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/user.py

@@ -1,81 +0,0 @@
-"""
-User model and related functionality.
-"""
-
-from typing import List, Optional
-
-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"