django-cfg 1.2.20__py3-none-any.whl → 1.2.22__py3-none-any.whl

django_cfg/apps/payments/serializers/__init__.py

@@ -0,0 +1,56 @@
+"""
+DRF serializers for the universal payments system.
+"""
+
+from .balance import (
+    UserBalanceSerializer, TransactionSerializer, TransactionListSerializer
+)
+from .payments import (
+    UniversalPaymentSerializer, PaymentCreateSerializer, PaymentListSerializer
+)
+from .subscriptions import (
+    SubscriptionSerializer, SubscriptionCreateSerializer, SubscriptionListSerializer,
+    EndpointGroupSerializer
+)
+from .api_keys import (
+    APIKeySerializer, APIKeyCreateSerializer, APIKeyListSerializer
+)
+from .currencies import (
+    CurrencySerializer, CurrencyNetworkSerializer, CurrencyListSerializer
+)
+from .tariffs import (
+    TariffSerializer, TariffEndpointGroupSerializer, TariffListSerializer
+)
+
+__all__ = [
+    # Balance
+    'UserBalanceSerializer',
+    'TransactionSerializer',
+    'TransactionListSerializer',
+    
+    # Payments
+    'UniversalPaymentSerializer',
+    'PaymentCreateSerializer',
+    'PaymentListSerializer',
+    
+    # Subscriptions
+    'SubscriptionSerializer',
+    'SubscriptionCreateSerializer',
+    'SubscriptionListSerializer',
+    'EndpointGroupSerializer',
+    
+    # API Keys
+    'APIKeySerializer',
+    'APIKeyCreateSerializer',
+    'APIKeyListSerializer',
+    
+    # Currencies
+    'CurrencySerializer',
+    'CurrencyNetworkSerializer',
+    'CurrencyListSerializer',
+    
+    # Tariffs
+    'TariffSerializer',
+    'TariffEndpointGroupSerializer',
+    'TariffListSerializer',
+]

django_cfg/apps/payments/serializers/api_keys.py

@@ -0,0 +1,51 @@
+"""
+API key serializers.
+"""
+
+from rest_framework import serializers
+from ..models import APIKey
+
+
+class APIKeySerializer(serializers.ModelSerializer):
+    """API key with usage stats."""
+    
+    is_valid = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = APIKey
+        fields = [
+            'id', 'name', 'key_value', 'key_prefix', 'usage_count',
+            'is_active', 'is_valid', 'last_used', 'expires_at',
+            'created_at'
+        ]
+        read_only_fields = ['key_value', 'key_prefix', 'usage_count', 'last_used', 'created_at']
+    
+    def get_is_valid(self, obj):
+        """Get validation status."""
+        return obj.is_valid()
+
+
+class APIKeyCreateSerializer(serializers.ModelSerializer):
+    """Create API key."""
+    
+    class Meta:
+        model = APIKey
+        fields = ['name', 'expires_at']
+
+
+class APIKeyListSerializer(serializers.ModelSerializer):
+    """Simplified API key for lists."""
+    
+    is_valid = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = APIKey
+        fields = [
+            'id', 'name', 'key_prefix', 'usage_count', 'is_active', 'is_valid',
+            'last_used', 'expires_at', 'created_at'
+        ]
+        read_only_fields = ['key_prefix', 'usage_count', 'last_used', 'created_at']
+    
+    def get_is_valid(self, obj):
+        """Get validation status."""
+        return obj.is_valid()

django_cfg/apps/payments/serializers/balance.py

@@ -0,0 +1,59 @@
+"""
+Balance serializers.
+"""
+
+from rest_framework import serializers
+from ..models import UserBalance, Transaction
+
+
+class UserBalanceSerializer(serializers.ModelSerializer):
+    """User balance with computed fields."""
+    
+    total_balance = serializers.ReadOnlyField()
+    pending_payments_count = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = UserBalance
+        fields = [
+            'amount_usd', 'reserved_usd', 'total_balance',
+            'total_earned', 'total_spent', 'last_transaction_at',
+            'pending_payments_count', 'created_at', 'updated_at'
+        ]
+        read_only_fields = [
+            'total_earned', 'total_spent', 'last_transaction_at',
+            'created_at', 'updated_at'
+        ]
+    
+    def get_pending_payments_count(self, obj):
+        """Get count of pending payments."""
+        return obj.user.universal_payments.filter(status='pending').count()
+
+
+class TransactionSerializer(serializers.ModelSerializer):
+    """Transaction with details."""
+    
+    transaction_type_display = serializers.CharField(source='get_transaction_type_display', read_only=True)
+    is_credit = serializers.ReadOnlyField()
+    is_debit = serializers.ReadOnlyField()
+    
+    class Meta:
+        model = Transaction
+        fields = [
+            'id', 'amount_usd', 'transaction_type', 'transaction_type_display',
+            'description', 'balance_before', 'balance_after', 
+            'is_credit', 'is_debit', 'reference_id', 'created_at'
+        ]
+        read_only_fields = ['id', 'balance_before', 'balance_after', 'created_at']
+
+
+class TransactionListSerializer(serializers.ModelSerializer):
+    """Simplified transaction for lists."""
+    
+    transaction_type_display = serializers.CharField(source='get_transaction_type_display', read_only=True)
+    
+    class Meta:
+        model = Transaction
+        fields = [
+            'id', 'amount_usd', 'transaction_type', 'transaction_type_display',
+            'description', 'balance_after', 'created_at'
+        ]

django_cfg/apps/payments/serializers/currencies.py

@@ -0,0 +1,55 @@
+"""
+Currency serializers.
+"""
+
+from rest_framework import serializers
+from ..models import Currency, CurrencyNetwork
+
+
+class CurrencySerializer(serializers.ModelSerializer):
+    """Currency with type info."""
+    
+    currency_type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
+    is_crypto = serializers.SerializerMethodField()
+    is_fiat = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = Currency
+        fields = [
+            'id', 'code', 'name', 'symbol', 'currency_type', 'currency_type_display',
+            'is_crypto', 'is_fiat', 'decimal_places', 'usd_rate', 'rate_updated_at',
+            'is_active', 'min_payment_amount'
+        ]
+        read_only_fields = ['rate_updated_at']
+    
+    def get_is_crypto(self, obj):
+        """Check if currency is crypto."""
+        return obj.is_crypto
+    
+    def get_is_fiat(self, obj):
+        """Check if currency is fiat."""
+        return obj.is_fiat
+
+
+class CurrencyNetworkSerializer(serializers.ModelSerializer):
+    """Currency network with status."""
+    
+    currency_code = serializers.CharField(source='currency.code', read_only=True)
+    currency_name = serializers.CharField(source='currency.name', read_only=True)
+    
+    class Meta:
+        model = CurrencyNetwork
+        fields = [
+            'id', 'currency', 'currency_code', 'currency_name', 'network_code',
+            'network_name', 'is_active', 'confirmation_blocks'
+        ]
+
+
+class CurrencyListSerializer(serializers.ModelSerializer):
+    """Simplified currency for lists."""
+    
+    currency_type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
+    
+    class Meta:
+        model = Currency
+        fields = ['id', 'code', 'name', 'currency_type', 'currency_type_display', 'is_active']

django_cfg/apps/payments/serializers/payments.py

@@ -0,0 +1,62 @@
+"""
+Payment serializers.
+"""
+
+from rest_framework import serializers
+from ..models import UniversalPayment
+
+
+class UniversalPaymentSerializer(serializers.ModelSerializer):
+    """Universal payment with status info."""
+    
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    provider_display = serializers.CharField(source='get_provider_display', read_only=True)
+    is_pending = serializers.ReadOnlyField()
+    is_completed = serializers.ReadOnlyField()
+    is_failed = serializers.ReadOnlyField()
+    
+    class Meta:
+        model = UniversalPayment
+        fields = [
+            'id', 'internal_payment_id', 'provider_payment_id', 'order_id',
+            'amount_usd', 'currency_code', 'actual_amount_usd', 'actual_currency_code',
+            'fee_amount_usd', 'provider', 'provider_display', 'status', 'status_display',
+            'pay_address', 'pay_amount', 'network', 'description',
+            'is_pending', 'is_completed', 'is_failed',
+            'expires_at', 'completed_at', 'created_at', 'updated_at'
+        ]
+        read_only_fields = [
+            'id', 'internal_payment_id', 'provider_payment_id', 
+            'actual_amount_usd', 'actual_currency_code', 'fee_amount_usd',
+            'pay_address', 'pay_amount', 'completed_at', 'processed_at',
+            'created_at', 'updated_at'
+        ]
+
+
+class PaymentCreateSerializer(serializers.ModelSerializer):
+    """Create payment request."""
+    
+    class Meta:
+        model = UniversalPayment
+        fields = [
+            'amount_usd', 'currency_code', 'provider', 'description', 'order_id'
+        ]
+    
+    def validate_amount_usd(self, value):
+        """Validate payment amount."""
+        if value < 1.0:
+            raise serializers.ValidationError("Minimum payment amount is $1.00")
+        return value
+
+
+class PaymentListSerializer(serializers.ModelSerializer):
+    """Simplified payment for lists."""
+    
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    
+    class Meta:
+        model = UniversalPayment
+        fields = [
+            'id', 'internal_payment_id', 'amount_usd', 'currency_code',
+            'provider', 'status', 'status_display', 'description', 'created_at'
+        ]

django_cfg/apps/payments/serializers/subscriptions.py

@@ -0,0 +1,71 @@
+"""
+Subscription serializers.
+"""
+
+from rest_framework import serializers
+from ..models import Subscription, EndpointGroup
+
+
+class EndpointGroupSerializer(serializers.ModelSerializer):
+    """Endpoint group with pricing tiers."""
+    
+    class Meta:
+        model = EndpointGroup
+        fields = [
+            'id', 'name', 'display_name', 'description',
+            'basic_price', 'premium_price', 'enterprise_price',
+            'basic_limit', 'premium_limit', 'enterprise_limit',
+            'is_active', 'require_api_key'
+        ]
+
+
+class SubscriptionSerializer(serializers.ModelSerializer):
+    """Subscription with computed fields."""
+    
+    endpoint_group_name = serializers.CharField(source='endpoint_group.name', read_only=True)
+    endpoint_group_display = serializers.CharField(source='endpoint_group.display_name', read_only=True)
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    tier_display = serializers.CharField(source='get_tier_display', read_only=True)
+    is_active_subscription = serializers.ReadOnlyField(source='is_active')
+    is_usage_exceeded = serializers.ReadOnlyField()
+    
+    class Meta:
+        model = Subscription
+        fields = [
+            'id', 'endpoint_group', 'endpoint_group_name', 'endpoint_group_display',
+            'tier', 'tier_display', 'status', 'status_display', 'monthly_price',
+            'usage_limit', 'usage_current', 'is_active_subscription', 'is_usage_exceeded',
+            'last_billed', 'next_billing', 'expires_at', 'created_at'
+        ]
+        read_only_fields = [
+            'usage_current', 'last_billed', 'next_billing', 'cancelled_at', 'created_at'
+        ]
+
+
+class SubscriptionCreateSerializer(serializers.Serializer):
+    """Create subscription request."""
+    
+    endpoint_group_id = serializers.IntegerField()
+    tier = serializers.ChoiceField(choices=Subscription.SubscriptionTier.choices)
+    
+    def validate_endpoint_group_id(self, value):
+        """Validate endpoint group exists."""
+        try:
+            endpoint_group = EndpointGroup.objects.get(id=value, is_active=True)
+            return value
+        except EndpointGroup.DoesNotExist:
+            raise serializers.ValidationError("Endpoint group not found or inactive")
+
+
+class SubscriptionListSerializer(serializers.ModelSerializer):
+    """Simplified subscription for lists."""
+    
+    endpoint_group_name = serializers.CharField(source='endpoint_group.name', read_only=True)
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    
+    class Meta:
+        model = Subscription
+        fields = [
+            'id', 'endpoint_group_name', 'tier', 'status', 'status_display',
+            'monthly_price', 'usage_current', 'usage_limit', 'expires_at'
+        ]

django_cfg/apps/payments/serializers/tariffs.py

@@ -0,0 +1,56 @@
+"""
+Tariff serializers.
+"""
+
+from rest_framework import serializers
+from ..models import Tariff, TariffEndpointGroup
+
+
+class TariffSerializer(serializers.ModelSerializer):
+    """Tariff with pricing info."""
+    
+    is_free = serializers.SerializerMethodField()
+    endpoint_groups_count = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = Tariff
+        fields = [
+            'id', 'name', 'display_name', 'description', 'monthly_price',
+            'request_limit', 'is_free', 'is_active', 'endpoint_groups_count'
+        ]
+    
+    def get_is_free(self, obj):
+        """Check if tariff is free."""
+        return obj.is_free
+    
+    def get_endpoint_groups_count(self, obj):
+        """Get count of enabled endpoint groups."""
+        return obj.endpoint_groups.filter(is_enabled=True).count()
+
+
+class TariffEndpointGroupSerializer(serializers.ModelSerializer):
+    """Tariff endpoint group association."""
+    
+    tariff_name = serializers.CharField(source='tariff.name', read_only=True)
+    endpoint_group_name = serializers.CharField(source='endpoint_group.name', read_only=True)
+    
+    class Meta:
+        model = TariffEndpointGroup
+        fields = [
+            'id', 'tariff', 'tariff_name', 'endpoint_group', 'endpoint_group_name',
+            'is_enabled'
+        ]
+
+
+class TariffListSerializer(serializers.ModelSerializer):
+    """Simplified tariff for lists."""
+    
+    is_free = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = Tariff
+        fields = ['id', 'name', 'display_name', 'monthly_price', 'is_free', 'is_active']
+    
+    def get_is_free(self, obj):
+        """Check if tariff is free."""
+        return obj.is_free

django_cfg/apps/payments/services/__init__.py

@@ -0,0 +1,14 @@
+"""
+Universal payment services.
+"""
+
+from .base import PaymentProvider, PaymentService
+from .nowpayments import NowPaymentsProvider
+from .redis_service import RedisService
+
+__all__ = [
+    'PaymentProvider',
+    'PaymentService', 
+    'NowPaymentsProvider',
+    'RedisService',
+]

django_cfg/apps/payments/services/base.py

@@ -0,0 +1,68 @@
+"""
+Base payment service classes.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+from decimal import Decimal
+
+
+class PaymentProvider(ABC):
+    """Abstract base class for payment providers."""
+    
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize provider with config."""
+        self.config = config
+        self.name = self.__class__.__name__.lower().replace('provider', '')
+    
+    @abstractmethod
+    def create_payment(self, amount: Decimal, currency: str, **kwargs) -> Dict[str, Any]:
+        """Create a payment request."""
+        pass
+    
+    @abstractmethod
+    def check_payment_status(self, payment_id: str) -> Dict[str, Any]:
+        """Check payment status."""
+        pass
+    
+    @abstractmethod
+    def process_webhook(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Process webhook payload."""
+        pass
+    
+    @abstractmethod
+    def get_supported_currencies(self) -> list[str]:
+        """Get list of supported currencies."""
+        pass
+
+
+class PaymentService:
+    """Main payment service with provider management."""
+    
+    def __init__(self):
+        """Initialize payment service."""
+        self.providers: Dict[str, PaymentProvider] = {}
+    
+    def register_provider(self, provider: PaymentProvider) -> None:
+        """Register a payment provider."""
+        self.providers[provider.name] = provider
+    
+    def get_provider(self, name: str) -> Optional[PaymentProvider]:
+        """Get provider by name."""
+        return self.providers.get(name)
+    
+    def create_payment(self, provider_name: str, amount: Decimal, currency: str, **kwargs) -> Dict[str, Any]:
+        """Create payment using specified provider."""
+        provider = self.get_provider(provider_name)
+        if not provider:
+            raise ValueError(f"Provider {provider_name} not found")
+        
+        return provider.create_payment(amount, currency, **kwargs)
+    
+    def process_webhook(self, provider_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Process webhook for specified provider."""
+        provider = self.get_provider(provider_name)
+        if not provider:
+            raise ValueError(f"Provider {provider_name} not found")
+        
+        return provider.process_webhook(payload)

django_cfg/apps/payments/services/nowpayments.py

@@ -0,0 +1,78 @@
+"""
+NowPayments provider implementation.
+"""
+
+from typing import Dict, Any
+from decimal import Decimal
+import requests
+from .base import PaymentProvider
+
+
+class NowPaymentsProvider(PaymentProvider):
+    """NowPayments crypto payment provider."""
+    
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize NowPayments provider."""
+        super().__init__(config)
+        self.api_key = config.get('api_key')
+        self.base_url = config.get('base_url', 'https://api.nowpayments.io/v1')
+        self.headers = {'x-api-key': self.api_key}
+    
+    def create_payment(self, amount: Decimal, currency: str, **kwargs) -> Dict[str, Any]:
+        """Create payment via NowPayments API."""
+        payload = {
+            'price_amount': float(amount),
+            'price_currency': 'USD',
+            'pay_currency': currency.upper(),
+            'order_id': kwargs.get('order_id'),
+            'order_description': kwargs.get('description', 'Payment'),
+            'ipn_callback_url': kwargs.get('callback_url'),
+            'success_url': kwargs.get('success_url'),
+            'cancel_url': kwargs.get('cancel_url'),
+        }
+        
+        response = requests.post(
+            f"{self.base_url}/payment",
+            json=payload,
+            headers=self.headers,
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def check_payment_status(self, payment_id: str) -> Dict[str, Any]:
+        """Check payment status via NowPayments API."""
+        response = requests.get(
+            f"{self.base_url}/payment/{payment_id}",
+            headers=self.headers,
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def process_webhook(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Process NowPayments webhook."""
+        # Extract important fields from webhook
+        return {
+            'payment_id': payload.get('payment_id'),
+            'payment_status': payload.get('payment_status'),
+            'pay_address': payload.get('pay_address'),
+            'pay_amount': payload.get('pay_amount'),
+            'pay_currency': payload.get('pay_currency'),
+            'price_amount': payload.get('price_amount'),
+            'price_currency': payload.get('price_currency'),
+            'order_id': payload.get('order_id'),
+            'outcome_amount': payload.get('outcome_amount'),
+            'outcome_currency': payload.get('outcome_currency'),
+        }
+    
+    def get_supported_currencies(self) -> list[str]:
+        """Get supported cryptocurrencies from NowPayments."""
+        response = requests.get(
+            f"{self.base_url}/currencies",
+            headers=self.headers,
+            timeout=30
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data.get('currencies', [])

django_cfg/apps/payments/services/providers.py

@@ -0,0 +1,77 @@
+"""
+Payment provider integrations using Pydantic for external data validation.
+Only for provider responses and internal service communication.
+"""
+
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from decimal import Decimal
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+
+
+class NowPaymentsWebhook(BaseModel):
+    """NowPayments webhook data validation."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str
+    payment_status: str
+    pay_address: str
+    pay_amount: Decimal
+    pay_currency: str
+    order_id: str
+    order_description: Optional[str] = None
+    ipn_callback_url: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    @field_validator('pay_amount')
+    @classmethod
+    def validate_amount(cls, v: Decimal) -> Decimal:
+        if v <= 0:
+            raise ValueError("Payment amount must be positive")
+        return v
+
+
+class NowPaymentsCreateResponse(BaseModel):
+    """NowPayments payment creation response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str
+    payment_status: str
+    pay_address: str
+    pay_amount: Decimal
+    pay_currency: str
+    order_id: str
+    order_description: Optional[str] = None
+    ipn_callback_url: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class NowPaymentsStatusResponse(BaseModel):
+    """NowPayments payment status response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    payment_id: str
+    payment_status: str
+    pay_address: str
+    pay_amount: Decimal
+    actually_paid: Optional[Decimal] = None
+    pay_currency: str
+    order_id: str
+    outcome_amount: Optional[Decimal] = None
+    outcome_currency: Optional[str] = None
+
+
+class ProviderWebhookData(BaseModel):
+    """Generic webhook data for any provider."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    provider: str
+    payment_id: str
+    status: str
+    amount: Optional[Decimal] = None
+    currency: Optional[str] = None
+    raw_data: Dict[str, Any] = Field(default_factory=dict)
+    signature: Optional[str] = None
+    received_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))