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

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

@@ -0,0 +1,434 @@
+"""
+Test Providers Management Command for Universal Payment System v2.0.
+
+Test payment provider connections, configurations, and functionality.
+"""
+
+from typing import List, Dict, Any, Optional
+from decimal import Decimal
+import time
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.services.providers.registry import get_provider_registry
+from django_cfg.apps.payments.models import Currency, Network
+from django_cfg.apps.payments.services.types.requests import PaymentCreateRequest
+
+logger = get_logger("test_providers")
+
+
+class Command(BaseCommand):
+    """
+    Test payment provider connections and functionality.
+    
+    Features:
+    - Test provider connectivity
+    - Validate configurations
+    - Test currency support
+    - Check API responses
+    - Performance testing
+    """
+    
+    help = 'Test payment provider connections and functionality'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--provider',
+            type=str,
+            help='Test specific provider only'
+        )
+        
+        parser.add_argument(
+            '--test-type',
+            choices=['connectivity', 'currencies', 'payment', 'all'],
+            default='all',
+            help='Type of test to run (default: all)'
+        )
+        
+        parser.add_argument(
+            '--timeout',
+            type=int,
+            default=30,
+            help='Request timeout in seconds (default: 30)'
+        )
+        
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Show detailed test information'
+        )
+        
+        parser.add_argument(
+            '--create-test-payment',
+            action='store_true',
+            help='Create actual test payment (use with caution!)'
+        )
+        
+        parser.add_argument(
+            '--test-amount',
+            type=float,
+            default=1.0,
+            help='Test payment amount in USD (default: 1.0)'
+        )
+    
+    def handle(self, *args, **options):
+        """Execute the command."""
+        try:
+            self.options = options
+            self.verbose = options['verbose']
+            
+            self.show_header()
+            
+            # Get provider registry
+            self.provider_registry = get_provider_registry()
+            
+            # Initialize test results
+            self.test_results = {}
+            
+            # Get providers to test
+            if options['provider']:
+                providers = [options['provider']]
+            else:
+                providers = self.provider_registry.get_available_providers()
+            
+            if not providers:
+                self.stdout.write(self.style.WARNING("No providers available to test"))
+                return
+            
+            # Run tests
+            for provider_name in providers:
+                self.test_provider(provider_name)
+            
+            self.show_summary()
+            
+        except Exception as e:
+            logger.error(f"Test providers command failed: {e}")
+            raise CommandError(f"Failed to test providers: {e}")
+    
+    def show_header(self):
+        """Display command header."""
+        self.stdout.write(
+            self.style.SUCCESS("=" * 60)
+        )
+        self.stdout.write(
+            self.style.SUCCESS("🧪 PAYMENT PROVIDER TESTING")
+        )
+        self.stdout.write(
+            self.style.SUCCESS("=" * 60)
+        )
+        self.stdout.write(f"Started: {timezone.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        self.stdout.write("")
+    
+    def test_provider(self, provider_name: str):
+        """Test a specific provider."""
+        self.stdout.write(self.style.SUCCESS(f"🔍 TESTING PROVIDER: {provider_name.upper()}"))
+        self.stdout.write("-" * 50)
+        
+        # Initialize provider results
+        self.test_results[provider_name] = {
+            'connectivity': False,
+            'currencies': False,
+            'payment': False,
+            'errors': [],
+            'warnings': [],
+            'performance': {}
+        }
+        
+        try:
+            # Get provider instance
+            provider = self.provider_registry.get_provider(provider_name)
+            if not provider:
+                self.test_results[provider_name]['errors'].append("Provider not available")
+                self.stdout.write(self.style.ERROR(f"❌ Provider {provider_name} not available"))
+                return
+            
+            # Run selected tests
+            test_type = self.options['test_type']
+            
+            if test_type in ['connectivity', 'all']:
+                self.test_connectivity(provider_name, provider)
+            
+            if test_type in ['currencies', 'all']:
+                self.test_currencies(provider_name, provider)
+            
+            if test_type in ['payment', 'all'] and self.options['create_test_payment']:
+                self.test_payment_creation(provider_name, provider)
+            
+        except Exception as e:
+            error_msg = f"Provider test failed: {e}"
+            self.test_results[provider_name]['errors'].append(error_msg)
+            logger.error(f"Error testing provider {provider_name}: {e}")
+            self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
+        
+        self.stdout.write("")
+    
+    def test_connectivity(self, provider_name: str, provider):
+        """Test provider connectivity."""
+        self.stdout.write("  🌐 Testing connectivity...")
+        
+        try:
+            start_time = time.time()
+            
+            # Test basic connectivity (health check or similar)
+            if hasattr(provider, 'health_check'):
+                result = provider.health_check()
+                success = result.success if hasattr(result, 'success') else True
+            elif hasattr(provider, 'get_supported_currencies'):
+                # Fallback: try to get currencies as connectivity test
+                result = provider.get_supported_currencies()
+                success = len(result) > 0 if isinstance(result, list) else bool(result)
+            else:
+                # Last resort: assume connectivity is OK if provider exists
+                success = True
+            
+            end_time = time.time()
+            response_time = (end_time - start_time) * 1000  # Convert to milliseconds
+            
+            self.test_results[provider_name]['performance']['connectivity_ms'] = response_time
+            
+            if success:
+                self.test_results[provider_name]['connectivity'] = True
+                self.stdout.write(f"    ✅ Connectivity OK ({response_time:.0f}ms)")
+            else:
+                self.test_results[provider_name]['errors'].append("Connectivity test failed")
+                self.stdout.write(f"    ❌ Connectivity failed")
+                
+        except Exception as e:
+            error_msg = f"Connectivity test error: {e}"
+            self.test_results[provider_name]['errors'].append(error_msg)
+            self.stdout.write(f"    ❌ Connectivity error: {e}")
+    
+    def test_currencies(self, provider_name: str, provider):
+        """Test provider currency support."""
+        self.stdout.write("  💰 Testing currency support...")
+        
+        try:
+            start_time = time.time()
+            
+            # Get supported currencies from provider
+            if hasattr(provider, 'get_supported_currencies'):
+                supported_currencies = provider.get_supported_currencies()
+            else:
+                self.test_results[provider_name]['warnings'].append("Provider doesn't support currency listing")
+                self.stdout.write("    ⚠️  Provider doesn't support currency listing")
+                return
+            
+            end_time = time.time()
+            response_time = (end_time - start_time) * 1000
+            
+            self.test_results[provider_name]['performance']['currencies_ms'] = response_time
+            
+            if isinstance(supported_currencies, list) and len(supported_currencies) > 0:
+                self.test_results[provider_name]['currencies'] = True
+                currency_count = len(supported_currencies)
+                self.stdout.write(f"    ✅ {currency_count} currencies supported ({response_time:.0f}ms)")
+                
+                if self.verbose:
+                    # Show first few currencies
+                    sample_currencies = supported_currencies[:5]
+                    currency_codes = [c.get('code', str(c)) for c in sample_currencies]
+                    self.stdout.write(f"    Sample: {', '.join(currency_codes)}")
+                
+                # Check if our database currencies are supported
+                our_currencies = Currency.objects.filter(is_active=True)[:10]
+                supported_codes = []
+                
+                if isinstance(supported_currencies[0], dict):
+                    supported_codes = [c.get('code', '').upper() for c in supported_currencies]
+                else:
+                    supported_codes = [str(c).upper() for c in supported_currencies]
+                
+                matching_count = 0
+                for currency in our_currencies:
+                    if currency.code.upper() in supported_codes:
+                        matching_count += 1
+                
+                if matching_count > 0:
+                    self.stdout.write(f"    ✅ {matching_count}/{our_currencies.count()} of our currencies supported")
+                else:
+                    self.test_results[provider_name]['warnings'].append("No matching currencies found")
+                    self.stdout.write("    ⚠️  No matching currencies found")
+                    
+            else:
+                self.test_results[provider_name]['errors'].append("No currencies returned")
+                self.stdout.write("    ❌ No currencies returned")
+                
+        except Exception as e:
+            error_msg = f"Currency test error: {e}"
+            self.test_results[provider_name]['errors'].append(error_msg)
+            self.stdout.write(f"    ❌ Currency test error: {e}")
+    
+    def test_payment_creation(self, provider_name: str, provider):
+        """Test payment creation (creates actual test payment!)."""
+        self.stdout.write("  💳 Testing payment creation...")
+        self.stdout.write("    ⚠️  WARNING: This creates an actual payment!")
+        
+        try:
+            # Get a supported currency for testing
+            test_currency = self.get_test_currency(provider)
+            if not test_currency:
+                self.test_results[provider_name]['warnings'].append("No suitable test currency found")
+                self.stdout.write("    ⚠️  No suitable test currency found")
+                return
+            
+            # Create test payment request
+            payment_request = PaymentCreateRequest(
+                amount_usd=self.options['test_amount'],
+                currency_code=test_currency,
+                description=f"Test payment from django-cfg ({timezone.now().isoformat()})",
+                callback_url="https://example.com/webhook/test",
+                success_url="https://example.com/success",
+                cancel_url="https://example.com/cancel"
+            )
+            
+            start_time = time.time()
+            
+            # Create payment
+            result = provider.create_payment(payment_request)
+            
+            end_time = time.time()
+            response_time = (end_time - start_time) * 1000
+            
+            self.test_results[provider_name]['performance']['payment_creation_ms'] = response_time
+            
+            if hasattr(result, 'success') and result.success:
+                self.test_results[provider_name]['payment'] = True
+                payment_id = getattr(result, 'provider_payment_id', 'Unknown')
+                payment_url = getattr(result, 'payment_url', 'No URL')
+                
+                self.stdout.write(f"    ✅ Payment created ({response_time:.0f}ms)")
+                self.stdout.write(f"    Payment ID: {payment_id}")
+                
+                if self.verbose and payment_url != 'No URL':
+                    self.stdout.write(f"    Payment URL: {payment_url}")
+                
+                # Test payment status check
+                if hasattr(provider, 'get_payment_status') and payment_id != 'Unknown':
+                    try:
+                        status_result = provider.get_payment_status(payment_id)
+                        if hasattr(status_result, 'success') and status_result.success:
+                            status = getattr(status_result, 'status', 'Unknown')
+                            self.stdout.write(f"    ✅ Status check OK: {status}")
+                        else:
+                            self.test_results[provider_name]['warnings'].append("Status check failed")
+                            self.stdout.write("    ⚠️  Status check failed")
+                    except Exception as e:
+                        self.test_results[provider_name]['warnings'].append(f"Status check error: {e}")
+                        self.stdout.write(f"    ⚠️  Status check error: {e}")
+                
+            else:
+                error = getattr(result, 'error', 'Unknown error')
+                self.test_results[provider_name]['errors'].append(f"Payment creation failed: {error}")
+                self.stdout.write(f"    ❌ Payment creation failed: {error}")
+                
+        except Exception as e:
+            error_msg = f"Payment creation error: {e}"
+            self.test_results[provider_name]['errors'].append(error_msg)
+            self.stdout.write(f"    ❌ Payment creation error: {e}")
+    
+    def get_test_currency(self, provider) -> Optional[str]:
+        """Get a suitable currency for testing."""
+        # Common test currencies
+        test_currencies = ['BTC', 'ETH', 'USDT', 'LTC', 'USD']
+        
+        try:
+            # Get supported currencies from provider
+            if hasattr(provider, 'get_supported_currencies'):
+                supported = provider.get_supported_currencies()
+                
+                if isinstance(supported, list) and len(supported) > 0:
+                    # Extract currency codes
+                    if isinstance(supported[0], dict):
+                        supported_codes = [c.get('code', '').upper() for c in supported]
+                    else:
+                        supported_codes = [str(c).upper() for c in supported]
+                    
+                    # Find first matching test currency
+                    for currency in test_currencies:
+                        if currency in supported_codes:
+                            return currency
+                    
+                    # Fallback: return first supported currency
+                    if supported_codes:
+                        return supported_codes[0]
+            
+            # Last resort: try BTC
+            return 'BTC'
+            
+        except Exception:
+            return 'BTC'
+    
+    def show_summary(self):
+        """Display test summary."""
+        self.stdout.write(self.style.SUCCESS("📊 TEST SUMMARY"))
+        self.stdout.write("-" * 40)
+        
+        total_providers = len(self.test_results)
+        successful_providers = 0
+        total_errors = 0
+        total_warnings = 0
+        
+        for provider_name, results in self.test_results.items():
+            errors = len(results['errors'])
+            warnings = len(results['warnings'])
+            
+            total_errors += errors
+            total_warnings += warnings
+            
+            # Count as successful if no errors and at least one test passed
+            if errors == 0 and (results['connectivity'] or results['currencies']):
+                successful_providers += 1
+            
+            # Show provider summary
+            status_icon = "✅" if errors == 0 else "❌"
+            self.stdout.write(f"{status_icon} {provider_name}:")
+            
+            if results['connectivity']:
+                self.stdout.write("    ✅ Connectivity")
+            if results['currencies']:
+                self.stdout.write("    ✅ Currencies")
+            if results['payment']:
+                self.stdout.write("    ✅ Payment Creation")
+            
+            if errors > 0:
+                self.stdout.write(f"    ❌ {errors} error(s)")
+            if warnings > 0:
+                self.stdout.write(f"    ⚠️  {warnings} warning(s)")
+            
+            # Show performance metrics
+            if self.verbose and results['performance']:
+                perf = results['performance']
+                if 'connectivity_ms' in perf:
+                    self.stdout.write(f"    ⏱️  Connectivity: {perf['connectivity_ms']:.0f}ms")
+                if 'currencies_ms' in perf:
+                    self.stdout.write(f"    ⏱️  Currencies: {perf['currencies_ms']:.0f}ms")
+                if 'payment_creation_ms' in perf:
+                    self.stdout.write(f"    ⏱️  Payment: {perf['payment_creation_ms']:.0f}ms")
+        
+        # Overall summary
+        self.stdout.write("")
+        self.stdout.write(f"Providers tested: {total_providers}")
+        self.stdout.write(f"Successful: {self.style.SUCCESS(successful_providers)}")
+        self.stdout.write(f"Failed: {self.style.ERROR(total_providers - successful_providers)}")
+        self.stdout.write(f"Total errors: {self.style.ERROR(total_errors)}")
+        self.stdout.write(f"Total warnings: {self.style.WARNING(total_warnings)}")
+        
+        # Show completion time
+        self.stdout.write("")
+        self.stdout.write(f"Completed: {timezone.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        
+        # Recommendations
+        if total_errors > 0:
+            self.stdout.write("")
+            self.stdout.write(
+                self.style.WARNING("⚠️  Some providers have errors. Check configurations and network connectivity.")
+            )
+        
+        if successful_providers == total_providers and total_errors == 0:
+            self.stdout.write("")
+            self.stdout.write(
+                self.style.SUCCESS("🎉 All providers tested successfully!")
+            )

django_cfg/apps/payments/models/balance.py

@@ -239,6 +239,9 @@ class Transaction(UUIDTimestampedModel):
     
     def save(self, *args, **kwargs):
         """Override save to ensure immutability."""
-        if self.pk:
-            raise ValidationError("Transactions are immutable and cannot be modified")
+        # Only prevent updates, not creation
+        if self.pk and not kwargs.get('force_insert', False):
+            # Check if this is actually an update (record exists in DB)
+            if Transaction.objects.filter(pk=self.pk).exists():
+                raise ValidationError("Transactions are immutable and cannot be modified")
         super().save(*args, **kwargs)

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

@@ -230,7 +230,7 @@ class APIKeyManager(models.Manager):
             logger.info(f"Created API key for user", extra={
                 'api_key_id': str(api_key.id),
                 'user_id': user.id,
-                'name': name,
+                'key_name': name,
                 'expires_in_days': expires_in_days
             })
             
@@ -239,7 +239,7 @@ class APIKeyManager(models.Manager):
         except Exception as e:
             logger.error(f"Failed to create API key: {e}", extra={
                 'user_id': user.id,
-                'name': name
+                'key_name': name
             })
             raise
     

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

@@ -4,7 +4,7 @@ Balance and transaction managers for the Universal Payment System v2.0.
 Optimized querysets and managers for balance and transaction operations.
 """
 
-from django.db import models
+from django.db import models, transaction
 from django.utils import timezone
 from django_cfg.modules.django_logger import get_logger
 
@@ -62,7 +62,7 @@ class UserBalanceManager(models.Manager):
         # Get or create balance
         balance = self.get_or_create_for_user(user)
         
-        with models.transaction.atomic():
+        with transaction.atomic():
             # Update balance
             balance.balance_usd += amount
             balance.total_deposited += amount
@@ -122,7 +122,7 @@ class UserBalanceManager(models.Manager):
         if amount > balance.balance_usd:
             raise ValueError(f"Insufficient balance: ${balance.balance_usd:.2f} < ${amount:.2f}")
         
-        with models.transaction.atomic():
+        with transaction.atomic():
             # Update balance
             balance.balance_usd -= amount
             balance.total_spent += amount

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

@@ -544,7 +544,7 @@ class SubscriptionManager(models.Manager):
             else:
                 subscription = subscription_id
             
-            subscription.status = subscription.model.SubscriptionStatus.CANCELLED
+            subscription.status = self.model.SubscriptionStatus.CANCELLED
             subscription.save(update_fields=['status', 'updated_at'])
             
             logger.info(f"Subscription cancelled", extra={
@@ -580,7 +580,7 @@ class SubscriptionManager(models.Manager):
             
             from datetime import timedelta
             
-            if subscription.is_expired:
+            if subscription.expires_at <= timezone.now():
                 # If expired, start from now
                 subscription.starts_at = timezone.now()
                 subscription.expires_at = subscription.starts_at + timedelta(days=duration_days)
@@ -588,7 +588,7 @@ class SubscriptionManager(models.Manager):
                 # If not expired, extend from current expiration
                 subscription.expires_at += timedelta(days=duration_days)
             
-            subscription.status = subscription.model.SubscriptionStatus.ACTIVE
+            subscription.status = self.model.SubscriptionStatus.ACTIVE
             subscription.save(update_fields=['starts_at', 'expires_at', 'status', 'updated_at'])
             
             logger.info(f"Subscription renewed", extra={

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

@@ -0,0 +1,143 @@
+"""
+Cache services for the Universal Payment System v2.0.
+
+Main entry point for cache functionality.
+Based on proven solutions from payments_old with improvements.
+ONLY for API access control - NOT payment data!
+"""
+
+from typing import Dict, Any
+from django.core.cache import cache
+from django_cfg.modules.django_logger import get_logger
+
+from .interfaces import CacheInterface
+from .simple_cache import SimpleCache
+from .api_key_cache import ApiKeyCache
+from .rate_limit_cache import RateLimitCache
+from .keys import CacheKeys
+
+logger = get_logger(__name__)
+
+
+class CacheService:
+    """
+    Main cache service providing access to specialized caches.
+    
+    Provides centralized access to different cache types.
+    """
+    
+    def __init__(self):
+        """Initialize cache service with specialized caches."""
+        self.simple_cache = SimpleCache()
+        self.api_key_cache = ApiKeyCache()
+        self.rate_limit_cache = RateLimitCache()
+        # Backward compatibility attributes
+        self.default_timeout = 300
+        self.key_prefix = "payments"
+    
+    # Backward compatibility methods - delegate to simple_cache
+    def get(self, key: str):
+        """Get value from cache."""
+        return self.simple_cache.get(key)
+    
+    def set(self, key: str, value, timeout=None):
+        """Set value in cache."""
+        return self.simple_cache.set(key, value, timeout)
+    
+    def delete(self, key: str):
+        """Delete value from cache."""
+        return self.simple_cache.delete(key)
+    
+    def exists(self, key: str):
+        """Check if key exists in cache."""
+        return self.simple_cache.exists(key)
+    
+    def get_or_set(self, key: str, default, timeout=None):
+        """Get value or set default if not exists."""
+        value = self.get(key)
+        if value is None:
+            if callable(default):
+                value = default()
+            else:
+                value = default
+            self.set(key, value, timeout)
+        return value
+    
+    def set_many(self, data: dict, timeout=None):
+        """Set multiple values."""
+        for key, value in data.items():
+            self.set(key, value, timeout)
+    
+    def get_many(self, keys: list):
+        """Get multiple values."""
+        result = {}
+        for key in keys:
+            value = self.get(key)
+            if value is not None:
+                result[key] = value
+        return result
+    
+    def delete_many(self, keys: list):
+        """Delete multiple values."""
+        for key in keys:
+            self.delete(key)
+    
+    def clear(self):
+        """Clear all cache (not implemented for safety)."""
+        # For safety, we don't implement cache.clear() 
+        # as it would clear the entire cache backend
+        # Instead, we clear Django's cache which is safe for tests
+        from django.core.cache import cache
+        cache.clear()
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Check cache health."""
+        try:
+            test_key = "health_check"
+            test_value = "ok"
+            
+            # Test set/get/delete
+            self.simple_cache.set(test_key, test_value, 10)
+            retrieved = self.simple_cache.get(test_key)
+            self.simple_cache.delete(test_key)
+            
+            is_healthy = retrieved == test_value
+            
+            return {
+                'healthy': is_healthy,
+                'backend': cache.__class__.__name__,
+                'simple_cache': True,
+                'api_key_cache': True,
+                'rate_limit_cache': True
+            }
+        except Exception as e:
+            logger.error(f"Cache health check failed: {e}")
+            return {
+                'healthy': False,
+                'error': str(e),
+                'backend': cache.__class__.__name__
+            }
+
+
+# Global cache service instance
+_cache_service = None
+
+
+def get_cache_service() -> CacheService:
+    """Get global cache service instance."""
+    global _cache_service
+    if _cache_service is None:
+        _cache_service = CacheService()
+    return _cache_service
+
+
+# Export main classes for backward compatibility
+__all__ = [
+    'CacheService',
+    'CacheInterface', 
+    'SimpleCache',
+    'ApiKeyCache',
+    'RateLimitCache',
+    'CacheKeys',
+    'get_cache_service'
+]