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

django_cfg/apps/payments/decorators.py

@@ -1,291 +0,0 @@
-"""
-Decorators for API access control and endpoint registration.
-"""
-
-import functools
-from django_cfg.modules.django_logger import get_logger
-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 = get_logger("decorators")
-
-
-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/management/commands/README.md

@@ -1,146 +0,0 @@
-# Payment Management Commands
-
-Optimized management commands for Django CFG payments system.
-
-## Available Commands
-
-### 1. `manage_currencies` - Currency and Rate Management
-
-Universal command for all currency-related operations.
-
-#### Usage Examples:
-
-```bash
-# Update USD exchange rates only
-python manage.py manage_currencies --rates-only
-
-# Update specific currency rate
-python manage.py manage_currencies --rates-only --currency ETH
-
-# Initial population (empty database)
-python manage.py manage_currencies --populate
-
-# Full update with fresh rates
-python manage.py manage_currencies --force
-
-# Dry run to see what would be updated
-python manage.py manage_currencies --dry-run
-
-# Limit number of currencies processed
-python manage.py manage_currencies --populate --max-crypto 100 --max-fiat 20
-```
-
-#### Options:
-- `--populate` - Initial population mode for empty database
-- `--rates-only` - Only update USD exchange rates  
-- `--currency CODE` - Update specific currency (e.g., BTC, ETH)
-- `--force` - Force refresh all data even if fresh
-- `--dry-run` - Show what would be done without changes
-- `--max-crypto N` - Limit crypto currencies (default: 200)
-- `--max-fiat N` - Limit fiat currencies (default: 50)
-
----
-
-### 2. `manage_providers` - Payment Provider Management
-
-Universal command for all provider-related operations.
-
-#### Usage Examples:
-
-```bash
-# Sync all active providers
-python manage.py manage_providers
-
-# Sync specific provider
-python manage.py manage_providers --provider nowpayments
-
-# Sync multiple providers
-python manage.py manage_providers --provider nowpayments,cryptomus
-
-# Sync providers + update USD rates
-python manage.py manage_providers --with-rates
-
-# Show provider statistics
-python manage.py manage_providers --stats
-
-# Dry run to see what would be synced
-python manage.py manage_providers --dry-run --verbose
-```
-
-#### Options:
-- `--provider NAME` - Specific provider(s) to sync (comma-separated)
-- `--all` - Sync all available providers
-- `--with-rates` - Also update USD exchange rates after sync
-- `--stats` - Show provider statistics
-- `--dry-run` - Show what would be synced without changes
-- `--verbose` - Show detailed progress information
-
----
-
-### 3. `currency_stats` - Statistics and Reports
-
-Display currency database statistics and health information.
-
-#### Usage Examples:
-
-```bash
-# Basic statistics
-python manage.py currency_stats
-
-# Detailed breakdown
-python manage.py currency_stats --detailed
-
-# Top currencies by value
-python manage.py currency_stats --top 10
-
-# Check rate freshness
-python manage.py currency_stats --check-rates
-```
-
----
-
-## Migration from Old Commands
-
-| Old Command | New Command |
-|-------------|-------------|
-| `populate_currencies` | `manage_currencies --populate` |
-| `update_currencies` | `manage_currencies` |
-| `update_currency_rates` | `manage_currencies --rates-only` |
-| `sync_providers` | `manage_providers` |
-| `currency_stats` | `currency_stats` (unchanged) |
-
-## Automation Examples
-
-### Daily Rate Updates (Crontab)
-```bash
-# Update rates every 6 hours
-0 */6 * * * cd /path/to/project && python manage.py manage_currencies --rates-only
-
-# Sync providers once daily
-0 2 * * * cd /path/to/project && python manage.py manage_providers --with-rates
-```
-
-### Initial Setup
-```bash
-# 1. Populate base currencies
-python manage.py manage_currencies --populate
-
-# 2. Sync payment providers
-python manage.py manage_providers
-
-# 3. Check statistics
-python manage.py manage_providers --stats
-python manage.py currency_stats
-```
-
----
-
-## Features
-
-- **🚀 Fast**: Optimized database queries and caching
-- **📊 Progress**: Real-time progress reporting and statistics  
-- **🔄 Atomic**: Transaction safety with rollback on errors
-- **🎯 Flexible**: Multiple operation modes and options
-- **📈 Pydantic**: Full type safety with Pydantic models
-- **🛡️ Safe**: Dry-run mode for testing changes
-- **📝 Verbose**: Detailed logging and error reporting

django_cfg/apps/payments/managers/__init__.py

@@ -1,23 +0,0 @@
-"""
-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, NetworkManager, ProviderCurrencyManager
-
-__all__ = [
-    'UniversalPaymentManager',
-    'UserBalanceManager',
-    'SubscriptionManager',
-    'EndpointGroupManager', 
-    'TariffManager',
-    'TariffEndpointGroupManager',
-    'APIKeyManager',
-    'CurrencyManager',
-    'NetworkManager',
-    'ProviderCurrencyManager',
-]

django_cfg/apps/payments/managers/api_key_manager.py

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