django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/payments/services/providers/nowpayments/sync.py

@@ -0,0 +1,196 @@
+"""
+NowPayments currency synchronization service.
+
+Handles syncing currencies from NowPayments API to database.
+"""
+
+from typing import Optional, Tuple, List
+from django.db import transaction
+from django.utils import timezone
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.models import Currency, Network, ProviderCurrency
+from ..models import UniversalCurrency, CurrencySyncResult
+from .config import NowPaymentsConfig as Config
+
+logger = get_logger("nowpayments_sync")
+
+
+class NowPaymentsCurrencySync:
+    """Service for synchronizing NowPayments currencies to database."""
+    
+    def __init__(self, provider_name: str = 'nowpayments'):
+        """Initialize currency sync service."""
+        self.provider_name = provider_name
+        
+    def sync_currencies_to_db(self, currencies: List[UniversalCurrency]) -> CurrencySyncResult:
+        """
+        Sync universal currencies to database.
+        
+        Args:
+            currencies: List of universal currencies from provider
+            
+        Returns:
+            CurrencySyncResult: Sync operation results
+        """
+        result = CurrencySyncResult(total_processed=len(currencies))
+        
+        try:
+            with transaction.atomic():
+                for currency in currencies:
+                    try:
+                        self._sync_single_currency(currency, result)
+                    except Exception as e:
+                        error_msg = f"Failed to sync {currency.provider_currency_code}: {e}"
+                        logger.error(error_msg)
+                        result.errors.append(error_msg)
+                        
+            logger.info(
+                f"Currency sync completed: {result.currencies_created} created, "
+                f"{result.currencies_updated} updated, "
+                f"{result.provider_currencies_created} provider currencies created, "
+                f"{len(result.errors)} errors"
+            )
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Currency sync transaction failed: {e}")
+            result.errors.append(f"Transaction failed: {e}")
+            return result
+    
+    def _sync_single_currency(self, currency: UniversalCurrency, result: CurrencySyncResult):
+        """Sync a single currency to database."""
+        
+        # 1. Ensure base currency exists
+        base_currency, currency_created = self._get_or_create_currency(currency)
+        if currency_created:
+            result.currencies_created += 1
+        else:
+            # Update existing currency if needed
+            updated = self._update_currency_if_needed(base_currency, currency)
+            if updated:
+                result.currencies_updated += 1
+        
+        # 2. Ensure network exists (if applicable)
+        network = None
+        if currency.network_code:
+            network, network_created = self._get_or_create_network(currency, base_currency)
+            if network_created:
+                result.networks_created += 1
+        
+        # 3. Create or update provider currency
+        provider_currency, pc_created = self._get_or_create_provider_currency(
+            currency, base_currency, network
+        )
+        
+        if pc_created:
+            result.provider_currencies_created += 1
+        else:
+            # Update existing provider currency
+            updated = self._update_provider_currency_if_needed(provider_currency, currency)
+            if updated:
+                result.provider_currencies_updated += 1
+    
+    def _get_or_create_currency(self, currency: UniversalCurrency) -> Tuple[Currency, bool]:
+        """Get or create base currency."""
+        
+        defaults = {
+            'name': currency.name,
+            'currency_type': currency.currency_type,
+            'is_active': currency.is_enabled,
+            'usd_rate': 1.0,  # Will be updated by rate sync
+            'usd_rate_updated_at': None,
+            'decimal_places': self._get_decimal_places(currency),
+        }
+        
+        return Currency.objects.get_or_create(
+            code=currency.base_currency_code,
+            defaults=defaults
+        )
+    
+    def _update_currency_if_needed(self, base_currency: Currency, currency: UniversalCurrency) -> bool:
+        """Update currency if needed."""
+        updated = False
+        
+        # Always update name to use the proper generated name
+        if base_currency.name != currency.name:
+            base_currency.name = currency.name
+            updated = True
+        
+        # Update activity status
+        if base_currency.is_active != currency.is_enabled:
+            base_currency.is_active = currency.is_enabled
+            updated = True
+        
+        if updated:
+            base_currency.save()
+            
+        return updated
+    
+    def _get_or_create_network(self, currency: UniversalCurrency, base_currency: Currency) -> Tuple[Network, bool]:
+        """Get or create network for currency."""
+        
+        network_name = Config.get_network_name(currency.network_code)
+        
+        defaults = {
+            'name': network_name,
+            'native_currency': base_currency,
+            'is_active': True,
+            'confirmation_blocks': Config.get_confirmation_blocks(currency.network_code),
+        }
+        
+        return Network.objects.get_or_create(
+            code=currency.network_code,
+            defaults=defaults
+        )
+    
+    def _get_or_create_provider_currency(
+        self, 
+        currency: UniversalCurrency, 
+        base_currency: Currency, 
+        network: Optional[Network]
+    ) -> Tuple[ProviderCurrency, bool]:
+        """Get or create provider currency."""
+        
+        defaults = {
+            'currency': base_currency,
+            'network': network,
+            'is_enabled': currency.is_enabled,
+        }
+        
+        return ProviderCurrency.objects.get_or_create(
+            provider=self.provider_name,
+            provider_currency_code=currency.provider_currency_code,
+            defaults=defaults
+        )
+    
+    def _update_provider_currency_if_needed(
+        self, 
+        provider_currency: ProviderCurrency, 
+        currency: UniversalCurrency
+    ) -> bool:
+        """Update provider currency if needed."""
+        updated = False
+        
+        # Update enabled status
+        if provider_currency.is_enabled != currency.is_enabled:
+            provider_currency.is_enabled = currency.is_enabled
+            updated = True
+        
+        # Update timestamps
+        if updated:
+            provider_currency.updated_at = timezone.now()
+            provider_currency.save()
+            
+        return updated
+    
+    def _get_decimal_places(self, currency: UniversalCurrency) -> int:
+        """Get appropriate decimal places for currency."""
+        if currency.currency_type == 'fiat':
+            return 2
+        elif currency.is_stable:
+            return 6  # Stablecoins
+        else:
+            return 8  # Regular crypto
+    

django_cfg/apps/payments/services/providers/registry.py

@@ -4,44 +4,16 @@ Provider registry for the Universal Payment System v2.0.
 Centralized management of payment providers with health monitoring and fallbacks.
 """
 
-from enum import Enum
 from typing import Dict, List, Optional, Type, Any
 from django_cfg.modules.django_logger import get_logger
 # ConfigService removed - using direct Constance access
 from ..types import ServiceOperationResult
-from .base import BaseProvider, ProviderConfig
-from .nowpayments import NowPaymentsProvider, NowPaymentsConfig
+from .base import BaseProvider
+from .models import ProviderConfig, ProviderEnum
+from .nowpayments import NowPaymentsProvider, NowPaymentsProviderConfig
 
 logger = get_logger("provider_registry")
 
-
-# Provider enums
-class ProviderEnum(Enum):
-    NOWPAYMENTS = "nowpayments"
-    CRYPTAPI = "cryptapi"
-    STRIPE = "stripe"
-    CRYPTOMUS = "cryptomus"
-
-    @classmethod
-    def get_crypto_providers(cls):
-        """Get list of crypto provider values."""
-        return [cls.NOWPAYMENTS.value, cls.CRYPTAPI.value, cls.CRYPTOMUS.value]
-    
-    @classmethod
-    def get_fiat_providers(cls):
-        """Get list of fiat provider values."""
-        return [cls.STRIPE.value]
-
-    @classmethod
-    def get_priority_order(cls):
-        """Get list of provider values in priority order."""
-        return [
-            cls.NOWPAYMENTS.value, 
-            cls.CRYPTAPI.value, 
-            cls.STRIPE.value, 
-            cls.CRYPTOMUS.value
-        ]
-
 class ProviderRegistry:
     """
     Registry for managing payment providers.
@@ -62,7 +34,7 @@ class ProviderRegistry:
             ProviderEnum.NOWPAYMENTS.value: NowPaymentsProvider,
         }
         self._provider_configs: Dict[str, Type[ProviderConfig]] = {
-            ProviderEnum.NOWPAYMENTS.value: NowPaymentsConfig,
+            ProviderEnum.NOWPAYMENTS.value: NowPaymentsProviderConfig,
         }
         
         self._health_status: Dict[str, bool] = {}

django_cfg/apps/payments/services/providers/sync_service.py

@@ -0,0 +1,277 @@
+"""
+Universal provider synchronization service.
+
+Handles synchronization of currencies from all payment providers to database.
+"""
+
+from typing import List, Dict, Optional
+from django.db import transaction
+from django.utils import timezone
+from datetime import timedelta
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.models import ProviderCurrency
+from .models import CurrencySyncResult
+from .registry import get_provider_registry
+from .base import BaseProvider
+
+logger = get_logger("provider_sync")
+
+
+class ProviderSyncService:
+    """Universal service for synchronizing all payment providers."""
+    
+    def __init__(self):
+        """Initialize provider sync service."""
+        self.registry = get_provider_registry()
+    
+    def sync_all_providers(
+        self, 
+        force_refresh: bool = False,
+        provider_names: Optional[List[str]] = None
+    ) -> Dict[str, CurrencySyncResult]:
+        """
+        Sync currencies from all available providers.
+        
+        Args:
+            force_refresh: Force refresh even if recently synced
+            provider_names: Specific providers to sync (None = all available)
+            
+        Returns:
+            Dict[str, CurrencySyncResult]: Results by provider name
+        """
+        logger.info("Starting universal provider synchronization")
+        
+        # Get providers to sync
+        if provider_names:
+            providers_to_sync = []
+            for name in provider_names:
+                provider = self.registry.get_provider(name)
+                if provider:
+                    providers_to_sync.append((name, provider))
+                else:
+                    logger.warning(f"Provider {name} not available")
+        else:
+            available_providers = self.registry.get_available_providers()
+            providers_to_sync = [
+                (name, self.registry.get_provider(name)) 
+                for name in available_providers
+            ]
+        
+        if not providers_to_sync:
+            logger.warning("No providers available for synchronization")
+            return {}
+        
+        # Sync each provider
+        results = {}
+        total_currencies = 0
+        total_errors = 0
+        
+        for provider_name, provider in providers_to_sync:
+            try:
+                logger.info(f"Syncing provider: {provider_name}")
+                
+                # Check if sync is needed
+                if not force_refresh and self._is_recently_synced(provider_name):
+                    logger.info(f"Provider {provider_name} recently synced, skipping")
+                    results[provider_name] = CurrencySyncResult(
+                        total_processed=0,
+                        errors=[f"Skipped - recently synced (use --force-refresh to override)"]
+                    )
+                    continue
+                
+                # Perform sync
+                sync_result = self._sync_single_provider(provider)
+                results[provider_name] = sync_result
+                
+                # Update stats
+                total_currencies += sync_result.currencies_created + sync_result.currencies_updated
+                total_errors += len(sync_result.errors)
+                
+                # Mark sync time
+                self._mark_sync_time(provider_name)
+                
+                logger.info(
+                    f"Provider {provider_name} sync completed: "
+                    f"{sync_result.currencies_created} created, "
+                    f"{sync_result.currencies_updated} updated, "
+                    f"{len(sync_result.errors)} errors"
+                )
+                
+            except Exception as e:
+                error_msg = f"Provider {provider_name} sync failed: {e}"
+                logger.error(error_msg)
+                results[provider_name] = CurrencySyncResult(
+                    total_processed=0,
+                    errors=[error_msg]
+                )
+                total_errors += 1
+        
+        logger.info(
+            f"Universal provider sync completed: "
+            f"{len(results)} providers processed, "
+            f"{total_currencies} currencies synced, "
+            f"{total_errors} errors"
+        )
+        
+        return results
+    
+    def sync_provider(
+        self, 
+        provider_name: str, 
+        force_refresh: bool = False
+    ) -> CurrencySyncResult:
+        """
+        Sync currencies from a specific provider.
+        
+        Args:
+            provider_name: Name of provider to sync
+            force_refresh: Force refresh even if recently synced
+            
+        Returns:
+            CurrencySyncResult: Sync operation result
+        """
+        provider = self.registry.get_provider(provider_name)
+        if not provider:
+            return CurrencySyncResult(
+                total_processed=0,
+                errors=[f"Provider {provider_name} not available"]
+            )
+        
+        # Check if sync is needed
+        if not force_refresh and self._is_recently_synced(provider_name):
+            return CurrencySyncResult(
+                total_processed=0,
+                errors=[f"Provider {provider_name} recently synced (use force_refresh=True to override)"]
+            )
+        
+        # Perform sync
+        result = self._sync_single_provider(provider)
+        
+        # Mark sync time
+        self._mark_sync_time(provider_name)
+        
+        return result
+    
+    def get_sync_statistics(self) -> Dict[str, any]:
+        """
+        Get synchronization statistics for all providers.
+        
+        Returns:
+            Dict: Statistics by provider
+        """
+        stats = {}
+        
+        for provider_name in self.registry.list_providers():
+            provider_stats = self._get_provider_stats(provider_name)
+            stats[provider_name] = provider_stats
+        
+        return stats
+    
+    def _sync_single_provider(self, provider: BaseProvider) -> CurrencySyncResult:
+        """Sync currencies from a single provider."""
+        try:
+            logger.debug(f"Starting sync for provider: {provider.name}")
+            
+            # Use provider's sync method
+            result = provider.sync_currencies_to_db()
+            
+            logger.debug(
+                f"Provider {provider.name} sync result: "
+                f"{result.currencies_created} created, "
+                f"{result.currencies_updated} updated, "
+                f"{result.provider_currencies_created} provider currencies created"
+            )
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Sync failed for provider {provider.name}: {e}"
+            logger.error(error_msg)
+            return CurrencySyncResult(
+                total_processed=0,
+                errors=[error_msg]
+            )
+    
+    def _is_recently_synced(self, provider_name: str, hours: int = 1) -> bool:
+        """Check if provider was recently synced."""
+        try:
+            # Check if any provider currencies were updated recently
+            recent_threshold = timezone.now() - timedelta(hours=hours)
+            
+            recent_updates = ProviderCurrency.objects.filter(
+                provider=provider_name,
+                updated_at__gte=recent_threshold
+            ).exists()
+            
+            return recent_updates
+            
+        except Exception as e:
+            logger.warning(f"Failed to check sync status for {provider_name}: {e}")
+            return False
+    
+    def _mark_sync_time(self, provider_name: str):
+        """Mark sync time for provider (could be stored in cache/database)."""
+        # For now, we rely on ProviderCurrency.updated_at
+        # In future, could store in dedicated sync log table
+        pass
+    
+    def _get_provider_stats(self, provider_name: str) -> Dict[str, any]:
+        """Get statistics for a specific provider."""
+        try:
+            from django.db.models import Count, Q
+            
+            # Get provider currency stats
+            provider_currencies = ProviderCurrency.objects.filter(provider=provider_name)
+            
+            total_currencies = provider_currencies.count()
+            enabled_currencies = provider_currencies.filter(is_enabled=True).count()
+            
+            # Get recent activity
+            recent_threshold = timezone.now() - timedelta(hours=24)
+            recent_updates = provider_currencies.filter(
+                updated_at__gte=recent_threshold
+            ).count()
+            
+            # Get last sync time
+            last_sync = None
+            if provider_currencies.exists():
+                last_sync = provider_currencies.order_by('-updated_at').first().updated_at
+            
+            return {
+                'total_currencies': total_currencies,
+                'enabled_currencies': enabled_currencies,
+                'disabled_currencies': total_currencies - enabled_currencies,
+                'recent_updates_24h': recent_updates,
+                'last_sync': last_sync.isoformat() if last_sync else None,
+                'is_recently_synced': self._is_recently_synced(provider_name)
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get stats for {provider_name}: {e}")
+            return {
+                'error': str(e),
+                'total_currencies': 0,
+                'enabled_currencies': 0,
+                'disabled_currencies': 0,
+                'recent_updates_24h': 0,
+                'last_sync': None,
+                'is_recently_synced': False
+            }
+
+
+# Global sync service instance
+_global_sync_service: Optional[ProviderSyncService] = None
+
+
+def get_provider_sync_service() -> ProviderSyncService:
+    """
+    Get global provider sync service instance.
+    
+    Returns:
+        ProviderSyncService: Global sync service instance
+    """
+    global _global_sync_service
+    if _global_sync_service is None:
+        _global_sync_service = ProviderSyncService()
+    return _global_sync_service

django_cfg/apps/payments/static/payments/js/api-client.js

@@ -10,8 +10,22 @@ class PaymentAPIClient {
 
     // Helper method to get CSRF token
     getCSRFToken() {
-        const token = document.querySelector('[name=csrfmiddlewaretoken]');
-        return token ? token.value : '';
+        // Try to get token from form input first
+        const tokenInput = document.querySelector('[name=csrfmiddlewaretoken]');
+        if (tokenInput && tokenInput.value) {
+            return tokenInput.value;
+        }
+        
+        // Fallback to cookie
+        const cookieString = document.cookie;
+        if (cookieString.includes('csrftoken=')) {
+            const match = cookieString.match(/csrftoken=([^;]+)/);
+            if (match) {
+                return match[1];
+            }
+        }
+            
+        return '';
     }
 
     // Generic request method
@@ -129,7 +143,7 @@ class PaymentAPIClient {
         supported: (params = {}) => this.get(`${this.baseURL}/currencies/supported/`, params),
         
         // Get currencies by provider
-        byProvider: (provider) => this.get(`${this.baseURL}/currencies/supported/`, { provider }),
+        byProvider: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider, page_size: 1000 }),
         
         // Get exchange rates
         rates: (params = {}) => this.get(`${this.baseURL}/currencies/rates/`, params),
@@ -138,7 +152,7 @@ class PaymentAPIClient {
         convert: (from, to, amount) => this.post(`${this.baseURL}/currencies/convert/`, { from, to, amount }),
         
         // Get provider-specific currency configurations
-        providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider }),
+        providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider, page_size: 1000 }),
         
         // Get currencies grouped by provider
         byProviderGrouped: () => this.get(`${this.baseURL}/provider-currencies/by_provider/`)
@@ -302,7 +316,7 @@ class PaymentAPIClient {
         
         // Webhook test method
         webhookTest: {
-            send: (url, eventType) => this.post(`${this.adminURL}/api/webhooks/test/`, { 
+            send: (url, eventType) => this.post(`${this.adminURL}/api/webhook-test/test/`, { 
                 webhook_url: url, 
                 event_type: eventType 
             })
@@ -377,7 +391,11 @@ class PaymentAPIClient {
 }
 
 // Create global instance
+console.log('🔧 PaymentAPIClient: Creating global instance...');
 window.PaymentAPI = new PaymentAPIClient();
+console.log('✅ PaymentAPIClient: Global instance created');
+console.log('🔍 PaymentAPI.currencies:', window.PaymentAPI.currencies);
+console.log('🔍 PaymentAPI.admin:', window.PaymentAPI.admin);
 
 // Export for modules
 if (typeof module !== 'undefined' && module.exports) {