django-cfg 1.4.48__py3-none-any.whl → 1.5.7__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/services/otp_service.py

@@ -1,205 +0,0 @@
-import logging
-import traceback
-from typing import Optional
-
-from django.db import transaction
-from django.utils import timezone
-
-from django_cfg.modules.django_telegram import DjangoTelegram
-
-from ..models import CustomUser, OTPSecret
-from ..signals import notify_failed_otp_attempt
-from ..utils.notifications import AccountNotifications
-
-logger = logging.getLogger(__name__)
-
-
-class OTPService:
-    """Simple OTP service for authentication."""
-
-    @staticmethod
-    def _get_otp_url(otp_code: str) -> str:
-        """Get OTP verification URL from configuration."""
-        try:
-            from django_cfg.core.state import get_current_config
-            config = get_current_config()
-            if config and hasattr(config, 'get_otp_url'):
-                return config.get_otp_url(otp_code)
-            else:
-                # Fallback URL if config is not available
-                return f"#otp-{otp_code}"
-        except Exception as e:
-            logger.warning(f"Could not generate OTP URL: {e}")
-            return f"#otp-{otp_code}"
-
-    @staticmethod
-    @transaction.atomic
-    def request_otp(email: str, source_url: Optional[str] = None) -> tuple[bool, str]:
-        """Generate and send OTP to email. Returns (success, error_type)."""
-        cleaned_email = email.strip().lower()
-        if not cleaned_email:
-            return False, "invalid_email"
-
-        # Find or create user using the manager's register_user method
-        try:
-            logger.info(f"Attempting to register user for email: {cleaned_email}")
-            user, created = CustomUser.objects.register_user(
-                cleaned_email, source_url=source_url
-            )
-
-            if created:
-                logger.info(f"Created new user: {cleaned_email}")
-
-        except Exception as e:
-            logger.error(
-                f"Error creating/finding user for email {cleaned_email}: {str(e)}"
-            )
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            return False, "user_creation_failed"
-
-        # Check for existing active OTP
-        existing_otp = OTPSecret.objects.filter(
-            email=cleaned_email, is_used=False, expires_at__gt=timezone.now()
-        ).first()
-
-        if existing_otp and existing_otp.is_valid:
-            otp_code = existing_otp.secret
-            logger.info(f"Reusing active OTP for {cleaned_email}")
-        else:
-            # Invalidate old OTPs
-            OTPSecret.objects.filter(email=cleaned_email, is_used=False).update(
-                is_used=True
-            )
-
-            # Generate new OTP
-            otp_code = OTPSecret.generate_otp()
-            OTPSecret.objects.create(email=cleaned_email, secret=otp_code)
-            logger.info(f"Generated new OTP for {cleaned_email}")
-
-        # Send email using AccountNotifications
-        try:
-            # Send OTP notification
-            AccountNotifications.send_otp_notification(
-                user=user,
-                otp_code=otp_code,
-                is_new_user=created,
-                source_url=source_url,
-                channel='email',
-                send_email=True,
-                send_telegram=False  # Telegram notification sent separately below
-            )
-
-            # Send welcome email for new users
-            if created:
-                AccountNotifications.send_welcome_email(
-                    user=user,
-                    send_email=True,
-                    send_telegram=False
-                )
-
-            # Send Telegram notification for OTP request
-            try:
-
-
-                # Prepare notification data
-                notification_data = {
-                    "Email": cleaned_email,
-                    "User Type": "New User" if created else "Existing User",
-                    "OTP Code": otp_code,
-                    "Source URL": source_url or "Direct",
-                    "Timestamp": timezone.now().strftime("%Y-%m-%d %H:%M:%S UTC")
-                }
-
-                if created:
-                    DjangoTelegram.send_success("New User OTP Request", notification_data)
-                else:
-                    DjangoTelegram.send_info("OTP Login Request", notification_data)
-
-                logger.info(f"Telegram OTP notification sent for {cleaned_email}")
-
-            except ImportError:
-                logger.warning("django_cfg DjangoTelegram not available for OTP notifications")
-            except Exception as telegram_error:
-                logger.error(f"Failed to send Telegram OTP notification: {telegram_error}")
-                # Don't fail the OTP process if Telegram fails
-
-            return True, "success"
-        except Exception as e:
-            logger.error(f"Failed to send OTP email: {e}")
-            return False, "email_send_failed"
-
-    @staticmethod
-    def verify_otp(
-        email: str, otp_code: str, source_url: Optional[str] = None
-    ) -> Optional[CustomUser]:
-        """Verify OTP and return user if valid."""
-        if not email or not otp_code:
-            return None
-
-        cleaned_email = email.strip().lower()
-        cleaned_otp = otp_code.strip()
-
-        if not cleaned_email or not cleaned_otp:
-            return None
-
-        try:
-            otp_secret = OTPSecret.objects.filter(
-                email=cleaned_email,
-                secret=cleaned_otp,
-                is_used=False,
-                expires_at__gt=timezone.now(),
-            ).first()
-
-            if not otp_secret or not otp_secret.is_valid:
-                logger.warning(f"Invalid OTP for {cleaned_email}")
-
-                # Send Telegram notification for failed OTP attempt
-                try:
-                    notify_failed_otp_attempt(cleaned_email, reason="Invalid or expired OTP")
-                except Exception as e:
-                    logger.error(f"Failed to send failed OTP notification: {e}")
-
-                return None
-
-            # Mark OTP as used
-            otp_secret.mark_used()
-
-            # Get user
-            try:
-                user = CustomUser.objects.get(email=cleaned_email)
-
-                # Link user to source if provided (for existing users logging in from new sources)
-                if source_url:
-                    CustomUser.objects._link_user_to_source(
-                        user, source_url, is_new_user=False
-                    )
-
-                # Send Telegram notification for successful OTP verification
-                try:
-
-                    verification_data = {
-                        "Email": cleaned_email,
-                        "Username": user.username,
-                        "Source URL": source_url or "Direct",
-                        "Login Time": timezone.now().strftime("%Y-%m-%d %H:%M:%S UTC"),
-                        "User ID": user.id
-                    }
-
-                    DjangoTelegram.send_success("Successful OTP Login", verification_data)
-                    logger.info(f"Telegram OTP verification notification sent for {cleaned_email}")
-
-                except ImportError:
-                    logger.warning("django_cfg DjangoTelegram not available for OTP verification notifications")
-                except Exception as telegram_error:
-                    logger.error(f"Failed to send Telegram OTP verification notification: {telegram_error}")
-
-                logger.info(f"OTP verified for {cleaned_email}")
-                return user
-            except CustomUser.DoesNotExist:
-                # User was deleted after OTP was sent
-                logger.warning(f"User was deleted after OTP was sent: {cleaned_email}")
-                return None
-
-        except Exception as e:
-            logger.error(f"Error verifying OTP: {e}")
-            return None