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

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

@@ -1,43 +1,52 @@
 """
-Management command to show currency database statistics.
+Currency Statistics Management Command for Universal Payment System v2.0.
 
-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
+Display comprehensive currency database statistics and health information.
 """
 
 from datetime import datetime, timedelta
-from typing import List
+from typing import List, Dict, Any
+from decimal import Decimal
 
-from django.core.management.base import BaseCommand
+from django.core.management.base import BaseCommand, CommandError
 from django.utils import timezone
-from django.db.models import Q, Count, Avg
+from django.db.models import Q, Count, Avg, Sum, Max, Min
+from django.contrib.humanize.templatetags.humanize import intcomma
 
-from django_cfg.apps.payments.models.currencies import Currency
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.models import Currency, Network, ProviderCurrency, UniversalPayment
+from django_cfg.apps.payments.services.providers.registry import get_provider_registry
+
+logger = get_logger("currency_stats")
 
 
 class Command(BaseCommand):
     """
     Display currency database statistics and health information.
+    
+    Features:
+    - Basic and detailed statistics
+    - Top currencies by usage and value
+    - Rate freshness analysis
+    - Provider currency coverage
+    - Payment volume analysis
     """
     
-    help = 'Show currency database statistics'
+    help = 'Show currency database statistics and health information'
     
     def add_arguments(self, parser):
         """Add command line arguments."""
         parser.add_argument(
             '--detailed',
             action='store_true',
-            help='Show detailed statistics'
+            help='Show detailed statistics breakdown'
         )
         
         parser.add_argument(
             '--top',
             type=int,
-            default=5,
-            help='Number of top currencies to show (default: 5)'
+            default=10,
+            help='Number of top currencies to show (default: 10)'
         )
         
         parser.add_argument(
@@ -46,259 +55,322 @@ class Command(BaseCommand):
             help='Check for outdated exchange rates'
         )
         
+        parser.add_argument(
+            '--provider',
+            type=str,
+            help='Show statistics for specific provider'
+        )
+        
         parser.add_argument(
             '--export-csv',
             type=str,
-            help='Export currency data to CSV file'
+            help='Export statistics to CSV file'
+        )
+        
+        parser.add_argument(
+            '--format',
+            choices=['table', 'json', 'yaml'],
+            default='table',
+            help='Output format (default: table)'
         )
     
     def handle(self, *args, **options):
-        """Main command handler."""
-        
+        """Execute the command."""
+        try:
+            self.options = options
+            self.show_header()
+            
+            if options['check_rates']:
+                self.check_rate_freshness()
+            elif options['provider']:
+                self.show_provider_stats(options['provider'])
+            else:
+                self.show_general_stats()
+                
+                if options['detailed']:
+                    self.show_detailed_stats()
+                
+                self.show_top_currencies()
+            
+            if options['export_csv']:
+                self.export_to_csv(options['export_csv'])
+                
+        except Exception as e:
+            logger.error(f"Currency stats command failed: {e}")
+            raise CommandError(f"Failed to generate currency statistics: {e}")
+    
+    def show_header(self):
+        """Display command header."""
         self.stdout.write(
-            self.style.SUCCESS('📊 Currency Database Statistics')
+            self.style.SUCCESS("=" * 60)
         )
-        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'])
+        self.stdout.write(
+            self.style.SUCCESS("📊 CURRENCY DATABASE STATISTICS")
+        )
+        self.stdout.write(
+            self.style.SUCCESS("=" * 60)
+        )
+        self.stdout.write(f"Generated: {timezone.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        self.stdout.write("")
     
-    def _show_basic_stats(self, options):
-        """Show basic currency statistics."""
-        
+    def show_general_stats(self):
+        """Show general currency statistics."""
         # Basic counts
-        total = Currency.objects.count()
-        active = Currency.objects.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, 
-        ).count()
-        active_crypto = Currency.objects.filter(
-            currency_type=Currency.CurrencyType.CRYPTO, 
-        ).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()
+        total_currencies = Currency.objects.count()
+        active_currencies = Currency.objects.filter(is_active=True).count()
+        crypto_currencies = Currency.objects.filter(currency_type='crypto').count()
+        fiat_currencies = Currency.objects.filter(currency_type='fiat').count()
+        
+        # Network stats
+        total_networks = Network.objects.count()
+        active_networks = Network.objects.filter(is_active=True).count()
+        
+        # Provider currency stats
+        total_provider_currencies = ProviderCurrency.objects.count()
+        active_provider_currencies = ProviderCurrency.objects.filter(is_active=True).count()
+        
+        # Payment stats
+        total_payments = UniversalPayment.objects.count()
+        completed_payments = UniversalPayment.objects.filter(status='completed').count()
+        
+        self.stdout.write(self.style.SUCCESS("📈 GENERAL STATISTICS"))
+        self.stdout.write("-" * 40)
+        
+        stats = [
+            ("Total Currencies", total_currencies),
+            ("Active Currencies", active_currencies),
+            ("Cryptocurrency", crypto_currencies),
+            ("Fiat Currency", fiat_currencies),
+            ("Networks", f"{active_networks}/{total_networks}"),
+            ("Provider Currencies", f"{active_provider_currencies}/{total_provider_currencies}"),
+            ("Total Payments", total_payments),
+            ("Completed Payments", completed_payments),
+        ]
         
-        # Recent (last 24h)
-        recent_threshold = now - timedelta(hours=24)
-        recent_updates = Currency.objects.filter(
-            rate_updated_at__gte=recent_threshold
-        ).count()
+        for label, value in stats:
+            self.stdout.write(f"{label:<20}: {self.style.WARNING(str(value))}")
         
-        # 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,
-        ).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'],
-        ).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}"
-                )
+        self.stdout.write("")
     
-    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,
-        ).aggregate(avg_rate=Avg('usd_rate'))['avg_rate']
-        
-        fiat_avg = Currency.objects.filter(
-            currency_type=Currency.CurrencyType.FIAT,
-        ).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
-        # Note: min_payment_amount field was removed - now handled at provider level
-        self.stdout.write(f"\n💰 Payment amounts now managed at provider level (ProviderCurrency)")
-        
-        # 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 show_detailed_stats(self):
+        """Show detailed statistics breakdown."""
+        self.stdout.write(self.style.SUCCESS("🔍 DETAILED BREAKDOWN"))
+        self.stdout.write("-" * 40)
+        
+        # Currency type breakdown
+        crypto_active = Currency.objects.filter(currency_type='crypto', is_active=True).count()
+        crypto_inactive = Currency.objects.filter(currency_type='crypto', is_active=False).count()
+        fiat_active = Currency.objects.filter(currency_type='fiat', is_active=True).count()
+        fiat_inactive = Currency.objects.filter(currency_type='fiat', is_active=False).count()
+        
+        self.stdout.write("Currency Status:")
+        self.stdout.write(f"  Crypto: {crypto_active} active, {crypto_inactive} inactive")
+        self.stdout.write(f"  Fiat:   {fiat_active} active, {fiat_inactive} inactive")
+        
+        # Provider coverage
+        providers = get_provider_registry().get_available_providers()
+        self.stdout.write(f"\nProvider Coverage:")
+        
+        for provider_name in providers:
+            provider_currencies = ProviderCurrency.objects.filter(
+                provider=provider_name,
+                is_active=True
+            ).count()
+            self.stdout.write(f"  {provider_name}: {provider_currencies} currencies")
+        
+        # Payment volume by currency
+        payment_stats = UniversalPayment.objects.filter(
+            status='completed'
+        ).values('currency__code').annotate(
+            count=Count('id'),
+            total_volume=Sum('amount_usd')
+        ).order_by('-total_volume')[:5]
+        
+        if payment_stats:
+            self.stdout.write(f"\nTop Payment Currencies:")
+            for stat in payment_stats:
+                currency = stat['currency__code'] or 'Unknown'
+                count = stat['count']
+                volume = stat['total_volume'] or 0
+                self.stdout.write(f"  {currency}: {count} payments, ${intcomma(volume)}")
+        
+        self.stdout.write("")
     
-    def _check_rate_freshness(self):
+    def show_top_currencies(self):
+        """Show top currencies by various metrics."""
+        top_count = self.options['top']
+        
+        self.stdout.write(self.style.SUCCESS(f"🏆 TOP {top_count} CURRENCIES"))
+        self.stdout.write("-" * 40)
+        
+        # Top by payment count
+        top_by_payments = UniversalPayment.objects.filter(
+            status='completed'
+        ).values('currency__code', 'currency__name').annotate(
+            payment_count=Count('id')
+        ).order_by('-payment_count')[:top_count]
+        
+        if top_by_payments:
+            self.stdout.write("By Payment Count:")
+            for i, currency in enumerate(top_by_payments, 1):
+                code = currency['currency__code'] or 'Unknown'
+                name = currency['currency__name'] or 'Unknown'
+                count = currency['payment_count']
+                self.stdout.write(f"  {i:2d}. {code} ({name}): {count} payments")
+        
+        # Top by volume
+        top_by_volume = UniversalPayment.objects.filter(
+            status='completed'
+        ).values('currency__code', 'currency__name').annotate(
+            total_volume=Sum('amount_usd')
+        ).order_by('-total_volume')[:top_count]
+        
+        if top_by_volume:
+            self.stdout.write(f"\nBy Payment Volume:")
+            for i, currency in enumerate(top_by_volume, 1):
+                code = currency['currency__code'] or 'Unknown'
+                name = currency['currency__name'] or 'Unknown'
+                volume = currency['total_volume'] or 0
+                self.stdout.write(f"  {i:2d}. {code} ({name}): ${intcomma(volume)}")
+        
+        self.stdout.write("")
+    
+    def check_rate_freshness(self):
         """Check for outdated exchange rates."""
-        
-        self.stdout.write(f"\n🔍 Rate Freshness Check:")
+        self.stdout.write(self.style.SUCCESS("🕐 RATE FRESHNESS CHECK"))
+        self.stdout.write("-" * 40)
         
         now = timezone.now()
+        stale_threshold = now - timedelta(hours=24)
+        very_stale_threshold = now - timedelta(days=7)
+        
+        # Check currencies with stale rates
+        stale_currencies = Currency.objects.filter(
+            updated_at__lt=stale_threshold,
+            is_active=True
+        ).order_by('updated_at')
+        
+        very_stale_currencies = Currency.objects.filter(
+            updated_at__lt=very_stale_threshold,
+            is_active=True
+        ).order_by('updated_at')
+        
+        fresh_currencies = Currency.objects.filter(
+            updated_at__gte=stale_threshold,
+            is_active=True
+        ).count()
         
-        # 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),
-        )
-        
-        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,
-        )
-        
-        if old_currencies.exists():
-            self.stdout.write(
-                self.style.WARNING(f"   ⚠️ {old_currencies.count()} currencies with old rates (7-30 days)")
-            )
+        self.stdout.write(f"Fresh rates (< 24h): {self.style.SUCCESS(fresh_currencies)}")
+        self.stdout.write(f"Stale rates (> 24h): {self.style.WARNING(stale_currencies.count())}")
+        self.stdout.write(f"Very stale (> 7d): {self.style.ERROR(very_stale_currencies.count())}")
         
-        # Fresh rates (last 24h)
-        fresh_threshold = now - timedelta(hours=24)
-        fresh = Currency.objects.filter(
-            rate_updated_at__gte=fresh_threshold,
-        ).count()
+        if very_stale_currencies.exists():
+            self.stdout.write(f"\n{self.style.ERROR('⚠️  VERY STALE CURRENCIES:')}")
+            for currency in very_stale_currencies[:10]:
+                age = now - currency.updated_at
+                self.stdout.write(f"  {currency.code}: {age.days} days old")
         
-        if fresh > 0:
-            self.stdout.write(
-                self.style.SUCCESS(f"   ✅ {fresh} currencies with fresh rates (<24h)")
-            )
+        if stale_currencies.exists() and not very_stale_currencies.exists():
+            self.stdout.write(f"\n{self.style.WARNING('⚠️  STALE CURRENCIES:')}")
+            for currency in stale_currencies[:10]:
+                age = now - currency.updated_at
+                hours = int(age.total_seconds() / 3600)
+                self.stdout.write(f"  {currency.code}: {hours} hours old")
         
-        # Recommendations
-        total_active = Currency.objects.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")
+        self.stdout.write("")
     
-    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 show_provider_stats(self, provider_name: str):
+        """Show statistics for specific provider."""
+        self.stdout.write(self.style.SUCCESS(f"🏢 PROVIDER STATISTICS: {provider_name.upper()}"))
+        self.stdout.write("-" * 40)
+        
+        # Provider currency stats
+        provider_currencies = ProviderCurrency.objects.filter(provider=provider_name)
+        active_provider_currencies = provider_currencies.filter(is_active=True)
+        
+        # Payment stats for this provider
+        provider_payments = UniversalPayment.objects.filter(provider=provider_name)
+        completed_payments = provider_payments.filter(status='completed')
+        
+        # Volume stats
+        total_volume = completed_payments.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0
+        avg_payment = completed_payments.aggregate(Avg('amount_usd'))['amount_usd__avg'] or 0
+        
+        stats = [
+            ("Total Currencies", provider_currencies.count()),
+            ("Active Currencies", active_provider_currencies.count()),
+            ("Total Payments", provider_payments.count()),
+            ("Completed Payments", completed_payments.count()),
+            ("Total Volume", f"${intcomma(total_volume)}"),
+            ("Average Payment", f"${intcomma(avg_payment):.2f}"),
+        ]
+        
+        for label, value in stats:
+            self.stdout.write(f"{label:<20}: {self.style.WARNING(str(value))}")
+        
+        # Top currencies for this provider
+        top_currencies = completed_payments.values(
+            'currency__code', 'currency__name'
+        ).annotate(
+            count=Count('id'),
+            volume=Sum('amount_usd')
+        ).order_by('-volume')[:5]
+        
+        if top_currencies:
+            self.stdout.write(f"\nTop Currencies:")
+            for currency in top_currencies:
+                code = currency['currency__code'] or 'Unknown'
+                count = currency['count']
+                volume = currency['volume'] or 0
+                self.stdout.write(f"  {code}: {count} payments, ${intcomma(volume)}")
+        
+        self.stdout.write("")
     
-    def _export_to_csv(self, filename: str):
-        """Export currency data to CSV file."""
+    def export_to_csv(self, filename: str):
+        """Export statistics to CSV file."""
         import csv
-        
-        self.stdout.write(f"\n📁 Exporting to {filename}...")
+        from pathlib import Path
         
         try:
+            # Collect all statistics
+            currencies = Currency.objects.select_related().all()
+            
             with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
                 writer = csv.writer(csvfile)
                 
-                # Header
+                # Write header
                 writer.writerow([
-                    'code', 'name', 'currency_type', 'usd_rate', 'rate_updated_at'
+                    'Code', 'Name', 'Type', 'Active', 'Created', 'Updated',
+                    'Payment Count', 'Total Volume USD'
                 ])
                 
-                # Data
-                currencies = Currency.objects.all().order_by('code')
+                # Write currency data
                 for currency in currencies:
+                    # Get payment stats for this currency
+                    payments = UniversalPayment.objects.filter(
+                        currency=currency,
+                        status='completed'
+                    )
+                    payment_count = payments.count()
+                    total_volume = payments.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0
+                    
                     writer.writerow([
                         currency.code,
                         currency.name,
                         currency.currency_type,
-                        currency.usd_rate,
-                        currency.rate_updated_at.isoformat() if currency.rate_updated_at else None
+                        currency.is_active,
+                        currency.created_at.strftime('%Y-%m-%d'),
+                        currency.updated_at.strftime('%Y-%m-%d'),
+                        payment_count,
+                        f"{total_volume:.2f}"
                     ])
             
             self.stdout.write(
-                self.style.SUCCESS(f"   ✅ Exported {currencies.count()} currencies to {filename}")
+                self.style.SUCCESS(f"✅ Statistics exported to: {filename}")
             )
             
         except Exception as e:
+            logger.error(f"Failed to export CSV: {e}")
             self.stdout.write(
-                self.style.ERROR(f"   ❌ Export failed: {str(e)}")
+                self.style.ERROR(f"❌ Failed to export CSV: {e}")
             )