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

django_cfg/apps/accounts/serializers/__init__.py

@@ -1,20 +0,0 @@
-from .otp import (
-    OTPErrorResponseSerializer,
-    OTPRequestResponseSerializer,
-    OTPRequestSerializer,
-    OTPSerializer,
-    OTPVerifyResponseSerializer,
-    OTPVerifySerializer,
-)
-from .profile import UserProfileUpdateSerializer, UserSerializer
-
-__all__ = [
-    'UserSerializer',
-    'UserProfileUpdateSerializer',
-    'OTPSerializer',
-    'OTPRequestSerializer',
-    'OTPVerifySerializer',
-    'OTPRequestResponseSerializer',
-    'OTPVerifyResponseSerializer',
-    'OTPErrorResponseSerializer',
-]

django_cfg/apps/accounts/serializers/otp.py

@@ -1,134 +0,0 @@
-from rest_framework import serializers
-
-from ..models import OTPSecret
-from .profile import UserSerializer
-
-
-class OTPSerializer(serializers.ModelSerializer):
-    """Serializer for OTP operations."""
-
-    class Meta:
-        model = OTPSecret
-        fields = ["email", "secret"]
-        read_only_fields = ["secret"]
-
-
-class OTPRequestSerializer(serializers.Serializer):
-    """Serializer for OTP request."""
-
-    identifier = serializers.CharField(
-        help_text="Email address or phone number for OTP delivery"
-    )
-    channel = serializers.ChoiceField(
-        choices=[('email', 'Email'), ('phone', 'Phone')],
-        required=False,
-        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://dashboard.unrealon.com)",
-    )
-
-    def validate_identifier(self, value):
-        """Validate identifier format."""
-        if not value:
-            raise serializers.ValidationError("Identifier is required.")
-
-        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()
-        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."""
-        if not value or not value.strip():
-            return None
-        return value
-
-
-class OTPVerifySerializer(serializers.Serializer):
-    """Serializer for OTP verification."""
-
-    identifier = serializers.CharField(
-        help_text="Email address or phone number used for OTP request"
-    )
-    otp = serializers.CharField(max_length=6, min_length=6)
-    channel = serializers.ChoiceField(
-        choices=[('email', 'Email'), ('phone', 'Phone')],
-        required=False,
-        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://dashboard.unrealon.com)",
-    )
-
-    def validate_identifier(self, value):
-        """Validate identifier format."""
-        if not value:
-            raise serializers.ValidationError("Identifier is required.")
-
-        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()
-        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_source_url(self, value):
-        """Validate source URL format."""
-        if not value or not value.strip():
-            return None
-        return value
-
-
-class OTPVerifyResponseSerializer(serializers.Serializer):
-    """OTP verification response."""
-
-    refresh = serializers.CharField(help_text="JWT refresh token")
-    access = serializers.CharField(help_text="JWT access token")
-    user = UserSerializer(help_text="User information")
-
-
-class OTPRequestResponseSerializer(serializers.Serializer):
-    """OTP request response."""
-
-    message = serializers.CharField(help_text="Success message")
-
-
-class OTPErrorResponseSerializer(serializers.Serializer):
-    """Error response for OTP operations."""
-
-    error = serializers.CharField(help_text="Error message")

django_cfg/apps/accounts/serializers/profile.py

@@ -1,169 +0,0 @@
-from drf_spectacular.utils import extend_schema_field
-from rest_framework import serializers
-
-from ..models import CustomUser, RegistrationSource, UserRegistrationSource
-
-
-class UserSerializer(serializers.ModelSerializer):
-    """Serializer for user details."""
-
-    full_name = serializers.ReadOnlyField()
-    initials = serializers.ReadOnlyField()
-    display_username = serializers.ReadOnlyField()
-    avatar = serializers.SerializerMethodField()
-
-    class Meta:
-        model = CustomUser
-        fields = [
-            "id",
-            "email",
-            "first_name",
-            "last_name",
-            "full_name",
-            "initials",
-            "display_username",
-            "company",
-            "phone",
-            "position",
-            "avatar",
-            "is_staff",
-            "is_superuser",
-            "date_joined",
-            "last_login",
-            "unanswered_messages_count",
-        ]
-        read_only_fields = [
-            "id",
-            "email",
-            "is_staff",
-            "is_superuser",
-            "date_joined",
-            "last_login",
-            "unanswered_messages_count",
-        ]
-
-    @extend_schema_field(serializers.URLField(allow_null=True))
-    def get_avatar(self, obj):
-        """Return full URL for avatar or None."""
-        if obj.avatar:
-            request = self.context.get('request')
-            if request is not None:
-                return request.build_absolute_uri(obj.avatar.url)
-            return obj.avatar.url
-        return None
-
-
-
-class UserProfileUpdateSerializer(serializers.ModelSerializer):
-    """Serializer for updating user profile."""
-
-    class Meta:
-        model = CustomUser
-        fields = ["first_name", "last_name", "company", "phone", "position"]
-
-    def validate_first_name(self, value):
-        """Validate first name."""
-        if value and len(value.strip()) < 2:
-            raise serializers.ValidationError(
-                "First name must be at least 2 characters long."
-            )
-        return value.strip() if value else value
-
-    def validate_last_name(self, value):
-        """Validate last name."""
-        if value and len(value.strip()) < 2:
-            raise serializers.ValidationError(
-                "Last name must be at least 2 characters long."
-            )
-        return value.strip() if value else value
-
-    def validate_phone(self, value):
-        """Validate phone number."""
-        if (
-            value
-            and not value.replace("+", "")
-            .replace("-", "")
-            .replace(" ", "")
-            .replace("(", "")
-            .replace(")", "")
-            .isdigit()
-        ):
-            raise serializers.ValidationError("Please enter a valid phone number.")
-        return value
-
-
-class AvatarUploadSerializer(serializers.ModelSerializer):
-    """Serializer for avatar upload only."""
-
-    class Meta:
-        model = CustomUser
-        fields = ["avatar"]
-
-    def validate_avatar(self, value):
-        """Validate avatar image."""
-        if value:
-            # Check file size (max 5MB)
-            if value.size > 5 * 1024 * 1024:
-                raise serializers.ValidationError(
-                    "Avatar file size must be less than 5MB."
-                )
-
-            # Check file type
-            allowed_types = ["image/jpeg", "image/png", "image/gif", "image/webp"]
-            if (
-                hasattr(value, "content_type")
-                and value.content_type not in allowed_types
-            ):
-                raise serializers.ValidationError(
-                    "Avatar must be a valid image file (JPEG, PNG, GIF, or WebP)."
-                )
-
-        return value
-
-
-class RegistrationSourceSerializer(serializers.ModelSerializer):
-    """Serializer for RegistrationSource model."""
-
-    class Meta:
-        model = RegistrationSource
-        fields = [
-            "id",
-            "url",
-            "name",
-            "description",
-            "is_active",
-            "created_at",
-            "updated_at",
-        ]
-        read_only_fields = ["id", "created_at", "updated_at"]
-
-
-class UserRegistrationSourceSerializer(serializers.ModelSerializer):
-    """Serializer for UserRegistrationSource model."""
-    source = RegistrationSourceSerializer(read_only=True)
-
-    class Meta:
-        model = UserRegistrationSource
-        fields = ["id", "user", "source", "first_registration", "registration_date"]
-        read_only_fields = ["id", "registration_date"]
-
-
-class UserWithSourcesSerializer(UserSerializer):
-    """Extended user serializer with sources information."""
-    sources = serializers.SerializerMethodField()
-    primary_source = serializers.SerializerMethodField()
-
-    class Meta(UserSerializer.Meta):
-        fields = UserSerializer.Meta.fields + ['sources', 'primary_source']
-
-    def get_sources(self, obj):
-        """Get all sources for the user."""
-        user_sources = UserRegistrationSource.objects.filter(user=obj).select_related('source')
-        return UserRegistrationSourceSerializer(user_sources, many=True).data
-
-    def get_primary_source(self, obj):
-        """Get the primary source for the user."""
-        primary_source = obj.primary_source
-        if primary_source:
-            return RegistrationSourceSerializer(primary_source).data
-        return None

django_cfg/apps/accounts/serializers/webhook.py

@@ -1,94 +0,0 @@
-"""
-Twilio Webhook Serializers
-
-Serializers for validating and processing Twilio webhook data.
-"""
-
-from rest_framework import serializers
-
-
-class TwilioWebhookSerializer(serializers.Serializer):
-    """
-    Serializer for Twilio webhook data.
-    
-    This handles both message status webhooks and verification webhooks
-    from Twilio. The fields are optional because different webhook types
-    send different data.
-    """
-
-    # Message-related fields (SMS/WhatsApp)
-    MessageSid = serializers.CharField(required=False, help_text="Twilio Message SID")
-    MessageStatus = serializers.CharField(required=False, help_text="Message status (sent, delivered, failed, etc.)")
-    To = serializers.CharField(required=False, help_text="Recipient phone number")
-    From = serializers.CharField(required=False, help_text="Sender phone number")
-    Body = serializers.CharField(required=False, help_text="Message body")
-
-    # Error fields
-    ErrorCode = serializers.CharField(required=False, help_text="Twilio error code")
-    ErrorMessage = serializers.CharField(required=False, help_text="Error message description")
-
-    # Pricing fields
-    Price = serializers.DecimalField(max_digits=10, decimal_places=6, required=False, help_text="Message price")
-    PriceUnit = serializers.CharField(required=False, help_text="Currency code")
-
-    # Verification-related fields (Verify API)
-    VerificationSid = serializers.CharField(required=False, help_text="Twilio Verification SID")
-    VerificationStatus = serializers.CharField(required=False, help_text="Verification status (approved, canceled, etc.)")
-    Channel = serializers.CharField(required=False, help_text="Verification channel (sms, whatsapp, call)")
-
-    # Timestamp fields
-    DateCreated = serializers.DateTimeField(required=False, help_text="When the message was created")
-    DateSent = serializers.DateTimeField(required=False, help_text="When the message was sent")
-    DateUpdated = serializers.DateTimeField(required=False, help_text="When the status was last updated")
-
-    # Account information
-    AccountSid = serializers.CharField(required=False, help_text="Twilio Account SID")
-
-    # Additional fields that might be present
-    Direction = serializers.CharField(required=False, help_text="Message direction (inbound/outbound)")
-    ApiVersion = serializers.CharField(required=False, help_text="Twilio API version")
-
-    # Alternative field names (some webhooks use different casing)
-    message_sid = serializers.CharField(required=False, help_text="Alternative field name for MessageSid")
-    message_status = serializers.CharField(required=False, help_text="Alternative field name for MessageStatus")
-    verification_sid = serializers.CharField(required=False, help_text="Alternative field name for VerificationSid")
-    verification_status = serializers.CharField(required=False, help_text="Alternative field name for VerificationStatus")
-
-    def validate(self, data):
-        """
-        Ensure that we have at least one of the required identifiers.
-        """
-        message_sid = data.get('MessageSid') or data.get('message_sid')
-        verification_sid = data.get('VerificationSid') or data.get('verification_sid')
-
-        if not message_sid and not verification_sid:
-            raise serializers.ValidationError(
-                "Either MessageSid or VerificationSid must be provided"
-            )
-
-        return data
-
-    def to_internal_value(self, data):
-        """
-        Convert the webhook data to internal format.
-        
-        This handles the fact that Twilio webhooks are sent as form data,
-        not JSON, so we need to be flexible about the input format.
-        """
-        if hasattr(data, 'items'):
-            # Convert QueryDict or dict to regular dict
-            data = dict(data.items()) if hasattr(data, 'items') else data
-
-        return super().to_internal_value(data)
-
-
-class TwilioWebhookResponseSerializer(serializers.Serializer):
-    """Response serializer for webhook endpoints."""
-    status = serializers.CharField(help_text="Processing status")
-    message = serializers.CharField(required=False, help_text="Optional message")
-
-
-class TwilioWebhookErrorSerializer(serializers.Serializer):
-    """Error response serializer for webhook endpoints."""
-    error = serializers.CharField(help_text="Error description")
-    details = serializers.DictField(required=False, help_text="Additional error details")

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