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

django_cfg/apps/payments/management/commands/currency_stats.py

@@ -73,6 +73,26 @@ class Command(BaseCommand):
             default='table',
             help='Output format (default: table)'
         )
+        
+        # Additional arguments expected by tests
+        parser.add_argument(
+            '--days',
+            type=int,
+            default=30,
+            help='Filter data for last N days (default: 30)'
+        )
+        
+        parser.add_argument(
+            '--currency',
+            type=str,
+            help='Show statistics for specific currency code'
+        )
+        
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Show verbose output (same as --detailed)'
+        )
     
     def handle(self, *args, **options):
         """Execute the command."""
@@ -80,10 +100,16 @@ class Command(BaseCommand):
             self.options = options
             self.show_header()
             
+            # Handle --verbose as alias for --detailed
+            if options['verbose']:
+                options['detailed'] = True
+            
             if options['check_rates']:
                 self.check_rate_freshness()
             elif options['provider']:
                 self.show_provider_stats(options['provider'])
+            elif options['currency']:
+                self.show_currency_stats(options['currency'])
             else:
                 self.show_general_stats()
                 
@@ -127,11 +153,16 @@ class Command(BaseCommand):
         
         # Provider currency stats
         total_provider_currencies = ProviderCurrency.objects.count()
-        active_provider_currencies = ProviderCurrency.objects.filter(is_active=True).count()
+        active_provider_currencies = ProviderCurrency.objects.filter(is_enabled=True).count()
+        
+        # Payment stats (filtered by days if specified)
+        payment_filter = Q()
+        if self.options.get('days'):
+            days_ago = timezone.now() - timedelta(days=self.options['days'])
+            payment_filter = Q(created_at__gte=days_ago)
         
-        # Payment stats
-        total_payments = UniversalPayment.objects.count()
-        completed_payments = UniversalPayment.objects.filter(status='completed').count()
+        total_payments = UniversalPayment.objects.filter(payment_filter).count()
+        completed_payments = UniversalPayment.objects.filter(payment_filter, status='completed').count()
         
         self.stdout.write(self.style.SUCCESS("📈 GENERAL STATISTICS"))
         self.stdout.write("-" * 40)
@@ -235,6 +266,42 @@ class Command(BaseCommand):
         
         self.stdout.write("")
     
+    def show_currency_stats(self, currency_code: str):
+        """Show statistics for specific currency."""
+        self.stdout.write(self.style.SUCCESS(f"💰 CURRENCY STATISTICS: {currency_code.upper()}"))
+        self.stdout.write("-" * 40)
+        
+        try:
+            currency = Currency.objects.get(code=currency_code.upper())
+        except Currency.DoesNotExist:
+            self.stdout.write(self.style.ERROR(f"Currency {currency_code} not found"))
+            return
+        
+        # Basic currency info
+        self.stdout.write(f"Name: {currency.name}")
+        self.stdout.write(f"Type: {currency.currency_type}")
+        self.stdout.write(f"Active: {'Yes' if currency.is_active else 'No'}")
+        self.stdout.write(f"Created: {currency.created_at.strftime('%Y-%m-%d')}")
+        self.stdout.write(f"Updated: {currency.updated_at.strftime('%Y-%m-%d')}")
+        
+        # Payment statistics
+        payments = UniversalPayment.objects.filter(currency=currency)
+        completed_payments = payments.filter(status='completed')
+        
+        if payments.exists():
+            total_volume = completed_payments.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0
+            avg_payment = completed_payments.aggregate(Avg('amount_usd'))['amount_usd__avg'] or 0
+            
+            self.stdout.write(f"\nPayment Statistics:")
+            self.stdout.write(f"  Total Payments: {payments.count()}")
+            self.stdout.write(f"  Completed: {completed_payments.count()}")
+            self.stdout.write(f"  Total Volume: ${intcomma(total_volume)}")
+            self.stdout.write(f"  Average Payment: ${intcomma(f'{avg_payment:.2f}')}")
+        else:
+            self.stdout.write(f"\nNo payments found for {currency_code}")
+        
+        self.stdout.write("")
+    
     def check_rate_freshness(self):
         """Check for outdated exchange rates."""
         self.stdout.write(self.style.SUCCESS("🕐 RATE FRESHNESS CHECK"))
@@ -302,7 +369,7 @@ class Command(BaseCommand):
             ("Total Payments", provider_payments.count()),
             ("Completed Payments", completed_payments.count()),
             ("Total Volume", f"${intcomma(total_volume)}"),
-            ("Average Payment", f"${intcomma(avg_payment):.2f}"),
+            ("Average Payment", f"${intcomma(f'{avg_payment:.2f}')}"),
         ]
         
         for label, value in stats:

django_cfg/apps/payments/management/commands/manage_currencies.py

@@ -262,16 +262,9 @@ class Command(BaseCommand):
         
         # Filter by staleness unless forced
         if not options['force']:
-            stale_threshold = timezone.now() - timedelta(hours=12)
-            
-            # Get currencies that need rate updates through ProviderCurrency
-            currencies_needing_update = Currency.objects.filter(
-                Q(providercurrency__usd_rate__isnull=True) |
-                Q(providercurrency__rate_updated_at__isnull=True) |
-                Q(providercurrency__rate_updated_at__lt=stale_threshold)
-            ).distinct()
-            
-            queryset = queryset.filter(id__in=currencies_needing_update)
+            # For now, skip staleness check since rate fields don't exist
+            # TODO: Implement proper rate tracking fields
+            pass
         
         # Apply limit
         queryset = queryset[:options['limit']]
@@ -300,20 +293,16 @@ class Command(BaseCommand):
                     # Update rate in ProviderCurrency (create if doesn't exist)
                     provider_currency, created = ProviderCurrency.objects.get_or_create(
                         currency=currency,
-                        provider_name='system',  # System-level rate
+                        provider='system',  # System-level rate
                         provider_currency_code=currency.code,
                         defaults={
-                            'usd_rate': usd_rate,
-                            'rate_updated_at': timezone.now(),
-                            'is_enabled': True,
-                            'is_stable': currency.currency_type == Currency.CurrencyType.FIAT
+                            'is_enabled': True
                         }
                     )
                     
                     if not created:
-                        provider_currency.usd_rate = usd_rate
-                        provider_currency.rate_updated_at = timezone.now()
-                        provider_currency.save(update_fields=['usd_rate', 'rate_updated_at'])
+                        # TODO: Add rate tracking fields to ProviderCurrency model
+                        provider_currency.save()  # Touch the record to update timestamp
                     
                     # Update currency's exchange rate source
                     currency.exchange_rate_source = 'django_currency'
@@ -364,9 +353,9 @@ class Command(BaseCommand):
             crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
             active_count = Currency.objects.filter(is_active=True).count()
             
-            # Count currencies with rates
+            # Count currencies with provider configs (simplified since rate fields don't exist)
             currencies_with_rates = Currency.objects.filter(
-                providercurrency__usd_rate__isnull=False
+                provider_configs__isnull=False
             ).distinct().count()
             
             rate_coverage = (currencies_with_rates / total_currencies * 100) if total_currencies > 0 else 0

django_cfg/apps/payments/management/commands/manage_providers.py

@@ -305,18 +305,18 @@ class Command(BaseCommand):
         self.stdout.write(f"   Enabled: {enabled_provider_currencies}")
         
         # Stats by provider
-        from django.db.models import Count
+        from django.db.models import Count, Q
         
-        provider_stats = ProviderCurrency.objects.values('provider_name').annotate(
+        provider_stats = ProviderCurrency.objects.values('provider').annotate(
             total=Count('id'),
-            enabled=Count('id', filter=models.Q(is_enabled=True))
+            enabled=Count('id', filter=Q(is_enabled=True))
         ).order_by('-total')
         
         if provider_stats:
             self.stdout.write(f"\n📈 By Provider:")
             for stat in provider_stats:
                 self.stdout.write(
-                    f"   - {stat['provider_name']}: {stat['total']} total, {stat['enabled']} enabled"
+                    f"   - {stat['provider']}: {stat['total']} total, {stat['enabled']} enabled"
                 )
         
         # Recent activity
@@ -330,7 +330,7 @@ class Command(BaseCommand):
         
         # Rate coverage
         currencies_with_rates = ProviderCurrency.objects.filter(
-            usd_rate__isnull=False
+            is_enabled=True
         ).count()
         
         rate_coverage = (currencies_with_rates / total_provider_currencies * 100) if total_provider_currencies > 0 else 0

django_cfg/apps/payments/middleware/api_access.py

@@ -44,8 +44,8 @@ class APIAccessMiddleware(MiddlewareMixin):
             
             # Configuration from django-cfg
             self.enabled = middleware_config['enabled']
-            self.api_prefixes = middleware_config['api_prefixes']
-            self.exempt_paths = middleware_config['exempt_paths']
+            self.protected_paths = middleware_config.get('protected_paths', [])
+            self.protected_patterns_raw = middleware_config.get('protected_patterns', [])
             self.cache_timeout = middleware_config['cache_timeouts']['api_key']
             
             # Default settings (can be overridden by Constance)
@@ -61,29 +61,32 @@ class APIAccessMiddleware(MiddlewareMixin):
             
         except Exception as e:
             logger.warning(f"Failed to load middleware config, using defaults: {e}")
-            # Fallback defaults
+            # Fallback defaults - whitelist approach
             self.enabled = True
-            self.api_prefixes = ['/api/']
-            self.exempt_paths = ['/api/health/', '/admin/']
+            self.protected_paths = [
+                '/api/admin/',  # Admin API endpoints
+                '/api/private/',  # Private API endpoints
+                '/api/secure/',  # Secure API endpoints
+            ]
+            self.protected_patterns_raw = [
+                r'^/api/admin/.*$',  # All admin API endpoints
+                r'^/api/private/.*$',  # All private API endpoints  
+                r'^/api/secure/.*$',  # All secure API endpoints
+            ]
             self.cache_timeout = 300
             self.strict_mode = False
             self.require_api_key = True
         
-        # Compile exempt path patterns (static for now)
-        self.exempt_patterns = [
-            re.compile(pattern) for pattern in [
-                r'^/api/payments/[^/]+/status/$',
-                r'^/api/webhooks/[^/]+/$',
-                r'^/api/payments/webhooks/(providers|health|stats)/$',  # Admin webhook endpoints
-                r'^/api/currencies/(rates|supported|convert)/$',
-            ]
+        # Compile protected path patterns
+        self.protected_patterns = [
+            re.compile(pattern) for pattern in self.protected_patterns_raw
         ]
         
         logger.info(f"API Access Middleware initialized", extra={
             'enabled': self.enabled,
             'strict_mode': self.strict_mode,
             'require_api_key': self.require_api_key,
-            'api_prefixes': self.api_prefixes
+            'protected_paths': self.protected_paths
         })
     
     def process_request(self, request: HttpRequest) -> Optional[JsonResponse]:
@@ -95,8 +98,8 @@ class APIAccessMiddleware(MiddlewareMixin):
         if not self.enabled:
             return None
         
-        # Check if this path requires authentication
-        if not self._requires_authentication(request.path):
+        # Check if this path is protected (whitelist approach)
+        if not self._is_protected_path(request.path):
             return None
         
         # Start timing for performance monitoring
@@ -177,26 +180,24 @@ class APIAccessMiddleware(MiddlewareMixin):
                 # Graceful degradation: allow access but log the issue
                 return None
     
-    def _requires_authentication(self, path: str) -> bool:
+    def _is_protected_path(self, path: str) -> bool:
         """
-        Check if the given path requires API authentication.
-        """
-        # Check if path starts with API prefix
-        requires_auth = any(path.startswith(prefix) for prefix in self.api_prefixes)
-        
-        if not requires_auth:
-            return False
+        Check if the given path is protected and requires API authentication.
         
-        # Check exempt paths
-        if path in self.exempt_paths:
-            return False
+        Whitelist approach: only paths explicitly listed as protected require API key.
+        """
+        # Check exact protected paths
+        for protected_path in self.protected_paths:
+            if path.startswith(protected_path):
+                return True
         
-        # Check exempt patterns
-        for pattern in self.exempt_patterns:
+        # Check protected patterns
+        for pattern in self.protected_patterns:
             if pattern.match(path):
-                return False
+                return True
         
-        return True
+        # Path is not protected - no API key required
+        return False
     
     def _extract_api_key(self, request: HttpRequest) -> Optional[str]:
         """
@@ -300,7 +301,7 @@ class APIAccessMiddleware(MiddlewareMixin):
                 user=api_key.user,
                 status=Subscription.SubscriptionStatus.ACTIVE,
                 expires_at__gt=timezone.now()
-            ).select_related('tariff', 'endpoint_group')
+            ).prefetch_related('endpoint_groups')
             
             if not active_subscriptions.exists():
                 return {
@@ -319,8 +320,8 @@ class APIAccessMiddleware(MiddlewareMixin):
                 'allowed': True,
                 'subscription_id': str(subscription.id),
                 'tier': subscription.tier,
-                'tariff_name': subscription.tariff.name if subscription.tariff else None,
-                'requests_remaining': subscription.requests_remaining(),
+                'tier_name': subscription.tier,
+                'requests_remaining': 'unlimited',  # TODO: Implement rate limiting per subscription
                 'expires_at': subscription.expires_at.isoformat() if subscription.expires_at else None
             }
             

django_cfg/apps/payments/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 5.2.6 on 2025-09-26 05:27
+# Generated by Django 5.2.6 on 2025-09-27 10:37
 
 import django.core.validators
 import django.db.models.deletion

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

@@ -93,6 +93,10 @@ class APIKeyManager(models.Manager):
         """Get API keys expiring soon."""
         return self.get_queryset().expiring_soon(days)
     
+    def by_user(self, user):
+        """Get API keys by user."""
+        return self.get_queryset().by_user(user)
+    
     # Business logic methods
     def increment_api_key_usage(self, api_key_id, ip_address=None):
         """

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

@@ -244,6 +244,11 @@ class PaymentManager(models.Manager):
         """Get active payments."""
         return self.get_queryset().active()
     
+    # User-based methods
+    def by_user(self, user):
+        """Get payments by user."""
+        return self.get_queryset().by_user(user)
+    
     # Provider-based methods
     def by_provider(self, provider):
         """Get payments by provider."""

django_cfg/apps/payments/models/subscriptions.py

@@ -102,30 +102,6 @@ class SubscriptionQuerySet(models.QuerySet):
         return self.filter(user=user)
 
 
-class SubscriptionManager(models.Manager):
-    """Manager for subscription operations."""
-    
-    def get_queryset(self):
-        """Return optimized queryset by default."""
-        return SubscriptionQuerySet(self.model, using=self._db)
-    
-    def optimized(self):
-        """Get optimized queryset."""
-        return self.get_queryset().optimized()
-    
-    def active(self):
-        """Get active subscriptions."""
-        return self.get_queryset().active()
-    
-    def expired(self):
-        """Get expired subscriptions."""
-        return self.get_queryset().expired()
-    
-    def by_tier(self, tier):
-        """Get subscriptions by tier."""
-        return self.get_queryset().by_tier(tier)
-
-
 class Subscription(UUIDTimestampedModel):
     """
     User subscription model for API access control.

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

@@ -4,7 +4,7 @@ Cache services for the Universal Payment System v2.0.
 Redis-backed caching with type safety and automatic key management.
 """
 
-from .cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
+from ..cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
 
 __all__ = [
     'CacheService',

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

@@ -5,10 +5,12 @@ Handles user balance operations and transaction management.
 """
 
 from typing import Optional, Dict, Any, List
-from django.contrib.auth.models import User
+from django.contrib.auth import get_user_model
 from django.db import models
 from django.utils import timezone
 
+User = get_user_model()
+
 from .base import BaseService
 from ..types import (
     BalanceUpdateRequest, BalanceResult, TransactionData,
@@ -141,7 +143,16 @@ class BalanceService(BaseService):
             
             # Convert to response data
             balance_data = BalanceData.model_validate(balance)
-            transaction_data = TransactionData.model_validate(transaction)
+            transaction_data = TransactionData(
+                id=str(transaction.id),
+                user_id=transaction.user_id,
+                amount=float(transaction.amount_usd),
+                transaction_type=transaction.transaction_type,
+                description=transaction.description,
+                payment_id=transaction.payment_id,
+                metadata=transaction.metadata or {},
+                created_at=transaction.created_at
+            )
             
             self._log_operation(
                 "update_balance",

django_cfg/apps/payments/services/integrations/ngrok_service.py

@@ -39,9 +39,9 @@ def get_api_base_url() -> str:
 
 
 def is_ngrok_available() -> bool:
-    """Check if ngrok tunnel is available."""
+    """Check if ngrok tunnel is actually active."""
     try:
-        from django_cfg.modules.django_ngrok import get_tunnel_url
-        return get_tunnel_url() is not None
+        from django_cfg.modules.django_ngrok import is_tunnel_active
+        return is_tunnel_active()
     except ImportError:
         return False

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

@@ -411,6 +411,26 @@ class ProviderRegistry:
         self._provider_configs[provider_name] = config_class
         logger.info(f"Registered provider class: {provider_name}")
     
+    def register_provider(self, provider_name: str, provider_instance: BaseProvider):
+        """
+        Register provider instance directly (for testing).
+        
+        Args:
+            provider_name: Provider name
+            provider_instance: Provider instance
+        """
+        self._providers[provider_name] = provider_instance
+        logger.info(f"Registered provider instance: {provider_name}")
+    
+    @property
+    def providers(self) -> Dict[str, BaseProvider]:
+        """Get dictionary of registered providers."""
+        return self._providers.copy()
+    
+    def list_providers(self) -> List[str]:
+        """Get list of registered provider names."""
+        return list(self._providers.keys())
+    
     def __len__(self) -> int:
         """Get number of initialized providers."""
         return len(self._providers)

django_cfg/apps/payments/signals/balance_signals.py

@@ -9,6 +9,7 @@ from django.db.models.signals import post_save, post_delete, pre_save
 from django.dispatch import receiver
 from django.core.cache import cache
 from django.utils import timezone
+from decimal import Decimal
 
 from ..models import UserBalance, Transaction
 from django_cfg.modules.django_logger import get_logger
@@ -22,7 +23,8 @@ def store_original_balance(sender, instance: UserBalance, **kwargs):
     if instance.pk:
         try:
             original = UserBalance.objects.get(pk=instance.pk)
-            instance._original_balance = original.balance_usd
+            # Ensure _original_balance is always Decimal
+            instance._original_balance = Decimal(str(original.balance_usd)) if original.balance_usd is not None else None
         except UserBalance.DoesNotExist:
             instance._original_balance = None
     else:
@@ -44,8 +46,9 @@ def handle_balance_change(sender, instance: UserBalance, created: bool, **kwargs
     else:
         # Check if balance changed
         if hasattr(instance, '_original_balance'):
-            old_balance = instance._original_balance or 0.0
-            new_balance = instance.balance_usd
+            # Ensure both values are Decimal for consistent arithmetic
+            old_balance = Decimal(str(instance._original_balance or 0.0))
+            new_balance = Decimal(str(instance.balance_usd))
             
             if old_balance != new_balance:
                 balance_change = new_balance - old_balance
@@ -143,7 +146,7 @@ def _handle_zero_balance(balance: UserBalance):
             f"zero_balance:{balance.user.id}",
             {
                 'timestamp': timezone.now().isoformat(),
-                'previous_balance': getattr(balance, '_original_balance', 0.0)
+                'previous_balance': getattr(balance, '_original_balance', Decimal('0.0'))
             },
             timeout=86400 * 7  # 7 days
         )