django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/payments/middleware/api_access.py

@@ -16,6 +16,10 @@ from django.contrib.auth import get_user_model
 from ..models import APIKey, Subscription
 from ..config.helpers import MiddlewareConfigHelper
 from django_cfg.modules.django_logger import get_logger
+from ..tasks.usage_tracking import (
+    update_api_key_usage_async,
+    update_subscription_usage_async
+)
 
 User = get_user_model()
 logger = get_logger("api_access_middleware")
@@ -335,25 +339,47 @@ class APIAccessMiddleware(MiddlewareMixin):
     
     def _track_usage_async(self, api_key: APIKey, request: HttpRequest):
         """
-        Track API usage asynchronously to avoid blocking the request.
+        Track API usage asynchronously using background tasks.
+        
+        This method replaces the blocking database writes with async task queuing,
+        dramatically improving response times and reducing database load.
         """
         try:
-            # Increment usage counter (this will trigger signals)
-            api_key.increment_usage(ip_address=self._get_client_ip(request))
+            # Send API key usage update to background queue (non-blocking)
+            update_api_key_usage_async.send(
+                api_key_id=str(api_key.id),
+                ip_address=self._get_client_ip(request)
+            )
+            
+            # If user has active subscription, update subscription usage
+            if hasattr(request, 'subscription_access') and request.subscription_access.get('allowed'):
+                subscription_id = request.subscription_access.get('subscription_id')
+                if subscription_id:
+                    update_subscription_usage_async.send(
+                        subscription_id=subscription_id
+                    )
             
-            # Update usage analytics in cache
+            # Update lightweight analytics in cache (fast operations only)
             today = timezone.now().date().isoformat()
             
-            # Daily usage counter
+            # Daily usage counter (for quick dashboard access)
             daily_key = f"api_usage_daily:{api_key.user.id}:{today}"
             cache.set(daily_key, cache.get(daily_key, 0) + 1, timeout=86400 * 2)
             
-            # Endpoint usage counter
+            # Endpoint usage counter (for analytics)
             endpoint_key = f"endpoint_usage:{request.path}:{today}"
             cache.set(endpoint_key, cache.get(endpoint_key, 0) + 1, timeout=86400 * 2)
             
+            logger.debug(f"Usage tracking queued", extra={
+                'api_key_id': str(api_key.id),
+                'user_id': api_key.user.id,
+                'path': request.path,
+                'method': 'background_tasks'
+            })
+            
         except Exception as e:
             logger.warning(f"Usage tracking failed: {e}")
+            # Don't fail the request if usage tracking fails
     
     def _get_client_ip(self, request: HttpRequest) -> str:
         """

django_cfg/apps/payments/migrations/0002_currency_usd_rate_currency_usd_rate_updated_at.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.2.6 on 2025-09-27 12:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("payments", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="currency",
+            name="usd_rate",
+            field=models.FloatField(
+                default=1.0, help_text="Current USD exchange rate (1 unit = X USD)"
+            ),
+        ),
+        migrations.AddField(
+            model_name="currency",
+            name="usd_rate_updated_at",
+            field=models.DateTimeField(
+                blank=True, help_text="When USD rate was last updated", null=True
+            ),
+        ),
+    ]

django_cfg/apps/payments/migrations/0003_remove_provider_currency_fields.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.2.6 on 2025-09-27 16:46
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("payments", "0002_currency_usd_rate_currency_usd_rate_updated_at"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="providercurrency",
+            name="fee_percentage",
+        ),
+        migrations.RemoveField(
+            model_name="providercurrency",
+            name="fixed_fee",
+        ),
+        migrations.RemoveField(
+            model_name="providercurrency",
+            name="max_amount",
+        ),
+        migrations.RemoveField(
+            model_name="providercurrency",
+            name="min_amount",
+        ),
+    ]

django_cfg/apps/payments/migrations/0004_add_reserved_usd_field.py

@@ -0,0 +1,30 @@
+# Generated by Django 5.2.6 on 2025-09-27 18:16
+
+import django.core.validators
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("payments", "0003_remove_provider_currency_fields"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userbalance",
+            name="reserved_usd",
+            field=models.FloatField(
+                default=0.0,
+                help_text="Reserved amount in USD (pending transactions)",
+                validators=[django.core.validators.MinValueValidator(0.0)],
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="userbalance",
+            constraint=models.CheckConstraint(
+                condition=models.Q(("reserved_usd__gte", 0.0)), name="reserved_non_negative_check"
+            ),
+        ),
+    ]

django_cfg/apps/payments/models/balance.py

@@ -35,6 +35,12 @@ class UserBalance(models.Model):
         help_text="Current balance in USD (float for performance)"
     )
     
+    reserved_usd = models.FloatField(
+        default=0.0,
+        validators=[MinValueValidator(0.0)],
+        help_text="Reserved amount in USD (pending transactions)"
+    )
+    
     # Tracking fields
     total_deposited = models.FloatField(
         default=0.0,
@@ -75,6 +81,10 @@ class UserBalance(models.Model):
                 check=models.Q(balance_usd__gte=0.0),
                 name='balance_non_negative_check'
             ),
+            models.CheckConstraint(
+                check=models.Q(reserved_usd__gte=0.0),
+                name='reserved_non_negative_check'
+            ),
         ]
     
     def __str__(self):
@@ -84,6 +94,8 @@ class UserBalance(models.Model):
         """Validate balance data."""
         if self.balance_usd < 0:
             raise ValidationError("Balance cannot be negative")
+        if self.reserved_usd < 0:
+            raise ValidationError("Reserved amount cannot be negative")
     
     @property
     def balance_display(self) -> str:

django_cfg/apps/payments/models/currencies.py

@@ -62,6 +62,17 @@ class Currency(TimestampedModel):
         help_text="Source for exchange rates (auto-detected by django_currency)"
     )
     
+    usd_rate = models.FloatField(
+        default=1.0,
+        help_text="Current USD exchange rate (1 unit = X USD)"
+    )
+    
+    usd_rate_updated_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When USD rate was last updated"
+    )
+    
     # Manager
     from .managers.currency_managers import CurrencyManager
     objects = CurrencyManager()
@@ -100,6 +111,19 @@ class Currency(TimestampedModel):
     def is_fiat(self) -> bool:
         """Check if this is a fiat currency."""
         return self.currency_type == self.CurrencyType.FIAT
+    
+    def get_provider_config(self, provider: str):
+        """
+        Get provider configuration for this currency.
+        
+        Args:
+            provider: Provider name (e.g., 'nowpayments')
+        
+        Returns:
+            dict: Provider configuration or None
+        """
+        return Currency.objects.get_provider_config(self.code, provider)
+    
 
 
 class Network(TimestampedModel):
@@ -206,41 +230,14 @@ class ProviderCurrency(TimestampedModel):
         help_text="Currency code as used by the provider"
     )
     
-    min_amount = models.DecimalField(
-        max_digits=20,
-        decimal_places=8,
-        null=True,
-        blank=True,
-        help_text="Minimum payment amount for this currency"
-    )
-    
-    max_amount = models.DecimalField(
-        max_digits=20,
-        decimal_places=8,
-        null=True,
-        blank=True,
-        help_text="Maximum payment amount for this currency"
-    )
+# min_amount and max_amount removed - now provided by provider configuration properties
     
     is_enabled = models.BooleanField(
         default=True,
         help_text="Whether this currency is enabled for this provider"
     )
     
-    # Fee configuration
-    fee_percentage = models.DecimalField(
-        max_digits=5,
-        decimal_places=4,
-        default=0,
-        help_text="Fee percentage (0.0250 = 2.5%)"
-    )
-    
-    fixed_fee = models.DecimalField(
-        max_digits=20,
-        decimal_places=8,
-        default=0,
-        help_text="Fixed fee amount in this currency"
-    )
+    # Fee configuration removed - now provided by provider configuration properties
     
     class Meta:
         db_table = 'payments_provider_currencies'
@@ -267,12 +264,89 @@ class ProviderCurrency(TimestampedModel):
         if self.currency and self.currency.is_fiat and self.network:
             raise ValidationError("Fiat currencies should not specify a network")
         
-        # Validate amount limits
-        if self.min_amount and self.max_amount and self.min_amount > self.max_amount:
-            raise ValidationError("Minimum amount cannot be greater than maximum amount")
+        # Amount limits validation removed - now handled by provider configuration
     
     @property
     def display_name(self) -> str:
         """Human-readable display name."""
         network_part = f" on {self.network.name}" if self.network else ""
         return f"{self.currency.name}{network_part}"
+    
+    # Provider configuration properties (get values from provider config)
+    @property
+    def provider_fee_percentage(self) -> float:
+        """Get fee percentage from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance:
+                return float(provider_instance.get_fee_percentage(self.currency.code, self.currency.currency_type))
+            return 0.005  # Default 0.5%
+        except Exception:
+            return 0.005  # Default fallback
+    
+    @property
+    def provider_fixed_fee_usd(self) -> float:
+        """Get fixed fee from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance:
+                return float(provider_instance.get_fixed_fee_usd(self.currency.code, self.currency.currency_type))
+            return 0.0  # Default no fee
+        except Exception:
+            return 0.0  # Default fallback
+    
+    @property
+    def provider_min_amount_usd(self) -> float:
+        """Get minimum amount from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance:
+                return float(provider_instance.get_min_amount_usd(self.currency.code, self.currency.currency_type))
+            return 0.000001  # Default minimum
+        except Exception:
+            return 0.000001  # Default fallback
+    
+    @property
+    def provider_max_amount_usd(self) -> float:
+        """Get maximum amount from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance:
+                return float(provider_instance.get_max_amount_usd(self.currency.code, self.currency.currency_type))
+            return 1000000.0  # Default maximum
+        except Exception:
+            return 1000000.0  # Default fallback
+    
+    @property
+    def provider_confirmation_blocks(self) -> int:
+        """Get confirmation blocks from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance and self.network:
+                return provider_instance.get_confirmation_blocks(self.network.code)
+            return 1  # Default
+        except Exception:
+            return 1  # Default fallback
+    
+    @property
+    def provider_network_name(self) -> str:
+        """Get network name from provider configuration."""
+        try:
+            from ..services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(self.provider)
+            if provider_instance and self.network:
+                return provider_instance.get_network_name(self.network.code)
+            return self.network.name if self.network else 'Unknown'
+        except Exception:
+            return self.network.name if self.network else 'Unknown'

django_cfg/apps/payments/models/managers/currency_managers.py

@@ -383,3 +383,68 @@ class CurrencyManager(models.Manager):
                 stats['by_provider'][provider] = queryset.supported_by_provider(provider).count()
         
         return stats
+    
+    def get_provider_config(self, currency_code: str, provider: str):
+        """
+        Get provider configuration for currency.
+        
+        Args:
+            currency_code: Currency code (e.g., 'BTC')
+            provider: Provider name (e.g., 'nowpayments')
+        
+        Returns:
+            dict: Provider configuration or None
+        """
+        try:
+            from ..currencies import ProviderCurrency
+            from ...services.providers.registry import get_provider_registry
+            
+            # Get provider instance
+            registry = get_provider_registry()
+            provider_instance = registry.get_provider(provider)
+            
+            if not provider_instance:
+                return None
+            
+            # Get currency
+            currency = self.by_code(currency_code)
+            if not currency:
+                return None
+            
+            # Get provider currency config from DB
+            try:
+                provider_currency = ProviderCurrency.objects.get(
+                    currency=currency,
+                    provider=provider,
+                    is_enabled=True
+                )
+                
+                # Get configuration from provider
+                return {
+                    'fee_percentage': float(provider_instance.get_fee_percentage(currency_code, currency.currency_type)),
+                    'fixed_fee_usd': float(provider_instance.get_fixed_fee_usd(currency_code, currency.currency_type)),
+                    'min_amount_usd': float(provider_instance.get_min_amount_usd(currency_code, currency.currency_type)),
+                    'max_amount_usd': float(provider_instance.get_max_amount_usd(currency_code, currency.currency_type)),
+                    'confirmation_blocks': provider_instance.get_confirmation_blocks(provider_currency.network.code if provider_currency.network else ''),
+                    'network_name': provider_instance.get_network_name(provider_currency.network.code if provider_currency.network else ''),
+                    'network_code': provider_currency.network.code if provider_currency.network else None,
+                }
+                
+            except ProviderCurrency.DoesNotExist:
+                # Return default configuration from provider
+                return {
+                    'fee_percentage': float(provider_instance.get_fee_percentage(currency_code, currency.currency_type)),
+                    'fixed_fee_usd': float(provider_instance.get_fixed_fee_usd(currency_code, currency.currency_type)),
+                    'min_amount_usd': float(provider_instance.get_min_amount_usd(currency_code, currency.currency_type)),
+                    'max_amount_usd': float(provider_instance.get_max_amount_usd(currency_code, currency.currency_type)),
+                    'confirmation_blocks': 1,
+                    'network_name': 'Unknown',
+                    'network_code': None,
+                }
+                
+        except Exception as e:
+            logger.error(f"Failed to get provider config: {e}", extra={
+                'currency_code': currency_code,
+                'provider': provider
+            })
+            return None

django_cfg/apps/payments/services/core/currency_service.py

@@ -4,10 +4,9 @@ Currency service for the Universal Payment System v2.0.
 Handles currency conversion and rate management using django_currency module.
 """
 
-from typing import Optional, Dict, Any, List
-from decimal import Decimal
+from typing import Optional, List
 from django.utils import timezone
-from datetime import timedelta
+from django.db import models
 
 from .base import BaseService
 from ..types import (
@@ -161,29 +160,35 @@ class CurrencyService(BaseService):
                 quote_currency=quote_currency
             )
     
-    def get_supported_currencies(self, provider: Optional[str] = None) -> ServiceOperationResult:
+    def get_supported_currencies(self, provider: Optional[str] = None, currency_type: str = 'all') -> ServiceOperationResult:
         """
         Get list of supported currencies.
         
         Args:
             provider: Filter by provider (optional)
+            currency_type: Filter by currency type ('all', 'crypto', 'fiat')
             
         Returns:
             ServiceOperationResult: List of supported currencies
         """
         try:
             self.logger.debug("Getting supported currencies", extra={
-                'provider': provider
+                'provider': provider,
+                'currency_type': currency_type
             })
             
             # Get currencies from database
-            queryset = Currency.objects.filter(is_enabled=True)
+            queryset = Currency.objects.filter(is_active=True)
+            
+            # Filter by currency type
+            if currency_type and currency_type != 'all':
+                queryset = queryset.filter(currency_type=currency_type)
             
             if provider:
                 # Filter by provider support
                 queryset = queryset.filter(
-                    providercurrency__provider=provider,
-                    providercurrency__is_enabled=True
+                    provider_configs__provider=provider,
+                    provider_configs__is_enabled=True
                 ).distinct()
             
             currencies = queryset.order_by('code')
@@ -197,18 +202,20 @@ class CurrencyService(BaseService):
                 # Add provider-specific info if requested
                 if provider:
                     try:
-                        provider_currency = ProviderCurrency.objects.get(
+                        provider_currency = ProviderCurrency.objects.filter(
                             currency=currency,
                             provider=provider,
                             is_enabled=True
-                        )
-                        currency_info['provider_info'] = {
-                            'min_amount': float(provider_currency.min_amount) if provider_currency.min_amount else None,
-                            'max_amount': float(provider_currency.max_amount) if provider_currency.max_amount else None,
-                            'network_fee': float(provider_currency.network_fee) if provider_currency.network_fee else None,
-                            'confirmation_blocks': provider_currency.confirmation_blocks
-                        }
-                    except ProviderCurrency.DoesNotExist:
+                        ).first()
+                        if provider_currency:
+                            currency_info['provider_info'] = {
+                                'min_amount': provider_currency.provider_min_amount_usd,
+                                'max_amount': provider_currency.provider_max_amount_usd,
+                                'fee_percentage': provider_currency.provider_fee_percentage,
+                                'fixed_fee_usd': provider_currency.provider_fixed_fee_usd,
+                                'confirmation_blocks': provider_currency.provider_confirmation_blocks
+                            }
+                    except Exception:
                         pass
                 
                 currency_data.append(currency_info)
@@ -245,7 +252,7 @@ class CurrencyService(BaseService):
             
             # Get currency
             try:
-                currency = Currency.objects.get(code=currency_code, is_enabled=True)
+                currency = Currency.objects.get(code=currency_code, is_active=True)
             except Currency.DoesNotExist:
                 return self._create_error_result(
                     f"Currency {currency_code} not found or disabled",
@@ -255,7 +262,7 @@ class CurrencyService(BaseService):
             # Get networks
             networks = Network.objects.filter(
                 currency_code=currency_code,
-                is_enabled=True
+                is_active=True
             ).order_by('name')
             
             network_data = []
@@ -305,10 +312,10 @@ class CurrencyService(BaseService):
             if currency_codes:
                 currencies = Currency.objects.filter(
                     code__in=currency_codes,
-                    is_enabled=True
+                    is_active=True
                 )
             else:
-                currencies = Currency.objects.filter(is_enabled=True)
+                currencies = Currency.objects.filter(is_active=True)
             
             updated_count = 0
             failed_count = 0
@@ -369,14 +376,14 @@ class CurrencyService(BaseService):
         try:
             # Currency counts
             total_currencies = Currency.objects.count()
-            enabled_currencies = Currency.objects.filter(is_enabled=True).count()
+            enabled_currencies = Currency.objects.filter(is_active=True).count()
             crypto_currencies = Currency.objects.filter(
                 currency_type=Currency.CurrencyType.CRYPTO,
-                is_enabled=True
+                is_active=True
             ).count()
             fiat_currencies = Currency.objects.filter(
                 currency_type=Currency.CurrencyType.FIAT,
-                is_enabled=True
+                is_active=True
             ).count()
             
             # Provider support
@@ -388,7 +395,7 @@ class CurrencyService(BaseService):
             
             # Network stats
             network_stats = Network.objects.filter(
-                is_enabled=True
+                is_active=True
             ).values('currency_code').annotate(
                 network_count=models.Count('id')
             ).order_by('-network_count')
@@ -415,14 +422,14 @@ class CurrencyService(BaseService):
         """Validate that currencies are supported."""
         try:
             # Check from_currency
-            if not Currency.objects.filter(code=from_currency, is_enabled=True).exists():
+            if not Currency.objects.filter(code=from_currency, is_active=True).exists():
                 return self._create_error_result(
                     f"Currency {from_currency} not supported",
                     "from_currency_not_supported"
                 )
             
             # Check to_currency
-            if not Currency.objects.filter(code=to_currency, is_enabled=True).exists():
+            if not Currency.objects.filter(code=to_currency, is_active=True).exists():
                 return self._create_error_result(
                     f"Currency {to_currency} not supported",
                     "to_currency_not_supported"
@@ -440,7 +447,7 @@ class CurrencyService(BaseService):
         """Perform currency service health check."""
         try:
             # Check database connectivity
-            currency_count = Currency.objects.filter(is_enabled=True).count()
+            currency_count = Currency.objects.filter(is_active=True).count()
             
             # Test currency conversion
             try:

django_cfg/apps/payments/services/core/payment_service.py

@@ -104,7 +104,7 @@ class PaymentService(BaseService):
             payment = self._execute_with_transaction(create_payment_transaction)
             
             # Create payment with provider
-            from ..providers.base import PaymentRequest as ProviderPaymentRequest
+            from ..providers.models import PaymentRequest as ProviderPaymentRequest
             
             provider_request = ProviderPaymentRequest(
                 amount_usd=request.amount_usd,

django_cfg/apps/payments/services/providers/__init__.py

@@ -7,6 +7,7 @@ Provider implementations with unified interface and Pydantic validation.
 from .base import BaseProvider
 from .nowpayments import NowPaymentsProvider
 from .registry import ProviderRegistry, get_provider_registry, initialize_providers
+from .sync_service import ProviderSyncService, get_provider_sync_service
 
 __all__ = [
     'BaseProvider',
@@ -14,4 +15,6 @@ __all__ = [
     'ProviderRegistry',
     'get_provider_registry',
     'initialize_providers',
+    'ProviderSyncService',
+    'get_provider_sync_service',
 ]