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

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

@@ -0,0 +1,323 @@
+"""
+Management command to show currency database statistics.
+
+Usage:
+    python manage.py currency_stats
+    python manage.py currency_stats --detailed
+    python manage.py currency_stats --top 10
+    python manage.py currency_stats --check-rates
+"""
+
+from datetime import datetime, timedelta
+from typing import List
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+from django.db.models import Q, Count, Avg
+
+from django_cfg.apps.payments.models.currencies import Currency
+
+
+class Command(BaseCommand):
+    """
+    Display currency database statistics and health information.
+    """
+    
+    help = 'Show currency database statistics'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--detailed',
+            action='store_true',
+            help='Show detailed statistics'
+        )
+        
+        parser.add_argument(
+            '--top',
+            type=int,
+            default=5,
+            help='Number of top currencies to show (default: 5)'
+        )
+        
+        parser.add_argument(
+            '--check-rates',
+            action='store_true',
+            help='Check for outdated exchange rates'
+        )
+        
+        parser.add_argument(
+            '--export-csv',
+            type=str,
+            help='Export currency data to CSV file'
+        )
+    
+    def handle(self, *args, **options):
+        """Main command handler."""
+        
+        self.stdout.write(
+            self.style.SUCCESS('📊 Currency Database Statistics')
+        )
+        self.stdout.write('=' * 50)
+        
+        self._show_basic_stats(options)
+        
+        if options['detailed']:
+            self._show_detailed_stats(options)
+        
+        if options['check_rates']:
+            self._check_rate_freshness()
+        
+        if options['export_csv']:
+            self._export_to_csv(options['export_csv'])
+    
+    def _show_basic_stats(self, options):
+        """Show basic currency statistics."""
+        
+        # Basic counts
+        total = Currency.objects.count()
+        active = Currency.objects.filter(is_active=True).count()
+        inactive = total - active
+        
+        fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
+        crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
+        
+        active_fiat = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.FIAT, 
+            is_active=True
+        ).count()
+        active_crypto = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.CRYPTO, 
+            is_active=True
+        ).count()
+        
+        self.stdout.write(f"\n📈 Overview:")
+        self.stdout.write(f"   Total currencies: {total}")
+        self.stdout.write(f"   Active: {active} | Inactive: {inactive}")
+        self.stdout.write(f"   Fiat: {fiat_count} ({active_fiat} active)")
+        self.stdout.write(f"   Crypto: {crypto_count} ({active_crypto} active)")
+        
+        # Rate update status
+        now = timezone.now()
+        
+        # Recent (last 24h)
+        recent_threshold = now - timedelta(hours=24)
+        recent_updates = Currency.objects.filter(
+            rate_updated_at__gte=recent_threshold
+        ).count()
+        
+        # Outdated (older than 7 days)
+        outdated_threshold = now - timedelta(days=7)
+        outdated = Currency.objects.filter(
+            Q(rate_updated_at__lt=outdated_threshold) | Q(rate_updated_at__isnull=True)
+        ).count()
+        
+        self.stdout.write(f"\n🕒 Rate Updates:")
+        self.stdout.write(f"   Updated in last 24h: {recent_updates}")
+        self.stdout.write(f"   Outdated (>7 days): {outdated}")
+        
+        # Top cryptocurrencies by USD value
+        top_crypto = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.CRYPTO,
+            is_active=True
+        ).order_by('-usd_rate')[:options['top']]
+        
+        if top_crypto:
+            self.stdout.write(f"\n🚀 Top {options['top']} Cryptocurrencies by USD Rate:")
+            for i, currency in enumerate(top_crypto, 1):
+                age = self._get_rate_age(currency)
+                self.stdout.write(
+                    f"   {i}. {currency.code}: ${currency.usd_rate:,.6f} {age}"
+                )
+        
+        # Major fiat currencies
+        major_fiat = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.FIAT,
+            code__in=['USD', 'EUR', 'GBP', 'JPY', 'CNY'],
+            is_active=True
+        ).order_by('code')
+        
+        if major_fiat:
+            self.stdout.write(f"\n💵 Major Fiat Currencies:")
+            for currency in major_fiat:
+                age = self._get_rate_age(currency)
+                self.stdout.write(
+                    f"   • {currency.code}: {currency.name} = ${currency.usd_rate:.6f} {age}"
+                )
+    
+    def _show_detailed_stats(self, options):
+        """Show detailed statistics."""
+        
+        self.stdout.write(f"\n📊 Detailed Statistics:")
+        
+        # Decimal places distribution
+        decimal_stats = Currency.objects.values('decimal_places').annotate(
+            count=Count('decimal_places')
+        ).order_by('decimal_places')
+        
+        self.stdout.write(f"\n🔢 Decimal Places Distribution:")
+        for stat in decimal_stats:
+            self.stdout.write(f"   {stat['decimal_places']} places: {stat['count']} currencies")
+        
+        # Average rates by type
+        crypto_avg = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.CRYPTO,
+            is_active=True
+        ).aggregate(avg_rate=Avg('usd_rate'))['avg_rate']
+        
+        fiat_avg = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.FIAT,
+            is_active=True
+        ).aggregate(avg_rate=Avg('usd_rate'))['avg_rate']
+        
+        self.stdout.write(f"\n📊 Average USD Rates:")
+        if crypto_avg:
+            self.stdout.write(f"   Cryptocurrencies: ${crypto_avg:.6f}")
+        if fiat_avg:
+            self.stdout.write(f"   Fiat currencies: ${fiat_avg:.6f}")
+        
+        # Min payment amounts
+        min_payment_stats = Currency.objects.values('min_payment_amount').annotate(
+            count=Count('min_payment_amount')
+        ).order_by('min_payment_amount')[:5]
+        
+        self.stdout.write(f"\n💰 Top Min Payment Amounts:")
+        for stat in min_payment_stats:
+            self.stdout.write(f"   ${stat['min_payment_amount']}: {stat['count']} currencies")
+        
+        # Rate freshness distribution
+        now = timezone.now()
+        thresholds = [
+            ('Last hour', timedelta(hours=1)),
+            ('Last 24 hours', timedelta(hours=24)),
+            ('Last week', timedelta(days=7)),
+            ('Last month', timedelta(days=30)),
+        ]
+        
+        self.stdout.write(f"\n⏰ Rate Update Distribution:")
+        previous_count = 0
+        for label, delta in thresholds:
+            threshold = now - delta
+            count = Currency.objects.filter(rate_updated_at__gte=threshold).count()
+            new_in_period = count - previous_count
+            self.stdout.write(f"   {label}: {new_in_period} new updates ({count} total)")
+            previous_count = count
+        
+        # Never updated
+        never_updated = Currency.objects.filter(rate_updated_at__isnull=True).count()
+        if never_updated > 0:
+            self.stdout.write(f"   Never updated: {never_updated} currencies")
+    
+    def _check_rate_freshness(self):
+        """Check for outdated exchange rates."""
+        
+        self.stdout.write(f"\n🔍 Rate Freshness Check:")
+        
+        now = timezone.now()
+        
+        # Very outdated (>30 days)
+        very_old_threshold = now - timedelta(days=30)
+        very_old = Currency.objects.filter(
+            Q(rate_updated_at__lt=very_old_threshold) | Q(rate_updated_at__isnull=True),
+            is_active=True
+        )
+        
+        if very_old.exists():
+            self.stdout.write(
+                self.style.ERROR(f"   ❌ {very_old.count()} currencies with very old rates (>30 days)")
+            )
+            for currency in very_old[:5]:
+                age = self._get_rate_age(currency)
+                self.stdout.write(f"      • {currency.code}: {age}")
+            if very_old.count() > 5:
+                self.stdout.write(f"      ... and {very_old.count() - 5} more")
+        
+        # Moderately outdated (7-30 days)
+        old_threshold = now - timedelta(days=7)
+        old_currencies = Currency.objects.filter(
+            rate_updated_at__lt=old_threshold,
+            rate_updated_at__gte=very_old_threshold,
+            is_active=True
+        )
+        
+        if old_currencies.exists():
+            self.stdout.write(
+                self.style.WARNING(f"   ⚠️ {old_currencies.count()} currencies with old rates (7-30 days)")
+            )
+        
+        # Fresh rates (last 24h)
+        fresh_threshold = now - timedelta(hours=24)
+        fresh = Currency.objects.filter(
+            rate_updated_at__gte=fresh_threshold,
+            is_active=True
+        ).count()
+        
+        if fresh > 0:
+            self.stdout.write(
+                self.style.SUCCESS(f"   ✅ {fresh} currencies with fresh rates (<24h)")
+            )
+        
+        # Recommendations
+        total_active = Currency.objects.filter(is_active=True).count()
+        if very_old.count() > 0:
+            self.stdout.write(f"\n💡 Recommendations:")
+            self.stdout.write(f"   • Run: python manage.py update_currencies --force-update")
+            self.stdout.write(f"   • Consider deactivating currencies with very old rates")
+    
+    def _get_rate_age(self, currency) -> str:
+        """Get human-readable age of currency rate."""
+        if not currency.rate_updated_at:
+            return "(never updated)"
+        
+        age = timezone.now() - currency.rate_updated_at
+        
+        if age.days > 30:
+            return f"({age.days} days ago)"
+        elif age.days > 0:
+            return f"({age.days}d ago)"
+        elif age.seconds > 3600:
+            hours = age.seconds // 3600
+            return f"({hours}h ago)"
+        else:
+            minutes = age.seconds // 60
+            return f"({minutes}m ago)"
+    
+    def _export_to_csv(self, filename: str):
+        """Export currency data to CSV file."""
+        import csv
+        
+        self.stdout.write(f"\n📁 Exporting to {filename}...")
+        
+        try:
+            with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
+                writer = csv.writer(csvfile)
+                
+                # Header
+                writer.writerow([
+                    'code', 'name', 'symbol', 'currency_type', 'decimal_places',
+                    'usd_rate', 'min_payment_amount', 'is_active', 'rate_updated_at'
+                ])
+                
+                # Data
+                currencies = Currency.objects.all().order_by('code')
+                for currency in currencies:
+                    writer.writerow([
+                        currency.code,
+                        currency.name,
+                        currency.symbol,
+                        currency.currency_type,
+                        currency.decimal_places,
+                        currency.usd_rate,
+                        currency.min_payment_amount,
+                        currency.is_active,
+                        currency.rate_updated_at.isoformat() if currency.rate_updated_at else None
+                    ])
+            
+            self.stdout.write(
+                self.style.SUCCESS(f"   ✅ Exported {currencies.count()} currencies to {filename}")
+            )
+            
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f"   ❌ Export failed: {str(e)}")
+            )

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

@@ -0,0 +1,246 @@
+"""
+Management command to populate initial currency data.
+
+This is a simpler version of update_currencies designed for initial setup.
+Use this when you need to populate an empty currency database.
+
+Usage:
+    python manage.py populate_currencies
+    python manage.py populate_currencies --quick
+    python manage.py populate_currencies --crypto-only
+    python manage.py populate_currencies --fiat-only
+"""
+
+import logging
+from typing import List
+
+from django.core.management.base import BaseCommand, CommandError
+from django.db import transaction
+from django.utils import timezone
+
+from django_cfg.modules.django_currency.database.database_loader import (
+    create_database_loader,
+    DatabaseLoaderConfig
+)
+from django_cfg.apps.payments.models.currencies import Currency
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    Simple command to populate initial currency data.
+    
+    Optimized for first-time setup with sensible defaults.
+    """
+    
+    help = 'Populate initial currency data (for empty database)'
+    
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            '--quick',
+            action='store_true',
+            help='Quick setup with top 50 cryptocurrencies and 20 fiat currencies'
+        )
+        
+        parser.add_argument(
+            '--crypto-only',
+            action='store_true',
+            help='Only populate cryptocurrencies'
+        )
+        
+        parser.add_argument(
+            '--fiat-only',
+            action='store_true',
+            help='Only populate fiat currencies'
+        )
+        
+        parser.add_argument(
+            '--skip-existing',
+            action='store_true',
+            help='Skip currencies that already exist in database'
+        )
+    
+    def handle(self, *args, **options):
+        """Main command handler."""
+        
+        self.stdout.write(
+            self.style.SUCCESS('🪙 Populating currency database...')
+        )
+        
+        # Check if database is empty
+        existing_count = Currency.objects.count()
+        if existing_count > 0 and not options['skip_existing']:
+            self.stdout.write(
+                self.style.WARNING(f'⚠️ Database already contains {existing_count} currencies')
+            )
+            response = input('Continue anyway? [y/N]: ')
+            if response.lower() != 'y':
+                self.stdout.write('Cancelled by user')
+                return
+        
+        try:
+            # Configure loader based on options
+            if options['quick']:
+                config = DatabaseLoaderConfig(
+                    max_cryptocurrencies=50,
+                    max_fiat_currencies=20,
+                    min_market_cap_usd=10_000_000,  # Top coins only
+                    coingecko_delay=1.0,  # Faster for initial setup
+                )
+                self.stdout.write("⚡ Quick setup mode: top 50 crypto + 20 fiat")
+            else:
+                config = DatabaseLoaderConfig(
+                    max_cryptocurrencies=200,
+                    max_fiat_currencies=30,
+                    min_market_cap_usd=1_000_000,
+                    coingecko_delay=1.5,
+                )
+                self.stdout.write("📈 Standard setup: top 200 crypto + 30 fiat")
+            
+            loader = create_database_loader(
+                max_cryptocurrencies=config.max_cryptocurrencies,
+                max_fiat_currencies=config.max_fiat_currencies,
+                min_market_cap_usd=config.min_market_cap_usd,
+                coingecko_delay=config.coingecko_delay
+            )
+            
+            # Get statistics
+            stats = loader.get_statistics()
+            self.stdout.write(f"📊 Available: {stats['total_currencies']} currencies")
+            
+            # Load currency data
+            self.stdout.write("🌐 Fetching currency data from APIs...")
+            fresh_currencies = loader.build_currency_database_data()
+            
+            # Filter by type if requested
+            if options['crypto_only']:
+                fresh_currencies = [c for c in fresh_currencies if c.currency_type == 'crypto']
+                self.stdout.write(f"🔗 Crypto only: {len(fresh_currencies)} cryptocurrencies")
+            elif options['fiat_only']:
+                fresh_currencies = [c for c in fresh_currencies if c.currency_type == 'fiat']
+                self.stdout.write(f"💵 Fiat only: {len(fresh_currencies)} fiat currencies")
+            else:
+                crypto_count = sum(1 for c in fresh_currencies if c.currency_type == 'crypto')
+                fiat_count = sum(1 for c in fresh_currencies if c.currency_type == 'fiat')
+                self.stdout.write(f"💰 Mixed: {crypto_count} crypto + {fiat_count} fiat")
+            
+            # Populate database
+            self._populate_database(fresh_currencies, options)
+            
+        except KeyboardInterrupt:
+            self.stdout.write(
+                self.style.WARNING('\n⚠️ Population interrupted by user')
+            )
+            raise CommandError("Population cancelled")
+            
+        except Exception as e:
+            logger.exception("Currency population failed")
+            self.stdout.write(
+                self.style.ERROR(f'❌ Population failed: {str(e)}')
+            )
+            raise CommandError(f"Population failed: {str(e)}")
+    
+    def _populate_database(self, currencies: List, options: dict):
+        """Populate the database with currencies."""
+        
+        created_count = 0
+        updated_count = 0
+        skipped_count = 0
+        
+        try:
+            with transaction.atomic():
+                self.stdout.write("💾 Populating database...")
+                
+                for i, currency_data in enumerate(currencies):
+                    try:
+                        # Check if exists and should skip
+                        if options['skip_existing']:
+                            if Currency.objects.filter(code=currency_data.code).exists():
+                                skipped_count += 1
+                                continue
+                        
+                        # Create or update
+                        currency, created = Currency.objects.update_or_create(
+                            code=currency_data.code,
+                            defaults={
+                                'name': currency_data.name,
+                                'symbol': currency_data.symbol,
+                                'currency_type': currency_data.currency_type,
+                                'decimal_places': currency_data.decimal_places,
+                                'usd_rate': currency_data.usd_rate,
+                                'min_payment_amount': currency_data.min_payment_amount,
+                                'is_active': currency_data.is_active,
+                                'rate_updated_at': timezone.now()
+                            }
+                        )
+                        
+                        if created:
+                            created_count += 1
+                        else:
+                            updated_count += 1
+                        
+                        # Progress indicator every 25 currencies
+                        if (i + 1) % 25 == 0:
+                            self.stdout.write(f"   📊 Progress: {i + 1}/{len(currencies)}")
+                    
+                    except Exception as e:
+                        self.stdout.write(
+                            self.style.WARNING(f'⚠️ Failed to create {currency_data.code}: {e}')
+                        )
+                        continue
+                
+                # Final summary
+                total_processed = created_count + updated_count
+                self.stdout.write(f"\n🎉 Population completed!")
+                self.stdout.write(f"   ✅ Created: {created_count} currencies")
+                self.stdout.write(f"   🔄 Updated: {updated_count} currencies")
+                self.stdout.write(f"   ⏭️ Skipped: {skipped_count} currencies")
+                self.stdout.write(f"   📊 Total: {total_processed} currencies processed")
+                
+                # Show some examples
+                self._show_examples()
+                
+                self.stdout.write(
+                    self.style.SUCCESS('\n✅ Currency database is ready for payments!')
+                )
+                
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f'❌ Population failed and rolled back: {str(e)}')
+            )
+            raise
+    
+    def _show_examples(self):
+        """Show some example currencies that were created."""
+        
+        # Show top cryptocurrencies
+        crypto_examples = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.CRYPTO
+        ).order_by('-usd_rate')[:3]
+        
+        if crypto_examples:
+            self.stdout.write(f"\n🔗 Top cryptocurrencies:")
+            for currency in crypto_examples:
+                self.stdout.write(f"   • {currency.code}: ${currency.usd_rate:.2f}")
+        
+        # Show fiat currencies
+        fiat_examples = Currency.objects.filter(
+            currency_type=Currency.CurrencyType.FIAT
+        ).order_by('code')[:5]
+        
+        if fiat_examples:
+            self.stdout.write(f"\n💵 Fiat currencies:")
+            for currency in fiat_examples:
+                self.stdout.write(f"   • {currency.code}: {currency.name} ({currency.symbol})")
+        
+        # Total counts
+        total = Currency.objects.count()
+        crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
+        fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
+        
+        self.stdout.write(f"\n📊 Database now contains:")
+        self.stdout.write(f"   • Total: {total} currencies")
+        self.stdout.write(f"   • Crypto: {crypto_count} currencies")
+        self.stdout.write(f"   • Fiat: {fiat_count} currencies")