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

django_cfg/apps/payments/managers/currency_manager.py

@@ -5,15 +5,20 @@ Manager for Currency model.
 from django.db import models
 from django.utils import timezone
 from datetime import timedelta
-from typing import List, Optional
+from typing import List, Optional, TYPE_CHECKING
+from decimal import Decimal
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_currency import convert_currency, get_exchange_rate, CurrencyError
+
+if TYPE_CHECKING:
+    from ..services.internal_types import CurrencyOptionModel
+
+logger = get_logger("currency_manager")
 
 
 class CurrencyManager(models.Manager):
-    """Manager for Currency model with convenient query methods."""
-    
-    def active(self):
-        """Get only active currencies."""
-        return self.filter(is_active=True)
+    """Manager for clean Currency model."""
     
     def fiat(self):
         """Get only fiat currencies."""
@@ -23,61 +28,279 @@ class CurrencyManager(models.Manager):
         """Get only cryptocurrencies."""
         return self.filter(currency_type='crypto')
     
-    def active_fiat(self):
-        """Get active fiat currencies."""
-        return self.filter(currency_type='fiat', is_active=True)
-    
-    def active_crypto(self):
-        """Get active cryptocurrencies.""" 
-        return self.filter(currency_type='crypto', is_active=True)
-    
     def by_code(self, code: str):
         """Get currency by code (case insensitive)."""
         return self.filter(code__iexact=code).first()
     
-    def supported_for_payments(self, min_amount: float = None):
-        """Get currencies supported for payments."""
-        queryset = self.active()
-        if min_amount:
-            queryset = queryset.filter(min_payment_amount__lte=min_amount)
-        return queryset
-    
-    def recently_updated(self, hours: int = 24):
-        """Get currencies updated within the last N hours."""
-        threshold = timezone.now() - timedelta(hours=hours)
-        return self.filter(rate_updated_at__gte=threshold)
-    
-    def outdated(self, days: int = 7):
-        """Get currencies with outdated rates."""
-        threshold = timezone.now() - timedelta(days=days)
-        return self.filter(
-            models.Q(rate_updated_at__lt=threshold) | 
-            models.Q(rate_updated_at__isnull=True)
-        )
-    
-    def top_crypto_by_value(self, limit: int = 10):
-        """Get top cryptocurrencies by USD value."""
-        return self.active_crypto().order_by('-usd_rate')[:limit]
-    
     def search(self, query: str):
         """Search currencies by code or name."""
         return self.filter(
             models.Q(code__icontains=query) |
             models.Q(name__icontains=query)
         )
+    
+    def get_usd_rate(self, currency_code_or_instance, force_refresh: bool = False) -> float:
+        """
+        Get USD exchange rate for currency (with 24h cache).
+        
+        Args:
+            currency_code_or_instance: Currency code (e.g., 'BTC') or Currency instance
+            force_refresh: If True, skip cache and fetch fresh rate
+            
+        Returns:
+            float: 1 CURRENCY = X USD
+        """
+        try:
+            # Handle both Currency instance and string code
+            if hasattr(currency_code_or_instance, 'code'):
+                # Currency instance passed
+                currency = currency_code_or_instance
+                currency_code = currency.code
+            else:
+                # String code passed
+                currency_code = str(currency_code_or_instance).upper()
+                currency = self.filter(code=currency_code).first()
+            
+            # Return cached rate if fresh and not forcing refresh
+            if not force_refresh and currency and currency.usd_rate is not None and currency.rate_updated_at:
+                # Check if cache is still fresh (24 hours)
+                if timezone.now() - currency.rate_updated_at < timedelta(hours=24):
+                    logger.debug(f"Using cached USD rate for {currency_code}: ${float(currency.usd_rate):.8f}")
+                    return float(currency.usd_rate)
+            
+            # Cache miss, expired, or forced refresh - fetch fresh rate
+            logger.info(f"Fetching fresh USD rate for {currency_code} (force_refresh={force_refresh})")
+            rate = get_exchange_rate(currency_code, 'USD')
+            rate_decimal = Decimal(str(rate)).quantize(Decimal('0.00000001'))
+            
+            # Update cache
+            if currency:
+                currency.usd_rate = rate_decimal
+                currency.rate_updated_at = timezone.now()
+                currency.save(update_fields=['usd_rate', 'rate_updated_at'])
+                logger.info(f"Updated USD rate for {currency_code}: ${rate:.8f}")
+            else:
+                logger.warning(f"Currency {currency_code} not found in database for rate caching")
+            
+            return round(rate, 8)
+            
+        except CurrencyError as e:
+            logger.warning(f"Failed to get USD rate for {currency_code}: {e}")
+            # Return cached rate if available, even if stale
+            if currency and currency.usd_rate is not None:
+                logger.info(f"Using stale cached rate for {currency_code} due to API error")
+                return float(currency.usd_rate)
+            return 0.0
+    
+    def get_tokens_per_usd(self, currency_code: str) -> float:
+        """Get how many tokens you can buy for 1 USD."""
+        usd_rate = self.get_usd_rate(currency_code)
+        if usd_rate > 0:
+            return round(1.0 / usd_rate, 8)
+        return 0.0
+    
+    def convert_to_usd(self, amount: float, currency_code: str) -> float:
+        """Convert currency amount to USD."""
+        usd_rate = self.get_usd_rate(currency_code)
+        return round(amount * usd_rate, 2)
+    
+    def convert_from_usd(self, usd_amount: float, currency_code: str) -> float:
+        """Convert USD amount to target currency."""
+        tokens_per_usd = self.get_tokens_per_usd(currency_code)
+        return round(usd_amount * tokens_per_usd, 8)
+    
+    def get_or_create_normalized(self, code: str, defaults: dict = None):
+        """Simple get_or_create with uppercase code normalization."""
+        normalized_code = code.upper().strip() if code else ''
+        if not normalized_code:
+            raise ValueError(f"Empty currency code: '{code}'")
+        
+        creation_defaults = defaults or {}
+        creation_defaults['code'] = normalized_code
+        
+        return self.get_or_create(code__iexact=normalized_code, defaults=creation_defaults)
+
+
+class NetworkManager(models.Manager):
+    """Manager for Network model."""
+    
+    def by_code(self, code: str):
+        """Get network by code (case insensitive)."""
+        return self.filter(code__iexact=code).first()
+    
+    def get_or_create_normalized(self, code: str, defaults: dict = None):
+        """Get or create network with normalized code."""
+        normalized_code = code.lower().strip() if code else ''
+        if not normalized_code:
+            raise ValueError(f"Empty network code: '{code}'")
+        
+        creation_defaults = defaults or {}
+        creation_defaults['code'] = normalized_code
+        
+        return self.get_or_create(code__iexact=normalized_code, defaults=creation_defaults)
 
 
-class CurrencyNetworkManager(models.Manager):
-    """Manager for CurrencyNetwork model."""
+class ProviderCurrencyManager(models.Manager):
+    """Manager for ProviderCurrency model."""
+    
+    def enabled(self):
+        """Get only enabled provider currencies."""
+        return self.filter(is_enabled=True)
+    
+    def for_provider(self, provider_name: str):
+        """Get currencies for specific provider."""
+        return self.filter(provider_name__iexact=provider_name)
+    
+    def for_base_currency(self, currency_code: str):
+        """Get provider currencies for base currency."""
+        return self.filter(base_currency__code__iexact=currency_code)
+    
+    def for_network(self, network_code: str):
+        """Get provider currencies for network."""
+        return self.filter(network__code__iexact=network_code)
+    
+    def enabled_for_provider(self, provider_name: str):
+        """Get enabled currencies for provider."""
+        return self.enabled().filter(provider_name__iexact=provider_name)
+    
+    def popular(self):
+        """Get popular currencies."""
+        return self.filter(is_popular=True)
+    
+    def stable(self):
+        """Get stable currencies."""
+        return self.filter(is_stable=True)
     
-    def active(self):
-        """Get only active networks."""
-        return self.filter(is_active=True)
+    def get_currency_options_for_provider(self, provider_name: str):
+        """
+        Get flat list of currency options for single select dropdown.
+        
+        Returns:
+            List[dict]: List of currency option dictionaries
+        """
+        provider_currencies = self.enabled_for_provider(provider_name).select_related(
+            'base_currency', 'network'
+        ).order_by('is_popular', 'is_stable', 'base_currency__code', 'network__code')
+        
+        options = []
+        for pc in provider_currencies:
+            # Create display name: "USDT (Ethereum)" or "BTC" for native currencies
+            if pc.network:
+                display_name = f"{pc.base_currency.code} ({pc.network.name})"
+            else:
+                display_name = pc.base_currency.code
+            
+            # Get exchange rates using Currency manager
+            from ..models import Currency
+            usd_rate = Currency.objects.get_usd_rate(pc.base_currency.code)
+            tokens_per_usd = Currency.objects.get_tokens_per_usd(pc.base_currency.code)
+            
+            option = {
+                'provider_currency_code': pc.provider_currency_code,
+                'display_name': display_name,
+                'base_currency_code': pc.base_currency.code,
+                'base_currency_name': pc.base_currency.name,
+                'network_code': pc.network.code if pc.network else None,
+                'network_name': pc.network.name if pc.network else None,
+                'currency_type': pc.base_currency.currency_type,
+                'is_popular': pc.is_popular,
+                'is_stable': pc.is_stable,
+                'available_for_payment': pc.available_for_payment,
+                'available_for_payout': pc.available_for_payout,
+                'min_amount': str(pc.min_amount) if pc.min_amount else None,
+                'max_amount': str(pc.max_amount) if pc.max_amount else None,
+                'logo_url': pc.logo_url,
+                # Exchange rates
+                'usd_rate': usd_rate,
+                'tokens_per_usd': tokens_per_usd
+            }
+            options.append(option)
+        
+        # Sort: popular first, then stable, then alphabetically
+        def sort_key(option):
+            return (
+                0 if option['is_popular'] else 1,     # Popular first
+                0 if option['is_stable'] else 1,      # Then stable  
+                option['base_currency_code'],         # Then by base currency
+                option['network_name'] or ''          # Then by network
+            )
+        
+        options.sort(key=sort_key)
+        return options
     
-    def for_currency(self, currency_code: str):
-        """Get networks for a specific currency."""
-        return self.filter(currency__code__iexact=currency_code)
+    def get_usd_rates_for_provider(self, provider_name: str):
+        """
+        Get USD exchange rates for all provider currencies.
+        
+        Returns:
+            dict: {provider_currency_code: {'rate': 0.0001, 'tokens_per_usd': 10000}}
+        """
+        provider_currencies = self.enabled_for_provider(provider_name).select_related('base_currency')
+        rates = {}
+        
+        for pc in provider_currencies:
+            try:
+                # Get rate: 1 BASE_CURRENCY = X USD
+                usd_rate = get_exchange_rate(pc.base_currency.code, 'USD')
+                
+                # Calculate tokens per 1 USD
+                if usd_rate > 0:
+                    tokens_per_usd = 1.0 / usd_rate
+                else:
+                    tokens_per_usd = 0.0
+                
+                rates[pc.provider_currency_code] = {
+                    'usd_rate': round(usd_rate, 8),
+                    'tokens_per_usd': round(tokens_per_usd, 2),
+                    'base_currency': pc.base_currency.code,
+                    'updated_at': timezone.now().isoformat()
+                }
+                
+            except CurrencyError as e:
+                logger.warning(f"Failed to get rate for {pc.base_currency.code}: {e}")
+                rates[pc.provider_currency_code] = {
+                    'usd_rate': 0.0,
+                    'tokens_per_usd': 0.0,
+                    'base_currency': pc.base_currency.code,
+                    'error': str(e)
+                }
+        
+        return rates
     
-    def active_for_currency(self, currency_code: str):
-        """Get active networks for a specific currency."""
-        return self.active().filter(currency__code__iexact=currency_code)
+    def convert_amount(self, amount: float, from_currency_code: str, to_currency: str = 'USD'):
+        """
+        Convert amount from provider currency to target currency.
+        
+        Args:
+            amount: Amount to convert
+            from_currency_code: Provider currency code (e.g., 'USDTERC20')
+            to_currency: Target currency (default: 'USD')
+            
+        Returns:
+            dict: {'amount': converted_amount, 'rate': exchange_rate, 'from': base_currency}
+        """
+        try:
+            # Find provider currency and get base currency
+            pc = self.get(provider_currency_code=from_currency_code)
+            base_currency = pc.base_currency.code
+            
+            # Convert via base currency
+            converted_amount = convert_currency(amount, base_currency, to_currency)
+            rate = get_exchange_rate(base_currency, to_currency)
+            
+            return {
+                'amount': round(converted_amount, 2),
+                'rate': round(rate, 8),
+                'from': base_currency,
+                'to': to_currency,
+                'original_amount': amount,
+                'provider_code': from_currency_code
+            }
+            
+        except (CurrencyError, self.model.DoesNotExist) as e:
+            logger.error(f"Conversion failed for {from_currency_code}: {e}")
+            return {
+                'amount': 0.0,
+                'rate': 0.0,
+                'error': str(e)
+            }

django_cfg/apps/payments/managers/payment_manager.py

@@ -1,37 +1,143 @@
 """
-Payment manager for UniversalPayment model.
+Enhanced Payment manager for UniversalPayment model with query optimizations.
 """
 
 from django.db import models
+from django.utils import timezone
+from datetime import timedelta
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("payment_manager")
+
+
+class PaymentQuerySet(models.QuerySet):
+    """Custom QuerySet for UniversalPayment with optimizations."""
+    
+    def with_user(self):
+        """Select related user to prevent N+1 queries."""
+        return self.select_related('user')
+    
+    def with_events(self):
+        """Skip prefetch for events since they use CharField payment_id, not ForeignKey."""
+        # PaymentEvent uses CharField payment_id, not ForeignKey, so no reverse relation exists
+        # Events should be fetched separately when needed
+        return self
+    
+    def optimized(self):
+        """Get optimized queryset for admin and API views."""
+        return self.select_related('user').with_events()
+    
+    def active(self):
+        """Get active payments (not failed, cancelled, or refunded)."""
+        return self.exclude(
+            status__in=['failed', 'cancelled', 'refunded', 'expired']
+        )
+    
+    def completed(self):
+        """Get only completed payments."""
+        return self.filter(status='completed')
+    
+    def pending(self):
+        """Get pending payments."""
+        return self.filter(status='pending')
+    
+    def by_provider(self, provider):
+        """Filter by payment provider."""
+        return self.filter(provider=provider)
+    
+    def recent(self, days=30):
+        """Get payments from last N days."""
+        cutoff_date = timezone.now() - timedelta(days=days)
+        return self.filter(created_at__gte=cutoff_date)
+    
+    def by_amount_range(self, min_amount=None, max_amount=None):
+        """Filter by USD amount range."""
+        queryset = self
+        if min_amount is not None:
+            queryset = queryset.filter(amount_usd__gte=min_amount)
+        if max_amount is not None:
+            queryset = queryset.filter(amount_usd__lte=max_amount)
+        return queryset
+    
+    def by_user(self, user):
+        """Filter by user."""
+        return self.filter(user=user)
+    
+    def expired(self):
+        """Get expired payments."""
+        return self.filter(
+            expires_at__lt=timezone.now(),
+            status__in=['pending', 'confirming']
+        )
 
 
 class UniversalPaymentManager(models.Manager):
-    """Manager for UniversalPayment model."""
+    """Enhanced manager for UniversalPayment with optimization methods."""
+    
+    def get_queryset(self):
+        """Return custom QuerySet."""
+        return PaymentQuerySet(self.model, using=self._db)
+    
+    def with_user(self):
+        """Get payments with user data preloaded."""
+        return self.get_queryset().with_user()
+    
+    def optimized(self):
+        """Get optimized queryset for admin views."""
+        return self.get_queryset().optimized()
+    
+    def active(self):
+        """Get active payments."""
+        return self.get_queryset().active()
+    
+    def completed(self):
+        """Get completed payments."""
+        return self.get_queryset().completed()
+    
+    def pending(self):
+        """Get pending payments."""
+        return self.get_queryset().pending()
+    
+    def recent(self, days=30):
+        """Get recent payments."""
+        return self.get_queryset().recent(days)
     
-    def create_payment(self, user, amount_usd: float, currency_code: str, provider: str):
-        """Create a new payment."""
+    def by_provider(self, provider):
+        """Get payments by provider."""
+        return self.get_queryset().by_provider(provider)
+    
+    def create_payment(self, user, amount_usd: float, currency_code: str, provider: str, **kwargs):
+        """Create a payment with automatic field generation."""
+        from uuid import uuid4
+        
+        # Generate unique internal payment ID if not provided
+        internal_payment_id = kwargs.pop('internal_payment_id', f"PAY_{uuid4().hex[:8].upper()}")
+        
         payment = self.create(
             user=user,
+            internal_payment_id=internal_payment_id,
             amount_usd=amount_usd,
             currency_code=currency_code.upper(),
             provider=provider,
-            status=self.model.PaymentStatus.PENDING
+            status=self.model.PaymentStatus.PENDING,
+            **kwargs
         )
+        
         return payment
     
     def get_pending_payments(self, user=None):
         """Get pending payments for user or all users."""
-        queryset = self.filter(status=self.model.PaymentStatus.PENDING)
+        queryset = self.pending()
         if user:
-            queryset = queryset.filter(user=user)
-        return queryset
+            queryset = queryset.by_user(user)
+        return queryset.with_user()
     
     def get_completed_payments(self, user=None):
         """Get completed payments for user or all users."""
-        queryset = self.filter(status=self.model.PaymentStatus.COMPLETED)
+        queryset = self.completed()
         if user:
-            queryset = queryset.filter(user=user)
-        return queryset
+            queryset = queryset.by_user(user)
+        return queryset.with_user()
     
     def get_failed_payments(self, user=None):
         """Get failed/expired payments for user or all users."""
@@ -40,5 +146,47 @@ class UniversalPaymentManager(models.Manager):
             self.model.PaymentStatus.EXPIRED
         ])
         if user:
-            queryset = queryset.filter(user=user)
-        return queryset
+            queryset = queryset.by_user(user)
+        return queryset.with_user()
+    
+    def get_user_stats(self, user):
+        """Get payment statistics for a user."""
+        user_payments = self.by_user(user)
+        
+        return {
+            'total_payments': user_payments.count(),
+            'completed_payments': user_payments.completed().count(),
+            'pending_payments': user_payments.pending().count(),
+            'failed_payments': user_payments.filter(status='failed').count(),
+            'total_amount_usd': user_payments.completed().aggregate(
+                total=models.Sum('amount_usd')
+            )['total'] or 0,
+            'recent_payments_30d': user_payments.recent(30).count(),
+        }
+    
+    def get_provider_stats(self, provider=None):
+        """Get payment statistics by provider."""
+        if provider:
+            payments = self.by_provider(provider)
+        else:
+            payments = self.all()
+        
+        return {
+            'total_payments': payments.count(),
+            'completed_payments': payments.completed().count(),
+            'pending_payments': payments.pending().count(),
+            'success_rate': (
+                payments.completed().count() / max(payments.count(), 1) * 100
+            ),
+            'total_volume_usd': payments.completed().aggregate(
+                total=models.Sum('amount_usd')
+            )['total'] or 0,
+        }
+    
+    def mark_expired_payments(self):
+        """Mark expired payments as expired."""
+        expired_count = self.expired().update(
+            status=self.model.PaymentStatus.EXPIRED,
+            updated_at=timezone.now()
+        )
+        return expired_count

django_cfg/apps/payments/middleware/api_access.py

@@ -3,7 +3,7 @@ API Access Control Middleware.
 Handles API key authentication and subscription validation.
 """
 
-import logging
+from django_cfg.modules.django_logger import get_logger
 from typing import Optional, Tuple
 from django.http import JsonResponse, HttpRequest, HttpResponse
 from django.utils.deprecation import MiddlewareMixin
@@ -13,7 +13,7 @@ from ..models import APIKey, Subscription, EndpointGroup
 from ..services import ApiKeyCache, RateLimitCache
 from ..services.security import error_handler, SecurityError
 
-logger = logging.getLogger(__name__)
+logger = get_logger("api_access")
 
 
 class APIAccessMiddleware(MiddlewareMixin):

django_cfg/apps/payments/middleware/rate_limiting.py

@@ -3,16 +3,16 @@ Rate Limiting Middleware.
 Implements sliding window rate limiting using Redis.
 """
 
-import logging
+from django_cfg.modules.django_logger import get_logger
 import time
 from typing import Optional
 from django.http import JsonResponse, HttpRequest
 from django.utils.deprecation import MiddlewareMixin
 from django.conf import settings
 from django.utils import timezone
-from ..services import RateLimitCache
+from django.core.cache import cache
 
-logger = logging.getLogger(__name__)
+logger = get_logger("rate_limiting")
 
 
 class RateLimitingMiddleware(MiddlewareMixin):
@@ -29,7 +29,6 @@ class RateLimitingMiddleware(MiddlewareMixin):
     
     def __init__(self, get_response=None):
         super().__init__(get_response)
-        self.rate_limit_cache = RateLimitCache()
         
         # Default rate limits (can be overridden in settings)
         self.default_limits = getattr(settings, 'PAYMENTS_RATE_LIMITS', {
@@ -142,14 +141,8 @@ class RateLimitingMiddleware(MiddlewareMixin):
             # Get request count in window
             redis_key = f"rate_limit:{rate_key}:{window}"
             
-            # Use Redis sorted set for sliding window
-            # Remove old entries and count current entries
-            count = self.redis_service.sliding_window_count(
-                redis_key, 
-                window_start, 
-                current_time, 
-                window_seconds
-            )
+            # Simple cache-based rate limiting
+            count = cache.get(redis_key, 0)
             
             return count >= limit
             
@@ -181,12 +174,9 @@ class RateLimitingMiddleware(MiddlewareMixin):
                 if window_seconds:
                     redis_key = f"rate_limit:{rate_key}:{window}"
                     
-                    # Add current timestamp to sorted set
-                    self.redis_service.record_request(
-                        redis_key,
-                        current_time,
-                        window_seconds
-                    )
+                    # Increment request count
+                    current_count = cache.get(redis_key, 0)
+                    cache.set(redis_key, current_count + 1, window_seconds)
             
         except Exception as e:
             logger.error(f"Error recording request: {e}")