django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/apps/business/accounts/managers/user_manager.py

@@ -0,0 +1,299 @@
+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.business.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.business.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/business/accounts/migrations/0001_initial.py

@@ -0,0 +1,119 @@
+# 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.business.accounts.managers.user_manager
+import django_cfg.apps.business.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.business.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.business.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/business/accounts/services/otp_service.py

@@ -0,0 +1,194 @@
+import logging
+import traceback
+from typing import Optional
+
+from django.db import transaction
+from django.utils import timezone
+
+from django_cfg.core.utils import get_otp_url
+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."""
+
+    # Expose get_otp_url as a static method for backward compatibility
+    _get_otp_url = staticmethod(get_otp_url)
+
+    @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