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

django_cfg/apps/payments/config/settings.py

@@ -0,0 +1,136 @@
+"""
+Universal payments module settings.
+
+Core settings for the payments system including security, rate limiting, billing, etc.
+"""
+
+from typing import Dict
+from pydantic import BaseModel, Field
+
+from .providers import PaymentProviderConfig
+
+
+class SecuritySettings(BaseModel):
+    """Security-related payment settings."""
+    api_key_length: int = Field(default=32, description="API key length in characters")
+    api_key_prefix: str = Field(default="ak_", description="API key prefix")
+    min_balance_threshold: float = Field(default=0.0, description="Minimum balance threshold")
+    auto_create_api_keys: bool = Field(default=True, description="Auto-create API keys for new users")
+
+
+class RateLimitSettings(BaseModel):
+    """Rate limiting settings."""
+    default_rate_limit_per_hour: int = Field(default=1000, description="Default API rate limit per hour")
+    default_rate_limit_per_day: int = Field(default=10000, description="Default API rate limit per day")
+    burst_limit_multiplier: float = Field(default=2.0, description="Burst limit multiplier")
+    sliding_window_size: int = Field(default=3600, description="Sliding window size in seconds")
+
+
+class BillingSettings(BaseModel):
+    """Billing and subscription settings."""
+    auto_bill_subscriptions: bool = Field(default=True, description="Automatically bill subscriptions")
+    billing_grace_period_hours: int = Field(default=24, description="Grace period for failed billing")
+    retry_failed_payments: bool = Field(default=True, description="Retry failed payments")
+    max_payment_retries: int = Field(default=3, description="Maximum payment retry attempts")
+    min_payment_amount_usd: float = Field(default=1.0, description="Minimum payment amount in USD")
+    max_payment_amount_usd: float = Field(default=50000.0, description="Maximum payment amount in USD")
+
+
+class CacheSettings(BaseModel):
+    """Cache timeout settings."""
+    cache_timeout_access_check: int = Field(default=60, description="Cache timeout for access checks (seconds)")
+    cache_timeout_user_balance: int = Field(default=300, description="Cache timeout for user balance (seconds)")
+    cache_timeout_subscriptions: int = Field(default=600, description="Cache timeout for subscriptions (seconds)")
+    cache_timeout_provider_status: int = Field(default=1800, description="Cache timeout for provider status (seconds)")
+    cache_timeout_currency_rates: int = Field(default=3600, description="Cache timeout for currency rates (seconds)")
+
+
+class NotificationSettings(BaseModel):
+    """Notification settings."""
+    send_payment_confirmations: bool = Field(default=True, description="Send payment confirmation emails")
+    send_subscription_renewals: bool = Field(default=True, description="Send subscription renewal notifications")
+    send_balance_alerts: bool = Field(default=True, description="Send low balance alerts")
+    send_api_key_alerts: bool = Field(default=True, description="Send API key security alerts")
+    webhook_timeout: int = Field(default=30, description="Webhook timeout in seconds")
+
+
+class PaymentsSettings(BaseModel):
+    """Universal payments module settings."""
+    
+    # General settings
+    enabled: bool = Field(default=True, description="Enable payments module")
+    debug_mode: bool = Field(default=False, description="Enable debug mode for payments")
+    
+    # Component settings
+    security: SecuritySettings = Field(default_factory=SecuritySettings)
+    rate_limits: RateLimitSettings = Field(default_factory=RateLimitSettings)
+    billing: BillingSettings = Field(default_factory=BillingSettings)
+    cache: CacheSettings = Field(default_factory=CacheSettings)
+    notifications: NotificationSettings = Field(default_factory=NotificationSettings)
+    
+    # Provider configurations
+    providers: Dict[str, PaymentProviderConfig] = Field(default_factory=dict, description="Payment provider configurations")
+    
+    # Feature flags
+    enable_crypto_payments: bool = Field(default=True, description="Enable cryptocurrency payments")
+    enable_fiat_payments: bool = Field(default=True, description="Enable fiat currency payments")
+    enable_subscription_system: bool = Field(default=True, description="Enable subscription system")
+    enable_balance_system: bool = Field(default=True, description="Enable user balance system")
+    enable_api_key_system: bool = Field(default=True, description="Enable API key system")
+    enable_webhook_processing: bool = Field(default=True, description="Enable webhook processing")
+    
+    # Backwards compatibility properties
+    @property
+    def auto_create_api_keys(self) -> bool:
+        """Backwards compatibility for auto_create_api_keys."""
+        return self.security.auto_create_api_keys
+    
+    @property
+    def min_balance_threshold(self) -> float:
+        """Backwards compatibility for min_balance_threshold."""
+        return self.security.min_balance_threshold
+    
+    @property
+    def default_rate_limit_per_hour(self) -> int:
+        """Backwards compatibility for default_rate_limit_per_hour."""
+        return self.rate_limits.default_rate_limit_per_hour
+    
+    @property
+    def default_rate_limit_per_day(self) -> int:
+        """Backwards compatibility for default_rate_limit_per_day."""
+        return self.rate_limits.default_rate_limit_per_day
+    
+    @property
+    def api_key_length(self) -> int:
+        """Backwards compatibility for api_key_length."""
+        return self.security.api_key_length
+    
+    @property
+    def api_key_prefix(self) -> str:
+        """Backwards compatibility for api_key_prefix."""
+        return self.security.api_key_prefix
+    
+    @property
+    def auto_bill_subscriptions(self) -> bool:
+        """Backwards compatibility for auto_bill_subscriptions."""
+        return self.billing.auto_bill_subscriptions
+    
+    @property
+    def billing_grace_period_hours(self) -> int:
+        """Backwards compatibility for billing_grace_period_hours."""
+        return self.billing.billing_grace_period_hours
+    
+    @property
+    def cache_timeout_access_check(self) -> int:
+        """Backwards compatibility for cache_timeout_access_check."""
+        return self.cache.cache_timeout_access_check
+    
+    @property
+    def cache_timeout_user_balance(self) -> int:
+        """Backwards compatibility for cache_timeout_user_balance."""
+        return self.cache.cache_timeout_user_balance
+    
+    @property
+    def cache_timeout_subscriptions(self) -> int:
+        """Backwards compatibility for cache_timeout_subscriptions."""
+        return self.cache.cache_timeout_subscriptions

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

django_cfg/apps/payments/managers/__init__.py

@@ -0,0 +1,22 @@
+"""
+Django model managers for universal payments.
+"""
+
+from .payment_manager import UniversalPaymentManager
+from .balance_manager import UserBalanceManager
+from .subscription_manager import SubscriptionManager, EndpointGroupManager
+from .tariff_manager import TariffManager, TariffEndpointGroupManager
+from .api_key_manager import APIKeyManager
+from .currency_manager import CurrencyManager, CurrencyNetworkManager
+
+__all__ = [
+    'UniversalPaymentManager',
+    'UserBalanceManager',
+    'SubscriptionManager',
+    'EndpointGroupManager', 
+    'TariffManager',
+    'TariffEndpointGroupManager',
+    'APIKeyManager',
+    'CurrencyManager',
+    'CurrencyNetworkManager',
+]

django_cfg/apps/payments/managers/api_key_manager.py

@@ -0,0 +1,35 @@
+"""
+API key managers.
+"""
+
+from django.db import models
+from django.utils import timezone
+
+
+class APIKeyManager(models.Manager):
+    """Manager for APIKey model."""
+    
+    def get_active_keys(self, user=None):
+        """Get active API keys."""
+        queryset = self.filter(is_active=True)
+        if user:
+            queryset = queryset.filter(user=user)
+        return queryset
+    
+    def get_expired_keys(self):
+        """Get expired API keys."""
+        return self.filter(
+            expires_at__lte=timezone.now()
+        )
+    
+    def get_valid_keys(self, user=None):
+        """Get valid (active and not expired) API keys."""
+        now = timezone.now()
+        queryset = self.filter(
+            is_active=True
+        ).filter(
+            models.Q(expires_at__isnull=True) | models.Q(expires_at__gt=now)
+        )
+        if user:
+            queryset = queryset.filter(user=user)
+        return queryset