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

django_cfg/apps/payments/config/utils.py

@@ -0,0 +1,198 @@
+"""
+Configuration utility functions.
+
+Helper functions for working with payment configurations.
+"""
+
+from typing import Optional, List, Dict, Any
+import logging
+
+from .module import PaymentsCfgModule
+from .settings import PaymentsSettings
+from .providers import PaymentProviderConfig, NowPaymentsConfig, StripeConfig, CryptAPIConfig
+
+logger = logging.getLogger(__name__)
+
+# Global payments configuration instance
+_payments_config = PaymentsCfgModule()
+
+
+def get_payments_config() -> PaymentsSettings:
+    """Get current payments configuration."""
+    return _payments_config.get_config()
+
+
+def get_provider_config(provider_name: str) -> Optional[PaymentProviderConfig]:
+    """Get configuration for specific payment provider."""
+    config = get_payments_config()
+    return config.providers.get(provider_name)
+
+
+def get_nowpayments_config() -> Optional[NowPaymentsConfig]:
+    """Get NowPayments configuration."""
+    provider_config = get_provider_config('nowpayments')
+    if isinstance(provider_config, NowPaymentsConfig):
+        return provider_config
+    return None
+
+
+def get_stripe_config() -> Optional[StripeConfig]:
+    """Get Stripe configuration."""
+    provider_config = get_provider_config('stripe')
+    if isinstance(provider_config, StripeConfig):
+        return provider_config
+    return None
+
+
+def get_cryptapi_config() -> Optional[CryptAPIConfig]:
+    """Get CryptAPI configuration."""
+    provider_config = get_provider_config('cryptapi')
+    if isinstance(provider_config, CryptAPIConfig):
+        return provider_config
+    return None
+
+
+
+
+def is_payments_enabled() -> bool:
+    """Check if payments module is enabled."""
+    try:
+        config = get_payments_config()
+        return config.enabled
+    except Exception as e:
+        logger.warning(f"Error checking payments status: {e}")
+        return False
+
+
+def is_feature_enabled(feature_name: str) -> bool:
+    """Check if specific payment feature is enabled."""
+    try:
+        config = get_payments_config()
+        feature_map = {
+            'crypto_payments': config.enable_crypto_payments,
+            'fiat_payments': config.enable_fiat_payments,
+            'subscriptions': config.enable_subscription_system,
+            'balance': config.enable_balance_system,
+            'api_keys': config.enable_api_key_system,
+            'webhooks': config.enable_webhook_processing,
+        }
+        return feature_map.get(feature_name, False)
+    except Exception as e:
+        logger.warning(f"Error checking feature {feature_name}: {e}")
+        return False
+
+
+def get_enabled_providers() -> List[str]:
+    """Get list of enabled payment providers."""
+    try:
+        config = get_payments_config()
+        return [name for name, provider_config in config.providers.items() if provider_config.enabled]
+    except Exception as e:
+        logger.warning(f"Error getting enabled providers: {e}")
+        return []
+
+
+def get_provider_settings(provider_name: str) -> Dict[str, Any]:
+    """Get provider settings as dictionary for service initialization."""
+    try:
+        provider_config = get_provider_config(provider_name)
+        if provider_config:
+            return provider_config.get_config_dict()
+        return {}
+    except Exception as e:
+        logger.error(f"Error getting settings for provider {provider_name}: {e}")
+        return {}
+
+
+def validate_provider_config(provider_name: str) -> bool:
+    """Validate provider configuration."""
+    try:
+        provider_config = get_provider_config(provider_name)
+        if not provider_config:
+            return False
+        
+        # Basic validation - check if API key exists
+        config_dict = provider_config.get_config_dict()
+        return bool(config_dict.get('api_key'))
+        
+    except Exception as e:
+        logger.error(f"Error validating provider {provider_name}: {e}")
+        return False
+
+
+def get_rate_limit_settings() -> Dict[str, int]:
+    """Get rate limiting settings."""
+    try:
+        config = get_payments_config()
+        return {
+            'hourly_limit': config.rate_limits.default_rate_limit_per_hour,
+            'daily_limit': config.rate_limits.default_rate_limit_per_day,
+            'burst_multiplier': config.rate_limits.burst_limit_multiplier,
+            'window_size': config.rate_limits.sliding_window_size,
+        }
+    except Exception as e:
+        logger.warning(f"Error getting rate limit settings: {e}")
+        return {
+            'hourly_limit': 1000,
+            'daily_limit': 10000,
+            'burst_multiplier': 2.0,
+            'window_size': 3600,
+        }
+
+
+def get_cache_settings() -> Dict[str, int]:
+    """Get cache timeout settings."""
+    try:
+        config = get_payments_config()
+        return {
+            'access_check': config.cache.cache_timeout_access_check,
+            'user_balance': config.cache.cache_timeout_user_balance,
+            'subscriptions': config.cache.cache_timeout_subscriptions,
+            'provider_status': config.cache.cache_timeout_provider_status,
+            'currency_rates': config.cache.cache_timeout_currency_rates,
+        }
+    except Exception as e:
+        logger.warning(f"Error getting cache settings: {e}")
+        return {
+            'access_check': 60,
+            'user_balance': 300,
+            'subscriptions': 600,
+            'provider_status': 1800,
+            'currency_rates': 3600,
+        }
+
+
+def get_billing_settings() -> Dict[str, Any]:
+    """Get billing settings."""
+    try:
+        config = get_payments_config()
+        return {
+            'auto_bill': config.billing.auto_bill_subscriptions,
+            'grace_period_hours': config.billing.billing_grace_period_hours,
+            'retry_failed': config.billing.retry_failed_payments,
+            'max_retries': config.billing.max_payment_retries,
+            'min_amount_usd': config.billing.min_payment_amount_usd,
+            'max_amount_usd': config.billing.max_payment_amount_usd,
+        }
+    except Exception as e:
+        logger.warning(f"Error getting billing settings: {e}")
+        return {
+            'auto_bill': True,
+            'grace_period_hours': 24,
+            'retry_failed': True,
+            'max_retries': 3,
+            'min_amount_usd': 1.0,
+            'max_amount_usd': 50000.0,
+        }
+
+
+def reset_config_cache():
+    """Reset configuration cache (useful for testing)."""
+    global _payments_config
+    _payments_config.reset_cache()
+
+
+def reload_config():
+    """Reload configuration from project settings."""
+    reset_config_cache()
+    return get_payments_config()

django_cfg/apps/payments/decorators.py

@@ -0,0 +1,291 @@
+"""
+Decorators for API access control and endpoint registration.
+"""
+
+import functools
+import logging
+from typing import Optional, List, Callable, Any
+from django.http import JsonResponse
+from django.conf import settings
+from django.utils import timezone
+from .models import EndpointGroup, Subscription
+
+logger = logging.getLogger(__name__)
+
+
+def require_api_key(func: Callable) -> Callable:
+    """
+    Decorator to require valid API key for function-based views.
+    Works with APIAccessMiddleware.
+    """
+    @functools.wraps(func)
+    def wrapper(request, *args, **kwargs):
+        if not hasattr(request, 'payment_api_key'):
+            return JsonResponse({
+                'error': {
+                    'code': 'MISSING_API_KEY',
+                    'message': 'Valid API key required',
+                    'timestamp': timezone.now().isoformat(),
+                }
+            }, status=401)
+        
+        return func(request, *args, **kwargs)
+    
+    return wrapper
+
+
+def require_subscription(endpoint_group_name: str):
+    """
+    Decorator to require active subscription for specific endpoint group.
+    
+    Args:
+        endpoint_group_name: Name of the endpoint group to check
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            # Check if middleware already validated subscription
+            if hasattr(request, 'payment_subscription'):
+                subscription = request.payment_subscription
+                if subscription.endpoint_group.name == endpoint_group_name:
+                    return func(request, *args, **kwargs)
+            
+            # If not validated by middleware, check manually
+            if not hasattr(request, 'payment_api_key'):
+                return JsonResponse({
+                    'error': {
+                        'code': 'MISSING_API_KEY',
+                        'message': 'Valid API key required',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=401)
+            
+            try:
+                endpoint_group = EndpointGroup.objects.get(
+                    name=endpoint_group_name,
+                    is_active=True
+                )
+                
+                subscription = Subscription.objects.filter(
+                    user=request.payment_api_key.user,
+                    endpoint_group=endpoint_group,
+                    status='active',
+                    expires_at__gt=timezone.now()
+                ).first()
+                
+                if not subscription:
+                    return JsonResponse({
+                        'error': {
+                            'code': 'NO_SUBSCRIPTION',
+                            'message': f'Active subscription required for {endpoint_group.display_name}',
+                            'timestamp': timezone.now().isoformat(),
+                        }
+                    }, status=403)
+                
+                # Store subscription in request
+                request.payment_subscription = subscription
+                
+                return func(request, *args, **kwargs)
+                
+            except EndpointGroup.DoesNotExist:
+                logger.error(f"Endpoint group '{endpoint_group_name}' not found")
+                return JsonResponse({
+                    'error': {
+                        'code': 'INVALID_ENDPOINT_GROUP',
+                        'message': 'Invalid endpoint group',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=500)
+        
+        return wrapper
+    return decorator
+
+
+def require_tier(minimum_tier: str):
+    """
+    Decorator to require minimum subscription tier.
+    
+    Args:
+        minimum_tier: Minimum required tier (basic, premium, enterprise)
+    """
+    tier_hierarchy = {
+        'basic': 1,
+        'premium': 2,
+        'enterprise': 3,
+    }
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            if not hasattr(request, 'payment_subscription'):
+                return JsonResponse({
+                    'error': {
+                        'code': 'NO_SUBSCRIPTION',
+                        'message': 'Active subscription required',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=403)
+            
+            subscription = request.payment_subscription
+            current_tier_level = tier_hierarchy.get(subscription.tier, 0)
+            required_tier_level = tier_hierarchy.get(minimum_tier, 999)
+            
+            if current_tier_level < required_tier_level:
+                return JsonResponse({
+                    'error': {
+                        'code': 'INSUFFICIENT_TIER',
+                        'message': f'Tier {minimum_tier} or higher required',
+                        'current_tier': subscription.tier,
+                        'required_tier': minimum_tier,
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=403)
+            
+            return func(request, *args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def track_usage(cost_per_request: float = 0.0):
+    """
+    Decorator to track API usage and deduct costs.
+    
+    Args:
+        cost_per_request: Cost to deduct per successful request
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            # Execute the function
+            response = func(request, *args, **kwargs)
+            
+            # Track usage if successful and we have subscription
+            if (hasattr(request, 'payment_subscription') and 
+                hasattr(response, 'status_code') and
+                200 <= response.status_code < 300 and
+                cost_per_request > 0):
+                
+                try:
+                    from .models import Transaction
+                    
+                    subscription = request.payment_subscription
+                    
+                    # Create billing transaction
+                    Transaction.objects.create(
+                        user=subscription.user,
+                        subscription=subscription,
+                        transaction_type='debit',
+                        amount_usd=-cost_per_request,
+                        description=f"API usage: {request.method} {request.path}",
+                        metadata={
+                            'endpoint': request.path,
+                            'method': request.method,
+                            'cost_per_request': cost_per_request,
+                        }
+                    )
+                    
+                except Exception as e:
+                    logger.error(f"Error tracking usage: {e}")
+            
+            return response
+        
+        return wrapper
+    return decorator
+
+
+def register_endpoint(endpoint_group_name: str, 
+                     display_name: Optional[str] = None,
+                     description: Optional[str] = None,
+                     require_api_key: bool = True):
+    """
+    Decorator to automatically register endpoint with the system.
+    This creates or updates EndpointGroup records.
+    
+    Args:
+        endpoint_group_name: Internal name for the endpoint group
+        display_name: Human-readable name
+        description: Description of the endpoint functionality
+        require_api_key: Whether this endpoint requires API key
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Auto-register endpoint group if it doesn't exist
+            try:
+                endpoint_group, created = EndpointGroup.objects.get_or_create(
+                    name=endpoint_group_name,
+                    defaults={
+                        'display_name': display_name or endpoint_group_name.replace('_', ' ').title(),
+                        'description': description or f'Auto-registered endpoint group: {endpoint_group_name}',
+                        'require_api_key': require_api_key,
+                        'is_active': True,
+                    }
+                )
+                
+                if created:
+                    logger.info(f"Auto-registered endpoint group: {endpoint_group_name}")
+                
+            except Exception as e:
+                logger.error(f"Error auto-registering endpoint group: {e}")
+            
+            return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def check_usage_limit(func: Callable) -> Callable:
+    """
+    Decorator to check subscription usage limits before processing request.
+    """
+    @functools.wraps(func)
+    def wrapper(request, *args, **kwargs):
+        if hasattr(request, 'payment_subscription'):
+            subscription = request.payment_subscription
+            
+            # Check if usage limit exceeded
+            if (subscription.usage_limit > 0 and 
+                subscription.usage_current >= subscription.usage_limit):
+                
+                return JsonResponse({
+                    'error': {
+                        'code': 'USAGE_EXCEEDED',
+                        'message': 'Monthly usage limit exceeded',
+                        'current_usage': subscription.usage_current,
+                        'usage_limit': subscription.usage_limit,
+                        'reset_date': subscription.next_billing.isoformat() if subscription.next_billing else None,
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=429)
+        
+        return func(request, *args, **kwargs)
+    
+    return wrapper
+
+
+# Utility decorator combinations
+def api_endpoint(endpoint_group_name: str, 
+                minimum_tier: str = 'basic',
+                cost_per_request: float = 0.0):
+    """
+    Combination decorator for typical API endpoint protection.
+    
+    Args:
+        endpoint_group_name: Name of the endpoint group
+        minimum_tier: Minimum subscription tier required
+        cost_per_request: Cost to charge per successful request
+    """
+    def decorator(func: Callable) -> Callable:
+        # Apply decorators in reverse order (they wrap from inside out)
+        decorated_func = func
+        decorated_func = track_usage(cost_per_request)(decorated_func)
+        decorated_func = check_usage_limit(decorated_func)
+        decorated_func = require_tier(minimum_tier)(decorated_func)
+        decorated_func = require_subscription(endpoint_group_name)(decorated_func)
+        decorated_func = require_api_key(decorated_func)
+        decorated_func = register_endpoint(endpoint_group_name)(decorated_func)
+        
+        return decorated_func
+    
+    return decorator