django-cfg 1.2.21__py3-none-any.whl → 1.2.23__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,65 @@
+"""
+Universal Payment Services.
+
+Modular architecture with minimal Pydantic typing for inter-service communication.
+Uses Django ORM for data persistence and DRF for API responses.
+"""
+
+# Core services
+from .core.payment_service import PaymentService
+from .core.balance_service import BalanceService
+from .core.subscription_service import SubscriptionService
+
+# Provider services
+from .providers.registry import ProviderRegistry
+from .providers.nowpayments import NowPaymentsProvider
+from .providers.cryptapi import CryptAPIProvider
+
+# Cache services
+from .cache import SimpleCache, ApiKeyCache, RateLimitCache
+
+# Internal types for inter-service communication
+from .internal_types import (
+    ProviderResponse, WebhookData, ServiceOperationResult,
+    BalanceUpdateRequest, AccessCheckRequest, AccessCheckResult,
+    # Service response models
+    PaymentCreationResult, WebhookProcessingResult, PaymentStatusResult,
+    UserBalanceResult, TransferResult, TransactionInfo,
+    EndpointGroupInfo, SubscriptionInfo, SubscriptionAnalytics
+)
+
+__all__ = [
+    # Core services
+    'PaymentService',
+    'BalanceService', 
+    'SubscriptionService',
+    
+    # Provider services
+    'ProviderRegistry',
+    'NowPaymentsProvider',
+    'CryptAPIProvider',
+    
+    # Cache services
+    'SimpleCache',
+    'ApiKeyCache', 
+    'RateLimitCache',
+    
+    # Internal types
+    'ProviderResponse',
+    'WebhookData', 
+    'ServiceOperationResult',
+    'BalanceUpdateRequest',
+    'AccessCheckRequest',
+    'AccessCheckResult',
+    
+    # Service response models
+    'PaymentCreationResult',
+    'WebhookProcessingResult', 
+    'PaymentStatusResult',
+    'UserBalanceResult',
+    'TransferResult',
+    'TransactionInfo',
+    'EndpointGroupInfo',
+    'SubscriptionInfo',
+    'SubscriptionAnalytics',
+]

django_cfg/apps/payments/services/billing/__init__.py

@@ -0,0 +1,8 @@
+"""
+Billing services for payments module.
+
+TODO: Implement billing services when needed.
+"""
+
+# Placeholder for future billing services
+__all__ = []

django_cfg/apps/payments/services/cache/__init__.py

@@ -0,0 +1,15 @@
+"""
+Simple caching for API key access control and rate limiting.
+
+ONLY for API key caching - NOT for payment data!
+"""
+
+from .base import CacheInterface
+from .simple_cache import SimpleCache, ApiKeyCache, RateLimitCache
+
+__all__ = [
+    'CacheInterface',
+    'SimpleCache', 
+    'ApiKeyCache',
+    'RateLimitCache',
+]

django_cfg/apps/payments/services/cache/base.py

@@ -0,0 +1,30 @@
+"""
+Base cache interface for payments module.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+
+
+class CacheInterface(ABC):
+    """Abstract cache interface."""
+    
+    @abstractmethod
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache."""
+        pass
+    
+    @abstractmethod
+    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
+        """Set value in cache."""
+        pass
+    
+    @abstractmethod
+    def delete(self, key: str) -> bool:
+        """Delete value from cache."""
+        pass
+    
+    @abstractmethod
+    def exists(self, key: str) -> bool:
+        """Check if key exists in cache."""
+        pass

django_cfg/apps/payments/services/cache/simple_cache.py

@@ -0,0 +1,135 @@
+"""
+Simple cache implementation for API keys and rate limiting.
+ONLY for API access control - NOT payment data!
+"""
+
+import logging
+from typing import Optional, Any
+from django.core.cache import cache
+
+from .base import CacheInterface
+from ...utils.config_utils import CacheConfigHelper
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleCache(CacheInterface):
+    """
+    Simple cache implementation using Django's cache framework.
+    
+    Falls back gracefully when cache is unavailable.
+    """
+    
+    def __init__(self, prefix: str = "payments"):
+        self.prefix = prefix
+        # Use config helper to check if cache is enabled
+        self.enabled = CacheConfigHelper.is_cache_enabled()
+        
+    def _make_key(self, key: str) -> str:
+        """Create prefixed cache key."""
+        return f"{self.prefix}:{key}"
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache."""
+        if not self.enabled:
+            return None
+            
+        try:
+            cache_key = self._make_key(key)
+            return cache.get(cache_key)
+        except Exception as e:
+            logger.warning(f"Cache get failed for key {key}: {e}")
+            return None
+    
+    def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
+        """Set value in cache."""
+        if not self.enabled:
+            return False
+            
+        try:
+            cache_key = self._make_key(key)
+            cache.set(cache_key, value, timeout)
+            return True
+        except Exception as e:
+            logger.warning(f"Cache set failed for key {key}: {e}")
+            return False
+    
+    def delete(self, key: str) -> bool:
+        """Delete value from cache."""
+        if not self.enabled:
+            return False
+            
+        try:
+            cache_key = self._make_key(key)
+            cache.delete(cache_key)
+            return True
+        except Exception as e:
+            logger.warning(f"Cache delete failed for key {key}: {e}")
+            return False
+    
+    def exists(self, key: str) -> bool:
+        """Check if key exists in cache."""
+        if not self.enabled:
+            return False
+            
+        try:
+            cache_key = self._make_key(key)
+            return cache.get(cache_key) is not None
+        except Exception as e:
+            logger.warning(f"Cache exists check failed for key {key}: {e}")
+            return False
+
+
+class ApiKeyCache:
+    """Specialized cache for API key operations."""
+    
+    def __init__(self):
+        self.cache = SimpleCache("api_keys")
+        # Get timeout from config
+        self.default_timeout = CacheConfigHelper.get_cache_timeout('api_key')
+    
+    def get_api_key_data(self, api_key: str) -> Optional[dict]:
+        """Get cached API key data."""
+        return self.cache.get(f"key:{api_key}")
+    
+    def cache_api_key_data(self, api_key: str, data: dict) -> bool:
+        """Cache API key data."""
+        return self.cache.set(f"key:{api_key}", data, self.default_timeout)
+    
+    def invalidate_api_key(self, api_key: str) -> bool:
+        """Invalidate cached API key."""
+        return self.cache.delete(f"key:{api_key}")
+
+
+class RateLimitCache:
+    """Specialized cache for rate limiting."""
+    
+    def __init__(self):
+        self.cache = SimpleCache("rate_limit")
+    
+    def get_usage_count(self, user_id: int, endpoint_group: str, window: str = "hour") -> int:
+        """Get current usage count for rate limiting."""
+        key = f"usage:{user_id}:{endpoint_group}:{window}"
+        count = self.cache.get(key)
+        return count if count is not None else 0
+    
+    def increment_usage(self, user_id: int, endpoint_group: str, window: str = "hour", ttl: Optional[int] = None) -> int:
+        """Increment usage count and return new count."""
+        key = f"usage:{user_id}:{endpoint_group}:{window}"
+        
+        # Get current count
+        current = self.get_usage_count(user_id, endpoint_group, window)
+        new_count = current + 1
+        
+        # Use config helper for TTL if not provided
+        if ttl is None:
+            ttl = CacheConfigHelper.get_cache_timeout('rate_limit')
+        
+        # Set new count with TTL
+        self.cache.set(key, new_count, ttl)
+        return new_count
+    
+    def reset_usage(self, user_id: int, endpoint_group: str, window: str = "hour") -> bool:
+        """Reset usage count."""
+        key = f"usage:{user_id}:{endpoint_group}:{window}"
+        return self.cache.delete(key)