django-cfg 1.3.7__py3-none-any.whl → 1.3.11__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.
@@ -52,17 +24,17 @@ class ProviderRegistry:
     
     def __init__(self):
         """Initialize provider registry."""
-        # Use PaymentConfigService for configuration
-        from ...config.constance import get_payment_config_service
+        # Use PaymentsConfigManager for configuration from BaseCfgAutoModule
+        from ...config.django_cfg_integration import PaymentsConfigManager
 
-        self.config_service = get_payment_config_service()
+        self.config_manager = PaymentsConfigManager
         self._providers: Dict[str, BaseProvider] = {}
 
         self._provider_classes: Dict[str, Type[BaseProvider]] = {
             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] = {}
@@ -78,9 +50,9 @@ class ProviderRegistry:
         try:
             logger.info("Initializing provider registry")
             
-            # Get all provider configurations
+            # Get all provider configurations from BaseCfgAutoModule
             try:
-                provider_configs = self.config_service.get_all_provider_configs()
+                provider_configs = self.config_manager.get_all_provider_configs()
             except Exception as e:
                 return ServiceOperationResult(
                     success=False,

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/services/types/requests.py

@@ -24,8 +24,8 @@ class PaymentCreateRequest(BaseModel):
     
     user_id: int = Field(gt=0, description="User ID")
     amount_usd: float = Field(gt=1.0, le=50000.0, description="Amount in USD")
-    currency_code: Literal['BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT'] = Field(
-        description="Cryptocurrency code"
+    currency_code: str = Field(
+        min_length=2, max_length=10, description="Cryptocurrency code"
     )
     provider: Literal['nowpayments'] = Field(default='nowpayments', description="Payment provider")
     callback_url: Optional[str] = Field(None, description="Success callback URL")
@@ -36,11 +36,23 @@ class PaymentCreateRequest(BaseModel):
     @field_validator('currency_code')
     @classmethod
     def validate_currency(cls, v: str) -> str:
-        """Validate currency is supported."""
-        supported = ['BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT']
-        if v.upper() not in supported:
-            raise ValueError(f"Currency {v} not supported. Supported: {', '.join(supported)}")
-        return v.upper()
+        """Validate currency is supported by checking database."""
+        from django_cfg.apps.payments.models import Currency
+        
+        currency_code = v.upper().strip()
+        
+        # Check if currency exists in database and is active
+        try:
+            currency = Currency.objects.get(code=currency_code, is_active=True)
+            return currency_code
+        except Currency.DoesNotExist:
+            # Get list of active currencies for error message
+            active_currencies = Currency.objects.filter(is_active=True).values_list('code', flat=True)[:10]
+            currency_list = ', '.join(active_currencies) + ('...' if len(active_currencies) == 10 else '')
+            raise ValueError(f"Currency {currency_code} not found or inactive. Available: {currency_list}")
+        except Exception:
+            # Fallback validation if database is not available
+            return currency_code
     
     @field_validator('callback_url', 'cancel_url')
     @classmethod

django_cfg/apps/payments/signals/payment_signals.py

@@ -17,16 +17,45 @@ logger = get_logger("payment_signals")
 
 
 @receiver(pre_save, sender=UniversalPayment)
-def store_original_status(sender, instance: UniversalPayment, **kwargs):
-    """Store original status for change detection."""
+def handle_status_changes(sender, instance: UniversalPayment, **kwargs):
+    """
+    Handle status changes and update status_changed_at field.
+    
+    This signal automatically updates status_changed_at when status changes,
+    ensuring consistent tracking across all update methods.
+    """
     if instance.pk:
         try:
             original = UniversalPayment.objects.get(pk=instance.pk)
             instance._original_status = original.status
+            
+            # Check if status has changed
+            if original.status != instance.status:
+                instance.status_changed_at = timezone.now()
+                
+                # Set completed_at if status changed to completed
+                if instance.status == 'completed' and not instance.completed_at:
+                    instance.completed_at = timezone.now()
+                
+                logger.debug(f"Status change detected in pre_save", extra={
+                    'payment_id': str(instance.id),
+                    'old_status': original.status,
+                    'new_status': instance.status,
+                    'status_changed_at': instance.status_changed_at.isoformat()
+                })
         except UniversalPayment.DoesNotExist:
             instance._original_status = None
     else:
+        # New object - set status_changed_at if status is set
         instance._original_status = None
+        if instance.status and not instance.status_changed_at:
+            instance.status_changed_at = timezone.now()
+            
+            logger.debug(f"New payment status set in pre_save", extra={
+                'payment_id': 'new',
+                'status': instance.status,
+                'status_changed_at': instance.status_changed_at.isoformat()
+            })
 
 
 @receiver(post_save, sender=UniversalPayment)