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

django_cfg/apps/payments/services/redis_service.py

@@ -0,0 +1,215 @@
+"""
+Redis service for universal payments with circuit breaker.
+"""
+
+import logging
+import redis
+import json
+import time
+from typing import Optional, Any, Dict, List
+from django_cfg.modules import BaseCfgModule
+from django.core.cache import cache
+from django.db import transaction
+
+logger = logging.getLogger(__name__)
+
+
+class RedisCircuitBreaker:
+    """Circuit breaker for Redis operations with database fallback."""
+    
+    def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self.failure_count = 0
+        self.last_failure_time = None
+        self.state = "CLOSED"  # CLOSED, OPEN, HALF_OPEN
+    
+    def call(self, redis_func, fallback_func, *args, **kwargs):
+        """Execute function with circuit breaker pattern."""
+        if self.state == "OPEN":
+            if self._should_attempt_reset():
+                self.state = "HALF_OPEN"
+            else:
+                logger.warning("Circuit breaker OPEN, using fallback")
+                return fallback_func(*args, **kwargs)
+        
+        try:
+            result = redis_func(*args, **kwargs)
+            self._on_success()
+            return result
+        except Exception as e:
+            self._on_failure()
+            logger.warning(f"Redis operation failed, using fallback: {e}")
+            return fallback_func(*args, **kwargs)
+    
+    def _on_success(self):
+        """Handle successful operation."""
+        self.failure_count = 0
+        self.state = "CLOSED"
+    
+    def _on_failure(self):
+        """Handle failed operation."""
+        self.failure_count += 1
+        self.last_failure_time = time.time()
+        if self.failure_count >= self.failure_threshold:
+            self.state = "OPEN"
+    
+    def _should_attempt_reset(self):
+        """Check if circuit breaker should attempt reset."""
+        import time
+        return (time.time() - self.last_failure_time) > self.recovery_timeout
+
+
+class RedisService(BaseCfgModule):
+    """Redis service with automatic configuration and circuit breaker."""
+    
+    def __init__(self):
+        super().__init__()
+        self._client = None
+        self._circuit_breaker = RedisCircuitBreaker()
+    
+    @property
+    def client(self) -> Optional[redis.Redis]:
+        """Get Redis client with lazy initialization."""
+        if self._client is None:
+            self._client = self._create_client()
+        return self._client
+    
+    def _create_client(self) -> Optional[redis.Redis]:
+        """Create Redis client from configuration."""
+        try:
+            config = self.get_config()
+            if not config:
+                logger.warning("No config available, Redis disabled")
+                return None
+            
+            # Get Redis config from main config
+            redis_config = getattr(config, 'cache', None)
+            if not redis_config:
+                logger.warning("No Redis config found, using default")
+                redis_url = "redis://localhost:6379/0"
+            else:
+                redis_url = getattr(redis_config, 'redis_url', "redis://localhost:6379/0")
+            
+            return redis.Redis.from_url(redis_url, decode_responses=True)
+            
+        except Exception as e:
+            logger.error(f"Failed to create Redis client: {e}")
+            return None
+    
+    def get_cache(self, key: str) -> Any:
+        """Get value from cache with circuit breaker."""
+        def redis_get():
+            if not self.client:
+                raise redis.ConnectionError("Redis client not available")
+            data = self.client.get(key)
+            return json.loads(data) if data else None
+        
+        def fallback_get():
+            # Fallback to Django cache (database)
+            return cache.get(key)
+        
+        return self._circuit_breaker.call(redis_get, fallback_get)
+    
+    def set_cache(self, key: str, value: Any, ttl: int = 300) -> bool:
+        """Set value in cache with circuit breaker."""
+        def redis_set():
+            if not self.client:
+                raise redis.ConnectionError("Redis client not available")
+            data = json.dumps(value) if value is not None else ""
+            return self.client.setex(key, ttl, data)
+        
+        def fallback_set():
+            # Fallback to Django cache (database)
+            cache.set(key, value, ttl)
+            return True
+        
+        return self._circuit_breaker.call(redis_set, fallback_set)
+    
+    def delete_cache(self, key: str) -> bool:
+        """Delete key from cache."""
+        def redis_delete():
+            if not self.client:
+                raise redis.ConnectionError("Redis client not available")
+            return self.client.delete(key)
+        
+        def fallback_delete():
+            cache.delete(key)
+            return True
+        
+        return self._circuit_breaker.call(redis_delete, fallback_delete)
+    
+    def increment(self, key: str, amount: int = 1, ttl: Optional[int] = None) -> int:
+        """Increment counter with circuit breaker."""
+        def redis_incr():
+            if not self.client:
+                raise redis.ConnectionError("Redis client not available")
+            result = self.client.incr(key, amount)
+            if ttl:
+                self.client.expire(key, ttl)
+            return result
+        
+        def fallback_incr():
+            # Simple fallback - just return amount (no persistence)
+            logger.warning(f"Redis unavailable, counter increment for {key} not persisted")
+            return amount
+        
+        return self._circuit_breaker.call(redis_incr, fallback_incr)
+    
+    def get_user_access_cache(self, user_id: int, endpoint_group: str) -> Optional[Dict]:
+        """Get cached user access info."""
+        key = f"access:{user_id}:{endpoint_group}"
+        return self.get_cache(key)
+    
+    def set_user_access_cache(self, user_id: int, endpoint_group: str, access_info: Dict, ttl: int = 60) -> bool:
+        """Set cached user access info."""
+        key = f"access:{user_id}:{endpoint_group}"
+        return self.set_cache(key, access_info, ttl)
+    
+    def track_usage(self, user_id: int, endpoint_group: str, response_time_ms: Optional[int] = None) -> None:
+        """Track API usage with rate limiting."""
+        # Increment request counter
+        usage_key = f"usage:{user_id}:{endpoint_group}"
+        self.increment(usage_key, ttl=3600)  # 1 hour window
+        
+        # Track response time if provided
+        if response_time_ms:
+            rt_key = f"response_time:{user_id}:{endpoint_group}"
+            def redis_track_rt():
+                if not self.client:
+                    raise redis.ConnectionError("Redis client not available")
+                self.client.lpush(rt_key, response_time_ms)
+                self.client.ltrim(rt_key, 0, 99)  # Keep last 100
+                self.client.expire(rt_key, 3600)
+            
+            def fallback_track_rt():
+                pass  # Skip response time tracking in fallback
+            
+            self._circuit_breaker.call(redis_track_rt, fallback_track_rt)
+    
+    def check_rate_limit(self, user_id: int, endpoint_group: str, limit: int, window: int = 3600) -> Dict:
+        """Check rate limit for user."""
+        rate_key = f"rate:{user_id}:{endpoint_group}:{window}"
+        
+        def redis_check():
+            if not self.client:
+                raise redis.ConnectionError("Redis client not available")
+            current = self.client.get(rate_key) or 0
+            return {
+                'allowed': int(current) < limit,
+                'current': int(current),
+                'limit': limit,
+                'window': window
+            }
+        
+        def fallback_check():
+            # Fallback - always allow (no rate limiting)
+            logger.warning(f"Redis unavailable, rate limiting disabled for user {user_id}")
+            return {
+                'allowed': True,
+                'current': 0,
+                'limit': limit,
+                'window': window
+            }
+        
+        return self._circuit_breaker.call(redis_check, fallback_check)

django_cfg/apps/payments/urls.py

@@ -0,0 +1,78 @@
+"""
+URL routing for universal payments with nested routers.
+"""
+
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from rest_framework_nested import routers
+
+from . import views
+
+app_name = 'payments'
+
+# Main router for global endpoints
+router = DefaultRouter()
+
+# Global ViewSets (without user nesting)
+router.register(r'payments', views.UniversalPaymentViewSet, basename='payment')
+router.register(r'subscriptions', views.SubscriptionViewSet, basename='subscription')
+router.register(r'api-keys', views.APIKeyViewSet, basename='apikey')
+router.register(r'balances', views.UserBalanceViewSet, basename='balance')
+router.register(r'transactions', views.TransactionViewSet, basename='transaction')
+router.register(r'currencies', views.CurrencyViewSet, basename='currency')
+router.register(r'currency-networks', views.CurrencyNetworkViewSet, basename='currencynetwork')
+router.register(r'endpoint-groups', views.EndpointGroupViewSet, basename='endpointgroup')
+router.register(r'tariffs', views.TariffViewSet, basename='tariff')
+router.register(r'tariff-endpoint-groups', views.TariffEndpointGroupViewSet, basename='tariffendpointgroup')
+
+# Nested routers for user-specific resources
+# /users/{user_id}/payments/
+users_router = routers.SimpleRouter()
+users_router.register(r'users', views.UserPaymentViewSet, basename='user')
+
+payments_router = routers.NestedSimpleRouter(users_router, r'users', lookup='user')
+payments_router.register(r'payments', views.UserPaymentViewSet, basename='user-payment')
+
+# /users/{user_id}/subscriptions/
+subscriptions_router = routers.NestedSimpleRouter(users_router, r'users', lookup='user')
+subscriptions_router.register(r'subscriptions', views.UserSubscriptionViewSet, basename='user-subscription')
+
+# /users/{user_id}/api-keys/
+apikeys_router = routers.NestedSimpleRouter(users_router, r'users', lookup='user')
+apikeys_router.register(r'api-keys', views.UserAPIKeyViewSet, basename='user-apikey')
+
+# Generic API endpoints
+generic_patterns = [
+    # Payment endpoints
+    path('payment/create/', views.PaymentCreateView.as_view(), name='payment-create'),
+    path('payment/status/<str:internal_payment_id>/', views.PaymentStatusView.as_view(), name='payment-status'),
+    
+    # Subscription endpoints
+    path('subscription/create/', views.SubscriptionCreateView.as_view(), name='subscription-create'),
+    path('subscriptions/active/', views.ActiveSubscriptionsView.as_view(), name='subscriptions-active'),
+    
+    # API Key endpoints
+    path('api-key/create/', views.APIKeyCreateView.as_view(), name='apikey-create'),
+    path('api-key/validate/', views.APIKeyValidateView.as_view(), name='apikey-validate'),
+    
+    # Currency endpoints
+    path('currencies/supported/', views.SupportedCurrenciesView.as_view(), name='currencies-supported'),
+    path('currencies/rates/', views.CurrencyRatesView.as_view(), name='currency-rates'),
+    
+    # Tariff endpoints
+    path('tariffs/available/', views.AvailableTariffsView.as_view(), name='tariffs-available'),
+    path('tariffs/comparison/', views.TariffComparisonView.as_view(), name='tariff-comparison'),
+]
+
+urlpatterns = [
+    # Include all router URLs
+    path('api/v1/', include(router.urls)),
+    
+    # Include nested router URLs
+    path('api/v1/', include(payments_router.urls)),
+    path('api/v1/', include(subscriptions_router.urls)),
+    path('api/v1/', include(apikeys_router.urls)),
+    
+    # Include generic API endpoints
+    path('api/v1/', include(generic_patterns)),
+]

django_cfg/apps/payments/views/__init__.py

@@ -0,0 +1,62 @@
+"""
+DRF ViewSets for universal payments.
+"""
+
+from .balance_views import UserBalanceViewSet, TransactionViewSet
+from .payment_views import (
+    UserPaymentViewSet, UniversalPaymentViewSet, 
+    PaymentCreateView, PaymentStatusView
+)
+from .subscription_views import (
+    UserSubscriptionViewSet, SubscriptionViewSet, EndpointGroupViewSet,
+    SubscriptionCreateView, ActiveSubscriptionsView
+)
+from .api_key_views import (
+    UserAPIKeyViewSet, APIKeyViewSet, 
+    APIKeyCreateView, APIKeyValidateView
+)
+from .currency_views import (
+    CurrencyViewSet, CurrencyNetworkViewSet,
+    SupportedCurrenciesView, CurrencyRatesView
+)
+from .tariff_views import (
+    TariffViewSet, TariffEndpointGroupViewSet,
+    AvailableTariffsView, TariffComparisonView
+)
+
+__all__ = [
+    # Balance ViewSets
+    'UserBalanceViewSet',
+    'TransactionViewSet',
+    
+    # Payment ViewSets & Generics
+    'UserPaymentViewSet',
+    'UniversalPaymentViewSet',
+    'PaymentCreateView',
+    'PaymentStatusView',
+    
+    # Subscription ViewSets & Generics
+    'UserSubscriptionViewSet',
+    'SubscriptionViewSet',
+    'EndpointGroupViewSet',
+    'SubscriptionCreateView',
+    'ActiveSubscriptionsView',
+    
+    # API Key ViewSets & Generics
+    'UserAPIKeyViewSet',
+    'APIKeyViewSet',
+    'APIKeyCreateView',
+    'APIKeyValidateView',
+    
+    # Currency ViewSets & Generics
+    'CurrencyViewSet',
+    'CurrencyNetworkViewSet',
+    'SupportedCurrenciesView',
+    'CurrencyRatesView',
+    
+    # Tariff ViewSets & Generics
+    'TariffViewSet',
+    'TariffEndpointGroupViewSet',
+    'AvailableTariffsView',
+    'TariffComparisonView',
+]

django_cfg/apps/payments/views/api_key_views.py

@@ -0,0 +1,164 @@
+"""
+API Key ViewSets with nested routing.
+"""
+
+from rest_framework import viewsets, permissions, status, generics
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django_filters.rest_framework import DjangoFilterBackend
+from django.contrib.auth import get_user_model
+from ..models import APIKey
+from ..serializers import (
+    APIKeySerializer, APIKeyCreateSerializer, APIKeyListSerializer
+)
+
+User = get_user_model()
+
+
+class UserAPIKeyViewSet(viewsets.ModelViewSet):
+    """Nested ViewSet for user API keys: /users/{user_id}/api-keys/"""
+    
+    serializer_class = APIKeySerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['is_active']
+    
+    def get_queryset(self):
+        """Filter by user from URL."""
+        user_id = self.kwargs.get('user_pk')
+        return APIKey.objects.filter(user_id=user_id).order_by('-created_at')
+    
+    def get_serializer_class(self):
+        """Use different serializers for different actions."""
+        if self.action == 'create':
+            return APIKeyCreateSerializer
+        elif self.action == 'list':
+            return APIKeyListSerializer
+        return APIKeySerializer
+    
+    def perform_create(self, serializer):
+        """Set user from URL when creating."""
+        user_id = self.kwargs.get('user_pk')
+        user = User.objects.get(id=user_id)
+        
+        # Generate unique API key
+        import secrets
+        key_value = f"ak_{secrets.token_urlsafe(32)}"
+        
+        serializer.save(user=user, key_value=key_value)
+    
+    @action(detail=True, methods=['post'])
+    def regenerate(self, request, user_pk=None, pk=None):
+        """Regenerate API key."""
+        api_key = self.get_object()
+        
+        # Generate new key
+        import secrets
+        api_key.key_value = f"ak_{secrets.token_urlsafe(32)}"
+        api_key.usage_count = 0  # Reset usage
+        api_key.save()
+        
+        serializer = self.get_serializer(api_key)
+        return Response(serializer.data)
+    
+    @action(detail=True, methods=['post'])
+    def deactivate(self, request, user_pk=None, pk=None):
+        """Deactivate API key."""
+        api_key = self.get_object()
+        api_key.is_active = False
+        api_key.save()
+        
+        return Response({'message': 'API key deactivated'})
+    
+    @action(detail=True, methods=['get'])
+    def usage_stats(self, request, user_pk=None, pk=None):
+        """Get usage statistics for API key."""
+        api_key = self.get_object()
+        
+        return Response({
+            'usage_count': api_key.usage_count,
+            'last_used': api_key.last_used,
+            'is_valid': api_key.is_valid(),
+            'expires_at': api_key.expires_at,
+            'is_active': api_key.is_active,
+        })
+
+
+class APIKeyViewSet(viewsets.ReadOnlyModelViewSet):
+    """Global API keys ViewSet: /api-keys/"""
+    
+    queryset = APIKey.objects.all()
+    serializer_class = APIKeySerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['is_active']
+    
+    def get_queryset(self):
+        """Filter by current user for security."""
+        return APIKey.objects.filter(user=self.request.user).order_by('-created_at')
+    
+    def get_serializer_class(self):
+        """Use list serializer for list action."""
+        if self.action == 'list':
+            return APIKeyListSerializer
+        return APIKeySerializer
+
+
+# Generic views for specific use cases
+class APIKeyCreateView(generics.CreateAPIView):
+    """Generic view to create API key."""
+    
+    serializer_class = APIKeyCreateSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    
+    def perform_create(self, serializer):
+        """Set current user and generate key when creating."""
+        import secrets
+        key_value = f"ak_{secrets.token_urlsafe(32)}"
+        serializer.save(user=self.request.user, key_value=key_value)
+
+
+class APIKeyValidateView(generics.GenericAPIView):
+    """Generic view to validate API key."""
+    
+    serializer_class = APIKeySerializer  # For schema generation
+    permission_classes = [permissions.AllowAny]  # Public endpoint
+    
+    def post(self, request):
+        """Validate API key."""
+        key_value = request.data.get('api_key')
+        
+        if not key_value:
+            return Response(
+                {'error': 'API key required'}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        try:
+            api_key = APIKey.objects.get(key_value=key_value, is_active=True)
+            
+            # Check if expired
+            if api_key.is_expired:
+                return Response(
+                    {'error': 'API key expired'}, 
+                    status=status.HTTP_401_UNAUTHORIZED
+                )
+            
+            # Update last used
+            from django.utils import timezone
+            api_key.last_used = timezone.now()
+            api_key.save()
+            
+            return Response({
+                'valid': True,
+                'user_id': api_key.user.id,
+                'usage_count': api_key.usage_count,
+                'expires_at': api_key.expires_at,
+                'is_active': api_key.is_active,
+            })
+            
+        except APIKey.DoesNotExist:
+            return Response(
+                {'valid': False, 'error': 'Invalid API key'}, 
+                status=status.HTTP_401_UNAUTHORIZED
+            )

django_cfg/apps/payments/views/balance_views.py

@@ -0,0 +1,75 @@
+"""
+Balance ViewSets.
+"""
+
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django_filters.rest_framework import DjangoFilterBackend
+from ..models import UserBalance, Transaction
+from ..serializers import (
+    UserBalanceSerializer, TransactionSerializer, TransactionListSerializer
+)
+
+
+class UserBalanceViewSet(viewsets.ReadOnlyModelViewSet):
+    """User balance ViewSet - read only."""
+    
+    queryset = UserBalance.objects.all()
+    serializer_class = UserBalanceSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    
+    def get_queryset(self):
+        """Filter by current user."""
+        return UserBalance.objects.filter(user=self.request.user)
+    
+    @action(detail=False, methods=['get'])
+    def current(self, request):
+        """Get current user balance."""
+        balance, _ = UserBalance.objects.get_or_create(
+            user=request.user,
+            defaults={'amount_usd': 0.0, 'reserved_usd': 0.0}
+        )
+        serializer = self.get_serializer(balance)
+        return Response(serializer.data)
+
+
+class TransactionViewSet(viewsets.ReadOnlyModelViewSet):
+    """Transaction ViewSet - read only."""
+    
+    queryset = Transaction.objects.all()
+    serializer_class = TransactionSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['transaction_type', 'payment', 'subscription']
+    
+    def get_queryset(self):
+        """Filter by current user."""
+        return Transaction.objects.filter(user=self.request.user).order_by('-created_at')
+    
+    def get_serializer_class(self):
+        """Use list serializer for list action."""
+        if self.action == 'list':
+            return TransactionListSerializer
+        return TransactionSerializer
+    
+    @action(detail=False, methods=['get'])
+    def summary(self, request):
+        """Get transaction summary."""
+        queryset = self.get_queryset()
+        
+        total_earned = sum(
+            t.amount_usd for t in queryset 
+            if t.amount_usd > 0
+        )
+        total_spent = sum(
+            abs(t.amount_usd) for t in queryset 
+            if t.amount_usd < 0
+        )
+        
+        return Response({
+            'total_transactions': queryset.count(),
+            'total_earned': total_earned,
+            'total_spent': total_spent,
+            'net_balance': total_earned - total_spent
+        })