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

django_cfg/apps/payments/serializers/api_keys.py

@@ -1,51 +0,0 @@
-"""
-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

@@ -1,59 +0,0 @@
-"""
-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

@@ -1,63 +0,0 @@
-"""
-Currency serializers.
-"""
-
-from rest_framework import serializers
-from ..models import Currency, Network, ProviderCurrency
-
-
-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', 'currency_type', 'currency_type_display',
-            'is_crypto', 'is_fiat', 'usd_rate', 'rate_updated_at'
-        ]
-        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 NetworkSerializer(serializers.ModelSerializer):
-    """Network information."""
-    
-    class Meta:
-        model = Network
-        fields = ['id', 'code', 'name']
-
-
-class ProviderCurrencySerializer(serializers.ModelSerializer):
-    """Provider currency with base currency and network info."""
-    
-    base_currency = CurrencySerializer(read_only=True)
-    network = NetworkSerializer(read_only=True)
-    
-    class Meta:
-        model = ProviderCurrency
-        fields = [
-            'id', 'provider_name', 'provider_currency_code', 'base_currency', 'network',
-            'is_enabled', 'available_for_payment', 'available_for_payout', 
-            'is_popular', 'is_stable', 'min_amount', 'max_amount', 'logo_url'
-        ]
-
-
-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']

django_cfg/apps/payments/serializers/payments.py

@@ -1,62 +0,0 @@
-"""
-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

@@ -1,71 +0,0 @@
-"""
-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

@@ -1,56 +0,0 @@
-"""
-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/billing/__init__.py

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

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

@@ -1,135 +0,0 @@
-"""
-Simple cache implementation for API keys and rate limiting.
-ONLY for API access control - NOT payment data!
-"""
-
-from django_cfg.modules.django_logger import get_logger
-from typing import Optional, Any
-from django.core.cache import cache
-
-from .base import CacheInterface
-from ...utils.config_utils import CacheConfigHelper
-
-logger = get_logger("simple_cache")
-
-
-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)