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

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

@@ -0,0 +1,229 @@
+"""
+Universal currency management command.
+
+Combines populate_currencies, update_currencies, and update_currency_rates into one.
+
+Usage:
+    python manage.py manage_currencies                          # Update existing currencies and rates
+    python manage.py manage_currencies --populate               # Initial population + rates
+    python manage.py manage_currencies --rates-only             # Only update USD rates
+    python manage.py manage_currencies --max-crypto 50          # Limit crypto currencies
+    python manage.py manage_currencies --force                  # Force refresh all data
+"""
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+from django.utils import timezone
+from django.db.models import Q
+from datetime import timedelta
+from decimal import Decimal
+import time
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_currency.database.database_loader import (
+    create_database_loader,
+    DatabaseLoaderConfig
+)
+from django_cfg.apps.payments.models import Currency
+
+logger = get_logger("manage_currencies")
+
+
+class Command(BaseCommand):
+    """Universal currency management command."""
+    
+    help = 'Manage currencies: populate, update, and refresh USD rates'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--populate',
+            action='store_true',
+            help='Initial population mode (for empty database)'
+        )
+        parser.add_argument(
+            '--rates-only',
+            action='store_true',
+            help='Only update USD exchange rates'
+        )
+        parser.add_argument(
+            '--max-crypto',
+            type=int,
+            default=200,
+            help='Maximum number of cryptocurrencies to process (default: 200)'
+        )
+        parser.add_argument(
+            '--max-fiat',
+            type=int,
+            default=50,
+            help='Maximum number of fiat currencies to process (default: 50)'
+        )
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help='Force refresh all data even if fresh'
+        )
+        parser.add_argument(
+            '--currency',
+            type=str,
+            help='Update specific currency by code (e.g., BTC, ETH)'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be done without making changes'
+        )
+        
+    def handle(self, *args, **options):
+        """Execute the command."""
+        start_time = time.time()
+        
+        self.stdout.write('=' * 60)
+        self.stdout.write(self.style.SUCCESS('🚀 Currency Management Tool'))
+        self.stdout.write('=' * 60)
+        
+        # Determine mode
+        if options['rates_only']:
+            result = self._update_rates_only(options)
+        elif options['populate']:
+            result = self._populate_and_update(options)
+        else:
+            result = self._update_existing(options)
+            
+        # Show summary
+        elapsed = time.time() - start_time
+        self.stdout.write('=' * 60)
+        self.stdout.write(f"⏱️  Completed in {elapsed:.2f} seconds")
+        self.stdout.write('=' * 60)
+        
+        # Commands should not return values to stdout
+        pass
+        
+    def _update_rates_only(self, options):
+        """Update only USD exchange rates."""
+        self.stdout.write("💱 Updating USD exchange rates...")
+        
+        if options['currency']:
+            currencies = Currency.objects.filter(code__iexact=options['currency'])
+            if not currencies.exists():
+                raise CommandError(f"Currency '{options['currency']}' not found")
+        else:
+            # Update all currencies, prioritizing those without rates or stale rates
+            stale_threshold = timezone.now() - timedelta(days=1)
+            currencies = Currency.objects.filter(
+                Q(usd_rate__isnull=True) | 
+                Q(rate_updated_at__isnull=True) |
+                Q(rate_updated_at__lt=stale_threshold)
+            )
+        
+        updated_count = 0
+        error_count = 0
+        
+        self.stdout.write(f"📊 Processing {currencies.count()} currencies...")
+        
+        for currency in currencies:
+            if options['dry_run']:
+                self.stdout.write(f"   [DRY RUN] Would update {currency.code}")
+                continue
+                
+            try:
+                # Force refresh if requested
+                rate = Currency.objects.get_usd_rate(
+                    currency.code, 
+                    force_refresh=options['force']
+                )
+                
+                if rate > 0:
+                    self.stdout.write(f"   ✅ {currency.code}: ${rate:.8f}")
+                    updated_count += 1
+                else:
+                    self.stdout.write(f"   ⚠️  {currency.code}: No rate available")
+                    
+            except Exception as e:
+                self.stdout.write(f"   ❌ {currency.code}: {str(e)}")
+                error_count += 1
+        
+        self.stdout.write(f"📈 Updated: {updated_count}, Errors: {error_count}")
+        return updated_count
+        
+    def _populate_and_update(self, options):
+        """Initial population of currencies."""
+        self.stdout.write("🔧 Populating currencies from external APIs...")
+        
+        # Check if database is empty
+        existing_count = Currency.objects.count()
+        if existing_count > 0 and not options['force']:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"⚠️  Database already contains {existing_count} currencies. "
+                    "Use --force to repopulate."
+                )
+            )
+            return 0
+            
+        if options['dry_run']:
+            self.stdout.write("[DRY RUN] Would populate currencies...")
+            return 0
+            
+        # Create database loader
+        config = DatabaseLoaderConfig(
+            max_crypto_currencies=options['max_crypto'],
+            max_fiat_currencies=options['max_fiat'],
+            yahoo_delay=1.0,
+            coinpaprika_delay=0.5
+        )
+        
+        loader = create_database_loader(config)
+        
+        try:
+            with transaction.atomic():
+                # Load currency data
+                currency_data = loader.build_currency_database_data()
+                
+                created_count = 0
+                updated_count = 0
+                
+                for currency_info in currency_data:
+                    currency, created = Currency.objects.get_or_create_normalized(
+                        code=currency_info.code,
+                        defaults={
+                            'name': currency_info.name,
+                            'currency_type': currency_info.currency_type,
+                            'usd_rate': currency_info.rate,
+                            'rate_updated_at': timezone.now()
+                        }
+                    )
+                    
+                    if created:
+                        created_count += 1
+                        self.stdout.write(f"   ➕ Created: {currency.code} - {currency.name}")
+                    else:
+                        # Update rate
+                        currency.usd_rate = currency_info.rate
+                        currency.rate_updated_at = timezone.now()
+                        currency.save()
+                        updated_count += 1
+                        self.stdout.write(f"   🔄 Updated: {currency.code} - ${currency.usd_rate:.8f}")
+                
+                self.stdout.write(f"📊 Created: {created_count}, Updated: {updated_count}")
+                return created_count + updated_count
+                
+        except Exception as e:
+            logger.exception("Failed to populate currencies")
+            raise CommandError(f"Population failed: {e}")
+            
+    def _update_existing(self, options):
+        """Update existing currencies and rates."""
+        self.stdout.write("🔄 Updating existing currencies...")
+        
+        if options['currency']:
+            return self._update_rates_only(options)
+            
+        # First update currency metadata if needed
+        self.stdout.write("1️⃣ Checking currency metadata...")
+        
+        # Then update rates
+        self.stdout.write("2️⃣ Updating USD exchange rates...")
+        rate_updates = self._update_rates_only(options)
+        
+        return rate_updates

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

@@ -0,0 +1,235 @@
+"""
+Universal payment provider management command.
+
+Combines sync_providers functionality with additional features.
+
+Usage:
+    python manage.py manage_providers                           # Sync all active providers
+    python manage.py manage_providers --provider nowpayments   # Sync specific provider
+    python manage.py manage_providers --with-rates             # Sync providers + update USD rates
+    python manage.py manage_providers --stats                  # Show provider statistics
+"""
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+from django.utils import timezone
+from typing import List, Optional
+import time
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.services.providers.registry import get_payment_provider, get_available_providers
+from django_cfg.apps.payments.models import Currency, ProviderCurrency
+
+logger = get_logger("manage_providers")
+
+
+class Command(BaseCommand):
+    """Universal payment provider management command."""
+    
+    help = 'Manage payment providers: sync currencies, networks, and rates'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--provider',
+            type=str,
+            help='Specific provider(s) to sync (comma-separated). E.g: nowpayments,cryptomus'
+        )
+        parser.add_argument(
+            '--all',
+            action='store_true',
+            help='Sync all available providers'
+        )
+        parser.add_argument(
+            '--with-rates',
+            action='store_true',
+            help='Also update USD exchange rates after sync'
+        )
+        parser.add_argument(
+            '--stats',
+            action='store_true',
+            help='Show provider statistics'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be synced without making changes'
+        )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Show detailed progress information'
+        )
+        
+    def handle(self, *args, **options):
+        """Execute the command."""
+        start_time = time.time()
+        
+        self.stdout.write('=' * 60)
+        self.stdout.write(self.style.SUCCESS('🚀 Provider Management Tool'))
+        self.stdout.write('=' * 60)
+        
+        if options['stats']:
+            return self._show_stats()
+            
+        # Determine which providers to sync
+        if options['provider']:
+            provider_names = [p.strip() for p in options['provider'].split(',')]
+        elif options['all']:
+            provider_names = get_available_providers()
+        else:
+            # Default: sync active providers only
+            provider_names = get_available_providers()
+            
+        # Sync providers
+        total_synced = 0
+        for provider_name in provider_names:
+            synced = self._sync_provider(provider_name, options)
+            total_synced += synced
+            
+        # Update rates if requested
+        if options['with_rates'] and not options['dry_run']:
+            self.stdout.write("\n💱 Updating USD exchange rates...")
+            self._update_rates()
+            
+        # Show summary
+        elapsed = time.time() - start_time
+        self.stdout.write('=' * 60)
+        self.stdout.write(f"📊 Total items synced: {total_synced}")
+        self.stdout.write(f"⏱️  Completed in {elapsed:.2f} seconds")
+        self.stdout.write('=' * 60)
+        
+        # Commands should not return values to stdout
+        pass
+        
+    def _sync_provider(self, provider_name: str, options: dict) -> int:
+        """Sync a specific provider."""
+        self.stdout.write(f"\n🔄 Syncing {provider_name}...")
+        
+        try:
+            provider = get_payment_provider(provider_name)
+            
+            if options['verbose']:
+                config = provider.config
+                self.stdout.write(f"   📡 Provider: {provider.__class__.__name__}")
+                self.stdout.write(f"   🔧 Config: enabled={config.enabled} timeout_seconds={config.timeout_seconds} sandbox={getattr(config, 'sandbox', 'N/A')}")
+            
+            if options['dry_run']:
+                # Dry run: just get parsed currencies to show what would be synced
+                try:
+                    parsed_response = provider.get_parsed_currencies()
+                    currency_count = len(parsed_response.currencies)
+                    
+                    # Calculate unique networks
+                    networks = set()
+                    for currency in parsed_response.currencies:
+                        if currency.network_code:
+                            networks.add(currency.network_code)
+                    network_count = len(networks)
+                    
+                    self.stdout.write(f"   💰 Would sync {currency_count} currencies")
+                    self.stdout.write(f"   🌐 Would sync {network_count} networks")
+                    
+                    return currency_count + network_count
+                    
+                except Exception as e:
+                    self.stdout.write(f"   ❌ Failed to fetch currencies: {e}")
+                    return 0
+            
+            else:
+                # Live sync
+                with transaction.atomic():
+                    sync_result = provider.sync_currencies_to_db()
+                    
+                    if options['verbose']:
+                        self.stdout.write(f"   ✅ Synced {sync_result.total_items_processed} items")
+                        if sync_result.errors:
+                            self.stdout.write(f"   ⚠️  Errors: {len(sync_result.errors)}")
+                            for error in sync_result.errors[:3]:  # Show first 3 errors
+                                self.stdout.write(f"      • {error}")
+                    
+                    self.stdout.write(
+                        self.style.SUCCESS(f"✅ {provider_name}: {sync_result.total_items_processed} items synced")
+                    )
+                    
+                    return sync_result.total_items_processed
+        
+        except Exception as e:
+            logger.exception(f"Error syncing provider {provider_name}")
+            self.stdout.write(
+                self.style.ERROR(f"❌ Failed to sync {provider_name}: {e}")
+            )
+            return 0
+            
+    def _update_rates(self):
+        """Update USD rates for currencies."""
+        try:
+            # Get currencies that need rate updates
+            from datetime import timedelta
+            from django.db.models import Q
+            
+            stale_threshold = timezone.now() - timedelta(hours=12)
+            currencies_to_update = Currency.objects.filter(
+                Q(usd_rate__isnull=True) | 
+                Q(rate_updated_at__isnull=True) |
+                Q(rate_updated_at__lt=stale_threshold)
+            )[:50]  # Limit to avoid long execution
+            
+            updated_count = 0
+            for currency in currencies_to_update:
+                try:
+                    rate = Currency.objects.get_usd_rate(currency.code, force_refresh=True)
+                    if rate > 0:
+                        updated_count += 1
+                        self.stdout.write(f"   ✅ {currency.code}: ${rate:.8f}")
+                except Exception as e:
+                    self.stdout.write(f"   ⚠️  {currency.code}: {str(e)}")
+                    
+            self.stdout.write(f"💱 Updated {updated_count} exchange rates")
+            
+        except Exception as e:
+            self.stdout.write(f"⚠️  Rate update failed: {e}")
+            
+    def _show_stats(self):
+        """Show provider statistics."""
+        self.stdout.write("📊 Provider Statistics")
+        self.stdout.write("-" * 40)
+        
+        # Available providers
+        available_providers = get_available_providers()
+        self.stdout.write(f"🏢 Available providers: {len(available_providers)}")
+        for provider_name in available_providers:
+            try:
+                provider = get_payment_provider(provider_name)
+                enabled = provider.config.enabled
+                status = "✅ Enabled" if enabled else "❌ Disabled"
+                self.stdout.write(f"   • {provider_name}: {status}")
+            except Exception as e:
+                self.stdout.write(f"   • {provider_name}: ❌ Error ({e})")
+        
+        self.stdout.write()
+        
+        # Database statistics
+        total_currencies = Currency.objects.count()
+        total_provider_currencies = ProviderCurrency.objects.count()
+        
+        self.stdout.write(f"💰 Total currencies: {total_currencies}")
+        self.stdout.write(f"🔗 Total provider currencies: {total_provider_currencies}")
+        
+        # Provider breakdown
+        from django.db.models import Count
+        provider_stats = ProviderCurrency.objects.values('provider_name').annotate(
+            count=Count('id')
+        ).order_by('-count')
+        
+        self.stdout.write("\n📊 Currencies by provider:")
+        for stat in provider_stats:
+            self.stdout.write(f"   • {stat['provider_name']}: {stat['count']} currencies")
+            
+        # Rate statistics
+        currencies_with_rates = Currency.objects.exclude(usd_rate__isnull=True).exclude(usd_rate=0)
+        rate_coverage = (currencies_with_rates.count() / total_currencies * 100) if total_currencies > 0 else 0
+        
+        self.stdout.write(f"\n💵 USD rate coverage: {rate_coverage:.1f}% ({currencies_with_rates.count()}/{total_currencies})")
+        
+        # Stats command should not return values

django_cfg/apps/payments/managers/__init__.py

@@ -7,7 +7,7 @@ from .balance_manager import UserBalanceManager
 from .subscription_manager import SubscriptionManager, EndpointGroupManager
 from .tariff_manager import TariffManager, TariffEndpointGroupManager
 from .api_key_manager import APIKeyManager
-from .currency_manager import CurrencyManager, CurrencyNetworkManager
+from .currency_manager import CurrencyManager, NetworkManager, ProviderCurrencyManager
 
 __all__ = [
     'UniversalPaymentManager',
@@ -18,5 +18,6 @@ __all__ = [
     'TariffEndpointGroupManager',
     'APIKeyManager',
     'CurrencyManager',
-    'CurrencyNetworkManager',
+    'NetworkManager',
+    'ProviderCurrencyManager',
 ]

django_cfg/apps/payments/managers/balance_manager.py

@@ -12,9 +12,9 @@ from django.db import models, transaction
 from django.utils import timezone
 from decimal import Decimal
 from typing import Optional, Dict, Any
-import logging
+from django_cfg.modules.django_logger import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger("balance_manager")
 
 
 class UserBalanceManager(models.Manager):