django-cfg 1.2.31__py3-none-any.whl → 1.3.3__py3-none-any.whl

django_cfg/apps/payments/views/serializers/balances.py

@@ -0,0 +1,300 @@
+"""
+Balance serializers for the Universal Payment System v2.0.
+
+DRF serializers for balance and transaction operations with service integration.
+"""
+
+from rest_framework import serializers
+from decimal import Decimal
+from typing import Dict, Any
+from django.contrib.auth import get_user_model
+
+from ...models import UserBalance, Transaction
+from ...services import get_balance_service, BalanceUpdateRequest
+from django_cfg.modules.django_logger import get_logger
+
+User = get_user_model()
+logger = get_logger("balance_serializers")
+
+
+class UserBalanceSerializer(serializers.ModelSerializer):
+    """
+    User balance serializer with computed fields.
+    
+    Provides balance information with display helpers.
+    """
+    
+    user = serializers.StringRelatedField(read_only=True)
+    balance_display = serializers.CharField(source='balance_display', read_only=True)
+    is_empty = serializers.BooleanField(source='is_empty', read_only=True)
+    has_transactions = serializers.BooleanField(source='has_transactions', read_only=True)
+    
+    class Meta:
+        model = UserBalance
+        fields = [
+            'user',
+            'balance_usd',
+            'balance_display',
+            'is_empty',
+            'has_transactions',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class TransactionSerializer(serializers.ModelSerializer):
+    """
+    Transaction serializer with full details.
+    
+    Used for transaction history and details.
+    """
+    
+    user = serializers.StringRelatedField(read_only=True)
+    amount_display = serializers.CharField(source='amount_display', read_only=True)
+    type_color = serializers.CharField(source='type_color', read_only=True)
+    is_credit = serializers.BooleanField(source='is_credit', read_only=True)
+    is_debit = serializers.BooleanField(source='is_debit', read_only=True)
+    
+    class Meta:
+        model = Transaction
+        fields = [
+            'id',
+            'user',
+            'amount',
+            'amount_display',
+            'transaction_type',
+            'type_color',
+            'description',
+            'payment_id',
+            'metadata',
+            'is_credit',
+            'is_debit',
+            'created_at',
+        ]
+        read_only_fields = fields
+
+
+class BalanceUpdateSerializer(serializers.Serializer):
+    """
+    Balance update serializer with service integration.
+    
+    Validates and processes balance updates through BalanceService.
+    """
+    
+    amount = serializers.FloatField(
+        help_text="Amount to add (positive) or subtract (negative)"
+    )
+    transaction_type = serializers.ChoiceField(
+        choices=[
+            ('deposit', 'Deposit'),
+            ('withdrawal', 'Withdrawal'),
+            ('payment', 'Payment'),
+            ('refund', 'Refund'),
+            ('fee', 'Fee'),
+            ('bonus', 'Bonus'),
+            ('adjustment', 'Adjustment'),
+        ],
+        help_text="Type of transaction"
+    )
+    description = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        max_length=500,
+        help_text="Transaction description"
+    )
+    payment_id = serializers.UUIDField(
+        required=False,
+        allow_null=True,
+        help_text="Related payment ID"
+    )
+    metadata = serializers.JSONField(
+        required=False,
+        default=dict,
+        help_text="Additional metadata"
+    )
+    
+    def validate_amount(self, value: float) -> float:
+        """Validate amount is not zero."""
+        if value == 0:
+            raise serializers.ValidationError("Amount cannot be zero")
+        return value
+    
+    def validate(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate balance update data."""
+        try:
+            # Get user from context
+            user_id = self.context.get('user_pk') or self.context['request'].user.id
+            
+            # Create Pydantic request for validation
+            request = BalanceUpdateRequest(
+                user_id=user_id,
+                **attrs
+            )
+            
+            # Store validated request for save method
+            self._validated_request = request
+            return attrs
+            
+        except Exception as e:
+            logger.error(f"Balance update validation failed: {e}")
+            raise serializers.ValidationError(f"Invalid balance update data: {e}")
+    
+    def save(self) -> Dict[str, Any]:
+        """Update balance using BalanceService."""
+        try:
+            balance_service = get_balance_service()
+            result = balance_service.update_balance(self._validated_request)
+            
+            if result.success:
+                logger.info(f"Balance updated successfully", extra={
+                    'user_id': self._validated_request.user_id,
+                    'amount': self._validated_request.amount,
+                    'transaction_id': result.transaction_id
+                })
+                
+                return {
+                    'success': True,
+                    'message': result.message,
+                    'balance': {
+                        'user_id': result.user_id,
+                        'balance_usd': result.balance_usd,
+                        'transaction_id': result.transaction_id,
+                        'transaction_amount': result.transaction_amount,
+                        'transaction_type': result.transaction_type,
+                    }
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Balance update error: {e}")
+            return {
+                'success': False,
+                'error': f"Balance update failed: {e}",
+                'error_code': 'balance_update_error'
+            }
+
+
+class FundsTransferSerializer(serializers.Serializer):
+    """
+    Funds transfer serializer for transferring between users.
+    
+    Handles user-to-user fund transfers through BalanceService.
+    """
+    
+    to_user_id = serializers.IntegerField(
+        min_value=1,
+        help_text="Destination user ID"
+    )
+    amount = serializers.FloatField(
+        min_value=0.01,
+        help_text="Amount to transfer (must be positive)"
+    )
+    description = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        max_length=500,
+        help_text="Transfer description"
+    )
+    
+    def validate_to_user_id(self, value: int) -> int:
+        """Validate destination user exists."""
+        if not User.objects.filter(id=value).exists():
+            raise serializers.ValidationError(f"User {value} not found")
+        return value
+    
+    def validate(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate transfer data."""
+        from_user_id = self.context['request'].user.id
+        to_user_id = attrs['to_user_id']
+        
+        if from_user_id == to_user_id:
+            raise serializers.ValidationError("Cannot transfer to yourself")
+        
+        return attrs
+    
+    def save(self) -> Dict[str, Any]:
+        """Execute transfer using BalanceService."""
+        try:
+            from_user_id = self.context['request'].user.id
+            to_user_id = self.validated_data['to_user_id']
+            amount = self.validated_data['amount']
+            description = self.validated_data.get('description')
+            
+            balance_service = get_balance_service()
+            result = balance_service.transfer_funds(
+                from_user_id=from_user_id,
+                to_user_id=to_user_id,
+                amount=amount,
+                description=description
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'message': result.message,
+                    'transfer': result.data
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Funds transfer error: {e}")
+            return {
+                'success': False,
+                'error': f"Transfer failed: {e}",
+                'error_code': 'transfer_error'
+            }
+
+
+class BalanceStatsSerializer(serializers.Serializer):
+    """
+    Balance statistics serializer.
+    
+    Used for balance analytics and reporting.
+    """
+    
+    days = serializers.IntegerField(
+        default=30,
+        min_value=1,
+        max_value=365,
+        help_text="Number of days to analyze"
+    )
+    
+    def save(self) -> Dict[str, Any]:
+        """Get balance statistics using BalanceService."""
+        try:
+            balance_service = get_balance_service()
+            result = balance_service.get_balance_stats(
+                days=self.validated_data['days']
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'stats': result.data,
+                    'message': result.message
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Balance stats error: {e}")
+            return {
+                'success': False,
+                'error': f"Stats generation failed: {e}",
+                'error_code': 'stats_error'
+            }

django_cfg/apps/payments/views/serializers/currencies.py

@@ -0,0 +1,335 @@
+"""
+Currency serializers for the Universal Payment System v2.0.
+
+DRF serializers for currency operations with service integration.
+"""
+
+from rest_framework import serializers
+from typing import Dict, Any
+
+from ...models import Currency, Network, ProviderCurrency
+from ...services import get_currency_service
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("currency_serializers")
+
+
+class CurrencySerializer(serializers.ModelSerializer):
+    """
+    Complete currency serializer with full details.
+    
+    Used for currency information and management.
+    """
+    
+    type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
+    is_crypto = serializers.BooleanField(source='is_crypto', read_only=True)
+    is_fiat = serializers.BooleanField(source='is_fiat', read_only=True)
+    is_stable = serializers.BooleanField(source='is_stable', read_only=True)
+    
+    class Meta:
+        model = Currency
+        fields = [
+            'id',
+            'code',
+            'name',
+            'symbol',
+            'currency_type',
+            'type_display',
+            'decimals',
+            'is_active',
+            'is_crypto',
+            'is_fiat',
+            'is_stable',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class CurrencyListSerializer(serializers.ModelSerializer):
+    """
+    Lightweight currency serializer for lists.
+    
+    Optimized for currency selection and lists.
+    """
+    
+    type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
+    
+    class Meta:
+        model = Currency
+        fields = [
+            'id',
+            'code',
+            'name',
+            'symbol',
+            'currency_type',
+            'type_display',
+            'is_active',
+        ]
+        read_only_fields = fields
+
+
+class NetworkSerializer(serializers.ModelSerializer):
+    """
+    Network serializer for blockchain networks.
+    
+    Used for network information and selection.
+    """
+    
+    currency = CurrencyListSerializer(read_only=True)
+    
+    class Meta:
+        model = Network
+        fields = [
+            'id',
+            'currency',
+            'name',
+            'code',
+            'is_active',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class ProviderCurrencySerializer(serializers.ModelSerializer):
+    """
+    Provider currency serializer for provider-specific currency info.
+    
+    Used for provider currency management and rates.
+    """
+    
+    currency = CurrencyListSerializer(read_only=True)
+    network = NetworkSerializer(read_only=True)
+    
+    class Meta:
+        model = ProviderCurrency
+        fields = [
+            'id',
+            'currency',
+            'network',
+            'provider',
+            'provider_currency_code',
+            'min_amount',
+            'max_amount',
+            'fee_percentage',
+            'is_active',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class CurrencyConversionSerializer(serializers.Serializer):
+    """
+    Currency conversion serializer with service integration.
+    
+    Handles currency conversion requests through CurrencyService.
+    """
+    
+    from_currency = serializers.CharField(
+        max_length=10,
+        help_text="Source currency code (e.g., USD, BTC)"
+    )
+    to_currency = serializers.CharField(
+        max_length=10,
+        help_text="Target currency code (e.g., USD, BTC)"
+    )
+    amount = serializers.FloatField(
+        min_value=0.01,
+        help_text="Amount to convert"
+    )
+    provider = serializers.ChoiceField(
+        choices=[('nowpayments', 'NowPayments')],
+        default='nowpayments',
+        required=False,
+        help_text="Provider for conversion rates"
+    )
+    
+    def validate_from_currency(self, value: str) -> str:
+        """Validate source currency exists."""
+        if not Currency.objects.filter(code=value.upper(), is_active=True).exists():
+            raise serializers.ValidationError(f"Currency {value} not found or inactive")
+        return value.upper()
+    
+    def validate_to_currency(self, value: str) -> str:
+        """Validate target currency exists."""
+        if not Currency.objects.filter(code=value.upper(), is_active=True).exists():
+            raise serializers.ValidationError(f"Currency {value} not found or inactive")
+        return value.upper()
+    
+    def validate(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate conversion request."""
+        if attrs['from_currency'] == attrs['to_currency']:
+            raise serializers.ValidationError("Source and target currencies cannot be the same")
+        
+        return attrs
+    
+    def save(self) -> Dict[str, Any]:
+        """Perform currency conversion using CurrencyService."""
+        try:
+            currency_service = get_currency_service()
+            result = currency_service.convert_currency(
+                from_currency=self.validated_data['from_currency'],
+                to_currency=self.validated_data['to_currency'],
+                amount=self.validated_data['amount'],
+                provider=self.validated_data.get('provider', 'nowpayments')
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'conversion': result.data,
+                    'message': result.message
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Currency conversion error: {e}")
+            return {
+                'success': False,
+                'error': f"Conversion failed: {e}",
+                'error_code': 'conversion_error'
+            }
+
+
+class CurrencyRatesSerializer(serializers.Serializer):
+    """
+    Currency rates serializer for getting exchange rates.
+    
+    Fetches current exchange rates through CurrencyService.
+    """
+    
+    base_currency = serializers.CharField(
+        default='USD',
+        max_length=10,
+        help_text="Base currency for rates (default: USD)"
+    )
+    currencies = serializers.ListField(
+        child=serializers.CharField(max_length=10),
+        required=False,
+        help_text="Specific currencies to get rates for (optional)"
+    )
+    provider = serializers.ChoiceField(
+        choices=[('nowpayments', 'NowPayments')],
+        default='nowpayments',
+        required=False,
+        help_text="Provider for exchange rates"
+    )
+    
+    def validate_base_currency(self, value: str) -> str:
+        """Validate base currency exists."""
+        if not Currency.objects.filter(code=value.upper(), is_active=True).exists():
+            raise serializers.ValidationError(f"Base currency {value} not found or inactive")
+        return value.upper()
+    
+    def validate_currencies(self, value: list) -> list:
+        """Validate requested currencies exist."""
+        if value:
+            upper_currencies = [c.upper() for c in value]
+            existing_currencies = set(
+                Currency.objects.filter(
+                    code__in=upper_currencies,
+                    is_active=True
+                ).values_list('code', flat=True)
+            )
+            
+            missing_currencies = set(upper_currencies) - existing_currencies
+            if missing_currencies:
+                raise serializers.ValidationError(
+                    f"Currencies not found or inactive: {', '.join(missing_currencies)}"
+                )
+            
+            return upper_currencies
+        return value
+    
+    def save(self) -> Dict[str, Any]:
+        """Get currency rates using CurrencyService."""
+        try:
+            currency_service = get_currency_service()
+            result = currency_service.get_exchange_rates(
+                base_currency=self.validated_data['base_currency'],
+                currencies=self.validated_data.get('currencies'),
+                provider=self.validated_data.get('provider', 'nowpayments')
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'rates': result.data,
+                    'message': result.message
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Currency rates error: {e}")
+            return {
+                'success': False,
+                'error': f"Rates fetch failed: {e}",
+                'error_code': 'rates_error'
+            }
+
+
+class SupportedCurrenciesSerializer(serializers.Serializer):
+    """
+    Supported currencies serializer for provider capabilities.
+    
+    Gets supported currencies from providers through CurrencyService.
+    """
+    
+    provider = serializers.ChoiceField(
+        choices=[('nowpayments', 'NowPayments')],
+        default='nowpayments',
+        required=False,
+        help_text="Provider to get supported currencies from"
+    )
+    currency_type = serializers.ChoiceField(
+        choices=[
+            ('all', 'All'),
+            ('crypto', 'Cryptocurrency'),
+            ('fiat', 'Fiat Currency'),
+        ],
+        default='all',
+        required=False,
+        help_text="Filter by currency type"
+    )
+    
+    def save(self) -> Dict[str, Any]:
+        """Get supported currencies using CurrencyService."""
+        try:
+            currency_service = get_currency_service()
+            result = currency_service.get_supported_currencies(
+                provider=self.validated_data.get('provider', 'nowpayments'),
+                currency_type=self.validated_data.get('currency_type', 'all')
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'currencies': result.data,
+                    'message': result.message
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Supported currencies error: {e}")
+            return {
+                'success': False,
+                'error': f"Supported currencies fetch failed: {e}",
+                'error_code': 'supported_currencies_error'
+            }