django-cfg 1.2.23__py3-none-any.whl → 1.2.27__py3-none-any.whl

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

@@ -0,0 +1,336 @@
+"""
+Management command to update currency data using django_currency database loader.
+
+This command automatically populates and updates the payments Currency model
+with fresh data from external APIs (CoinGecko, YFinance).
+
+Usage:
+    python manage.py update_currencies
+    python manage.py update_currencies --max-crypto 100 --max-fiat 20
+    python manage.py update_currencies --dry-run
+    python manage.py update_currencies --force-update
+"""
+
+import logging
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+from django.utils import timezone
+from django.conf import settings
+
+from django_cfg.modules.django_currency.database.database_loader import (
+    CurrencyDatabaseLoader,
+    DatabaseLoaderConfig,
+    create_database_loader
+)
+from django_cfg.apps.payments.models.currencies import Currency
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    Management command to update currency data.
+    
+    Features:
+    - Automatic detection of new currencies
+    - Rate updates for existing currencies
+    - Dry-run mode for testing
+    - Configurable limits for API calls
+    - Progress reporting
+    - Error handling and rollback
+    """
+    
+    help = 'Update currency data from external APIs (CoinGecko, YFinance)'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--max-crypto',
+            type=int,
+            default=500,
+            help='Maximum number of cryptocurrencies to load (default: 500)'
+        )
+        
+        parser.add_argument(
+            '--max-fiat',
+            type=int,
+            default=50,
+            help='Maximum number of fiat currencies to load (default: 50)'
+        )
+        
+        parser.add_argument(
+            '--min-market-cap',
+            type=float,
+            default=1000000,
+            help='Minimum market cap in USD for cryptocurrencies (default: 1M)'
+        )
+        
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be updated without making changes'
+        )
+        
+        parser.add_argument(
+            '--force-update',
+            action='store_true',
+            help='Force update all currencies even if recently updated'
+        )
+        
+        parser.add_argument(
+            '--exclude-stablecoins',
+            action='store_true',
+            help='Exclude stablecoins from cryptocurrency updates'
+        )
+        
+        parser.add_argument(
+            '--update-threshold-hours',
+            type=int,
+            default=6,
+            help='Only update currencies older than N hours (default: 6)'
+        )
+        
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Verbose output with detailed progress'
+        )
+    
+    def handle(self, *args, **options):
+        """Main command handler."""
+        
+        # Configure logging
+        log_level = logging.INFO if options['verbose'] else logging.WARNING
+        logging.getLogger('django_cfg.modules.django_currency').setLevel(log_level)
+        
+        self.stdout.write(
+            self.style.SUCCESS('🏦 Starting currency database update...')
+        )
+        
+        try:
+            # Create database loader with options
+            config = DatabaseLoaderConfig(
+                max_cryptocurrencies=options['max_crypto'],
+                max_fiat_currencies=options['max_fiat'],
+                min_market_cap_usd=options['min_market_cap'],
+                exclude_stablecoins=options['exclude_stablecoins'],
+                coingecko_delay=1.5,  # Be respectful to APIs
+                yfinance_delay=0.5
+            )
+            
+            loader = CurrencyDatabaseLoader(config)
+            
+            # Get statistics
+            stats = loader.get_statistics()
+            self.stdout.write(f"📊 Loader config: {stats['total_currencies']} currencies available")
+            self.stdout.write(f"   • {stats['total_fiat_currencies']} fiat currencies")
+            self.stdout.write(f"   • {stats['total_cryptocurrencies']} cryptocurrencies")
+            
+            # Check existing currencies
+            existing_count = Currency.objects.count()
+            self.stdout.write(f"📋 Current database: {existing_count} currencies")
+            
+            # Determine update strategy
+            if options['force_update']:
+                currencies_to_update = Currency.objects.all()
+                self.stdout.write("🔄 Force update mode: updating all currencies")
+            else:
+                threshold = timezone.now() - timedelta(hours=options['update_threshold_hours'])
+                currencies_to_update = Currency.objects.filter(
+                    rate_updated_at__lt=threshold
+                ) | Currency.objects.filter(rate_updated_at__isnull=True)
+                
+                self.stdout.write(
+                    f"⏰ Updating currencies older than {options['update_threshold_hours']} hours: "
+                    f"{currencies_to_update.count()} currencies"
+                )
+            
+            # Load fresh currency data
+            self.stdout.write("🌐 Fetching fresh currency data from APIs...")
+            fresh_currencies = loader.build_currency_database_data()
+            
+            if options['dry_run']:
+                self._handle_dry_run(fresh_currencies, currencies_to_update)
+            else:
+                self._handle_update(fresh_currencies, currencies_to_update, options)
+            
+        except KeyboardInterrupt:
+            self.stdout.write(
+                self.style.WARNING('\n⚠️ Update interrupted by user')
+            )
+            raise CommandError("Update cancelled by user")
+            
+        except Exception as e:
+            logger.exception("Currency update failed")
+            self.stdout.write(
+                self.style.ERROR(f'❌ Currency update failed: {str(e)}')
+            )
+            raise CommandError(f"Update failed: {str(e)}")
+    
+    def _handle_dry_run(self, fresh_currencies: List, currencies_to_update):
+        """Handle dry-run mode - show what would be updated."""
+        self.stdout.write(
+            self.style.WARNING('🧪 DRY RUN MODE - No changes will be made')
+        )
+        
+        # Analyze changes
+        existing_codes = set(Currency.objects.values_list('code', flat=True))
+        fresh_codes = {curr.code for curr in fresh_currencies}
+        
+        new_currencies = fresh_codes - existing_codes
+        existing_currencies = fresh_codes & existing_codes
+        
+        self.stdout.write(f"\n📈 Analysis:")
+        self.stdout.write(f"   • Would add {len(new_currencies)} new currencies")
+        self.stdout.write(f"   • Would update {len(existing_currencies)} existing currencies")
+        
+        if new_currencies:
+            self.stdout.write(f"\n➕ New currencies to add:")
+            for code in sorted(list(new_currencies)[:10]):  # Show first 10
+                currency = next(c for c in fresh_currencies if c.code == code)
+                self.stdout.write(f"   • {code}: {currency.name} ({currency.currency_type})")
+            if len(new_currencies) > 10:
+                self.stdout.write(f"   ... and {len(new_currencies) - 10} more")
+        
+        if existing_currencies:
+            self.stdout.write(f"\n🔄 Existing currencies to update:")
+            for code in sorted(list(existing_currencies)[:10]):  # Show first 10
+                currency = next(c for c in fresh_currencies if c.code == code)
+                try:
+                    existing = Currency.objects.get(code=code)
+                    rate_diff = abs(existing.usd_rate - currency.usd_rate)
+                    if rate_diff > 0.01:  # Significant change
+                        change_pct = ((currency.usd_rate - existing.usd_rate) / existing.usd_rate) * 100
+                        self.stdout.write(
+                            f"   • {code}: ${existing.usd_rate:.6f} → ${currency.usd_rate:.6f} "
+                            f"({change_pct:+.2f}%)"
+                        )
+                except Currency.DoesNotExist:
+                    pass
+        
+        self.stdout.write(
+            self.style.SUCCESS('\n✅ Dry run completed - use --force-update to apply changes')
+        )
+    
+    def _handle_update(self, fresh_currencies: List, currencies_to_update, options: Dict):
+        """Handle actual database update."""
+        
+        updated_count = 0
+        created_count = 0
+        errors = []
+        
+        # Create lookup for fresh data
+        fresh_data_map = {curr.code: curr for curr in fresh_currencies}
+        
+        try:
+            with transaction.atomic():
+                self.stdout.write("💾 Updating database...")
+                
+                # Process currencies
+                for i, fresh_currency in enumerate(fresh_currencies):
+                    try:
+                        currency, created = Currency.objects.update_or_create(
+                            code=fresh_currency.code,
+                            defaults={
+                                'name': fresh_currency.name,
+                                'symbol': fresh_currency.symbol,
+                                'currency_type': fresh_currency.currency_type,
+                                'decimal_places': fresh_currency.decimal_places,
+                                'usd_rate': fresh_currency.usd_rate,
+                                'min_payment_amount': fresh_currency.min_payment_amount,
+                                'is_active': fresh_currency.is_active,
+                                'rate_updated_at': timezone.now()
+                            }
+                        )
+                        
+                        if created:
+                            created_count += 1
+                            if options['verbose']:
+                                self.stdout.write(f"   ➕ Created {fresh_currency.code}")
+                        else:
+                            updated_count += 1
+                            if options['verbose']:
+                                self.stdout.write(f"   🔄 Updated {fresh_currency.code}")
+                        
+                        # Progress indicator
+                        if (i + 1) % 50 == 0:
+                            self.stdout.write(f"   Progress: {i + 1}/{len(fresh_currencies)} currencies processed")
+                    
+                    except Exception as e:
+                        error_msg = f"Failed to update {fresh_currency.code}: {str(e)}"
+                        errors.append(error_msg)
+                        logger.error(error_msg)
+                        
+                        # Continue with other currencies unless it's a critical error
+                        if len(errors) > 10:  # Too many errors
+                            raise CommandError(f"Too many errors ({len(errors)}), aborting")
+                
+                # Summary
+                total_processed = created_count + updated_count
+                self.stdout.write(f"\n📊 Update Summary:")
+                self.stdout.write(f"   ✅ Successfully processed: {total_processed} currencies")
+                self.stdout.write(f"   ➕ Created new: {created_count}")
+                self.stdout.write(f"   🔄 Updated existing: {updated_count}")
+                
+                if errors:
+                    self.stdout.write(f"   ⚠️ Errors: {len(errors)}")
+                    for error in errors[:5]:  # Show first 5 errors
+                        self.stdout.write(f"      • {error}")
+                    if len(errors) > 5:
+                        self.stdout.write(f"      ... and {len(errors) - 5} more errors")
+                
+                # Deactivate currencies not in fresh data (optional)
+                fresh_codes = {curr.code for curr in fresh_currencies}
+                stale_currencies = Currency.objects.filter(is_active=True).exclude(
+                    code__in=fresh_codes
+                )
+                
+                if stale_currencies.exists():
+                    self.stdout.write(f"   📋 Found {stale_currencies.count()} currencies not in fresh data")
+                    # Optionally deactivate them
+                    # stale_currencies.update(is_active=False)
+                
+                self.stdout.write(
+                    self.style.SUCCESS('✅ Currency database update completed successfully!')
+                )
+        
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f'❌ Update failed and rolled back: {str(e)}')
+            )
+            raise
+    
+    def _show_statistics(self):
+        """Show current currency statistics."""
+        total = Currency.objects.count()
+        fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
+        crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
+        active_count = Currency.objects.filter(is_active=True).count()
+        
+        # Recent updates
+        recent_threshold = timezone.now() - timedelta(hours=24)
+        recent_updates = Currency.objects.filter(rate_updated_at__gte=recent_threshold).count()
+        
+        self.stdout.write(f"\n📊 Current Database Statistics:")
+        self.stdout.write(f"   • Total currencies: {total}")
+        self.stdout.write(f"   • Fiat currencies: {fiat_count}")
+        self.stdout.write(f"   • Cryptocurrencies: {crypto_count}")
+        self.stdout.write(f"   • Active currencies: {active_count}")
+        self.stdout.write(f"   • Updated in last 24h: {recent_updates}")
+        
+        # Show some examples
+        recent_currencies = Currency.objects.filter(
+            rate_updated_at__gte=recent_threshold
+        ).order_by('-rate_updated_at')[:5]
+        
+        if recent_currencies:
+            self.stdout.write(f"\n🕒 Recently updated currencies:")
+            for currency in recent_currencies:
+                age = timezone.now() - currency.rate_updated_at
+                hours_ago = int(age.total_seconds() / 3600)
+                self.stdout.write(
+                    f"   • {currency.code}: ${currency.usd_rate:.6f} ({hours_ago}h ago)"
+                )

django_cfg/apps/payments/managers/currency_manager.py

@@ -1,32 +1,83 @@
 """
-Currency managers.
+Manager for Currency model.
 """
 
 from django.db import models
+from django.utils import timezone
+from datetime import timedelta
+from typing import List, Optional
 
 
 class CurrencyManager(models.Manager):
-    """Manager for Currency model."""
+    """Manager for Currency model with convenient query methods."""
     
-    def get_active_currencies(self):
-        """Get active currencies."""
+    def active(self):
+        """Get only active currencies."""
         return self.filter(is_active=True)
     
-    def get_fiat_currencies(self):
-        """Get fiat currencies."""
+    def fiat(self):
+        """Get only fiat currencies."""
+        return self.filter(currency_type='fiat')
+    
+    def crypto(self):
+        """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 get_crypto_currencies(self):
-        """Get cryptocurrencies."""
+    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)
+        )
 
 
 class CurrencyNetworkManager(models.Manager):
     """Manager for CurrencyNetwork model."""
     
-    def get_active_networks(self, currency=None):
-        """Get active networks."""
-        queryset = self.filter(is_active=True)
-        if currency:
-            queryset = queryset.filter(currency=currency)
-        return queryset
+    def active(self):
+        """Get only active networks."""
+        return self.filter(is_active=True)
+    
+    def for_currency(self, currency_code: str):
+        """Get networks for a specific currency."""
+        return self.filter(currency__code__iexact=currency_code)
+    
+    def active_for_currency(self, currency_code: str):
+        """Get active networks for a specific currency."""
+        return self.active().filter(currency__code__iexact=currency_code)

django_cfg/apps/payments/middleware/api_access.py

@@ -11,6 +11,7 @@ from django.conf import settings
 from django.utils import timezone
 from ..models import APIKey, Subscription, EndpointGroup
 from ..services import ApiKeyCache, RateLimitCache
+from ..services.security import error_handler, SecurityError
 
 logger = logging.getLogger(__name__)
 
@@ -58,6 +59,15 @@ class APIAccessMiddleware(MiddlewareMixin):
         # Extract API key
         api_key = self._extract_api_key(request)
         if not api_key:
+            security_error = SecurityError(
+                "API key required for protected endpoint",
+                details={'path': request.path, 'method': request.method}
+            )
+            error_handler.handle_error(security_error, {
+                'middleware': 'api_access',
+                'operation': 'api_key_extraction'
+            }, request)
+            
             return self._error_response(
                 'API key required', 
                 status=401,
@@ -67,6 +77,20 @@ class APIAccessMiddleware(MiddlewareMixin):
         # Validate API key
         api_key_obj = self._validate_api_key(api_key)
         if not api_key_obj:
+            security_error = SecurityError(
+                f"Invalid or expired API key attempted",
+                details={
+                    'api_key_prefix': api_key[:8] + '...' if len(api_key) > 8 else api_key,
+                    'path': request.path,
+                    'method': request.method,
+                    'ip_address': self._get_client_ip(request)
+                }
+            )
+            error_handler.handle_error(security_error, {
+                'middleware': 'api_access',
+                'operation': 'api_key_validation'
+            }, request)
+            
             return self._error_response(
                 'Invalid or expired API key',
                 status=401,
@@ -249,6 +273,15 @@ class APIAccessMiddleware(MiddlewareMixin):
         except Exception as e:
             logger.error(f"Error tracking usage: {e}")
     
+    def _get_client_ip(self, request: HttpRequest) -> str:
+        """Extract client IP address from request."""
+        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+        if x_forwarded_for:
+            ip = x_forwarded_for.split(',')[0].strip()
+        else:
+            ip = request.META.get('REMOTE_ADDR', '')
+        return ip
+    
     def _error_response(self, message: str, status: int = 400, error_code: str = 'ERROR') -> JsonResponse:
         """Return standardized error response."""
         

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

@@ -1,4 +1,4 @@
-# Generated by Django 5.2.6 on 2025-09-23 14:27
+# Generated by Django 5.2.6 on 2025-09-24 07:15
 
 import django.core.validators
 import django.db.models.deletion
@@ -498,6 +498,8 @@ class Migration(migrations.Migration):
                     models.CharField(
                         choices=[
                             ("nowpayments", "NowPayments"),
+                            ("cryptapi", "CryptAPI"),
+                            ("cryptomus", "Cryptomus"),
                             ("stripe", "Stripe"),
                             ("internal", "Internal"),
                         ],
@@ -577,6 +579,76 @@ class Migration(migrations.Migration):
                         blank=True, help_text="Raw webhook data from provider", null=True
                     ),
                 ),
+                (
+                    "security_nonce",
+                    models.CharField(
+                        blank=True,
+                        db_index=True,
+                        help_text="Security nonce for replay attack protection (CryptAPI, Cryptomus, etc.)",
+                        max_length=64,
+                        null=True,
+                    ),
+                ),
+                (
+                    "provider_callback_url",
+                    models.CharField(
+                        blank=True,
+                        help_text="Full callback URL with security parameters",
+                        max_length=512,
+                        null=True,
+                    ),
+                ),
+                (
+                    "transaction_hash",
+                    models.CharField(
+                        blank=True,
+                        db_index=True,
+                        help_text="Main transaction hash/ID (txid_in for CryptAPI, hash for Cryptomus)",
+                        max_length=256,
+                        null=True,
+                    ),
+                ),
+                (
+                    "confirmation_hash",
+                    models.CharField(
+                        blank=True,
+                        help_text="Secondary transaction hash (txid_out for CryptAPI, confirmation for others)",
+                        max_length=256,
+                        null=True,
+                    ),
+                ),
+                (
+                    "sender_address",
+                    models.CharField(
+                        blank=True,
+                        help_text="Sender address (address_in for CryptAPI, from_address for Cryptomus)",
+                        max_length=200,
+                        null=True,
+                    ),
+                ),
+                (
+                    "receiver_address",
+                    models.CharField(
+                        blank=True,
+                        help_text="Receiver address (address_out for CryptAPI, to_address for Cryptomus)",
+                        max_length=200,
+                        null=True,
+                    ),
+                ),
+                (
+                    "crypto_amount",
+                    models.FloatField(
+                        blank=True,
+                        help_text="Amount in cryptocurrency units (value_coin for CryptAPI, amount for Cryptomus)",
+                        null=True,
+                    ),
+                ),
+                (
+                    "confirmations_count",
+                    models.PositiveIntegerField(
+                        default=0, help_text="Number of blockchain confirmations"
+                    ),
+                ),
                 (
                     "expires_at",
                     models.DateTimeField(
@@ -964,6 +1036,27 @@ class Migration(migrations.Migration):
             model_name="universalpayment",
             index=models.Index(fields=["processed_at"], name="universal_p_process_1c8a1f_idx"),
         ),
+        migrations.AddIndex(
+            model_name="universalpayment",
+            index=models.Index(fields=["security_nonce"], name="universal_p_securit_4a38cc_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="universalpayment",
+            index=models.Index(fields=["transaction_hash"], name="universal_p_transac_8a27c6_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="universalpayment",
+            index=models.Index(
+                fields=["confirmations_count"], name="universal_p_confirm_8df8c9_idx"
+            ),
+        ),
+        migrations.AddIndex(
+            model_name="universalpayment",
+            index=models.Index(
+                fields=["provider", "status", "confirmations_count"],
+                name="universal_p_provide_3c8a34_idx",
+            ),
+        ),
         migrations.AddIndex(
             model_name="transaction",
             index=models.Index(