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

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

@@ -1,386 +1,452 @@
 """
-Provider registry for managing payment providers.
+Provider registry for the Universal Payment System v2.0.
 
-Central registry with lazy loading and typed configuration.
+Centralized management of payment providers with health monitoring and fallbacks.
 """
 
-import time
-from typing import Optional, List, Dict, Any
-from datetime import datetime, timedelta
-from django.core.cache import cache
-from django.utils import timezone
-
-from .base import PaymentProvider
-from ...utils.config_utils import get_payments_config
-from .nowpayments.provider import NowPaymentsProvider
-from .nowpayments.models import NowPaymentsConfig
-from .cryptapi.provider import CryptAPIProvider
-from .cryptapi.models import CryptAPIConfig
-from .cryptomus.provider import CryptomusProvider
-from .cryptomus.models import CryptomusConfig
-from .stripe.provider import StripeProvider
-from .stripe.models import StripeConfig
+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
 
 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:
-    """Central registry for payment providers with typed configs."""
+    """
+    Registry for managing payment providers.
+    
+    Provides centralized access to providers with health monitoring,
+    configuration management, and fallback mechanisms.
+    """
     
     def __init__(self):
-        """Initialize registry with lazy loading and health monitoring."""
-        self._providers: dict[str, PaymentProvider] = {}
-        self._provider_configs: dict[str, dict] = {}
-        self._health_cache: dict[str, dict] = {}
-        self._fallback_order: List[str] = []  # Provider preference order
-        self._load_configurations()
-        self._initialize_health_monitoring()
+        """Initialize provider registry."""
+        # Use PaymentConfigService for configuration
+        from ...config.constance import get_payment_config_service
+
+        self.config_service = get_payment_config_service()
+        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,
+        }
+        
+        self._health_status: Dict[str, bool] = {}
+        self._initialized = False
     
-    def _load_configurations(self) -> None:
-        """Load provider configurations."""
+    def initialize(self) -> ServiceOperationResult:
+        """
+        Initialize all configured providers.
+        
+        Returns:
+            ServiceOperationResult: Initialization result
+        """
         try:
-            config = get_payments_config()
+            logger.info("Initializing provider registry")
             
-            self._provider_configs = {}
-            for provider_name, provider_config in config.providers.items():
-                if provider_config.enabled:
-                    self._provider_configs[provider_name] = provider_config.get_config_dict()
-                    
-        except Exception as e:
-            logger.warning(f"Failed to load provider configurations: {e}")
-            self._provider_configs = {}
-    
-    def _create_provider(self, name: str, config_dict: dict) -> Optional[PaymentProvider]:
-        """Create provider instance from configuration with typed config."""
-        try:
-            if name == 'nowpayments':
-                config = NowPaymentsConfig(**config_dict)
-                return NowPaymentsProvider(config)
-            elif name == 'cryptapi':
-                config = CryptAPIConfig(**config_dict)
-                return CryptAPIProvider(config)
-            elif name == 'cryptomus':
-                config = CryptomusConfig(**config_dict)
-                return CryptomusProvider(config)
-            elif name == 'stripe':
-                config = StripeConfig(**config_dict)
-                return StripeProvider(config)
-            else:
-                logger.warning(f"Unknown provider type: {name}")
-                return None
+            # Get all provider configurations
+            try:
+                provider_configs = self.config_service.get_all_provider_configs()
+            except Exception as e:
+                return ServiceOperationResult(
+                    success=False,
+                    message=f"Failed to get provider configurations: {e}",
+                    error_code="config_failed"
+                )
+            
+            # provider_configs is already a dict from get_all_provider_configs()
+            initialized_count = 0
+            failed_providers = []
+            
+            # Initialize each configured provider
+            for provider_name, config_data in provider_configs.items():
+                if not config_data.get('enabled', False):
+                    logger.debug(f"Skipping disabled provider: {provider_name}")
+                    continue
                 
-        except Exception as e:
-            logger.error(f"Failed to create provider {name}: {e}")
-            return None
-    
-    def register_provider(self, name: str, provider: PaymentProvider) -> None:
-        """Register a payment provider instance."""
-        self._providers[name] = provider
-    
-    def get_provider(self, name: str) -> Optional[PaymentProvider]:
-        """Get provider by name with lazy loading."""
-        # Check if already loaded
-        if name in self._providers:
-            return self._providers[name]
-        
-        # Try to load from configuration
-        if name in self._provider_configs:
-            provider = self._create_provider(name, self._provider_configs[name])
-            if provider:
-                self._providers[name] = provider
-                return provider
-        
-        return None
-    
-    def list_providers(self) -> List[str]:
-        """Get list of available providers."""
-        available = set(self._providers.keys())
-        available.update(self._provider_configs.keys())
-        return list(available)
-    
-    def get_active_providers(self) -> List[str]:
-        """Get list of active providers."""
-        active = []
-        for name in self.list_providers():
-            provider = self.get_provider(name)
-            if provider and provider.enabled:
-                active.append(name)
-        return active
-    
-    def _initialize_health_monitoring(self) -> None:
-        """Initialize health monitoring for all providers."""
-        try:
-            # Set up fallback order based on configuration or defaults
-            available_providers = self.list_providers()
+                try:
+                    provider = self._create_provider(provider_name, config_data)
+                    if provider:
+                        self._providers[provider_name] = provider
+                        initialized_count += 1
+                        logger.info(f"Initialized provider: {provider_name}")
+                    else:
+                        failed_providers.append(provider_name)
+                        
+                except Exception as e:
+                    logger.error(f"Failed to initialize provider {provider_name}: {e}")
+                    failed_providers.append(provider_name)
             
-            # Default priority: NowPayments -> CryptAPI -> Cryptomus -> Stripe
-            priority_order = ['nowpayments', 'cryptapi', 'cryptomus', 'stripe']
+            self._initialized = True
             
-            self._fallback_order = [p for p in priority_order if p in available_providers]
+            # Perform initial health check
+            self.health_check_all()
             
-            # Add any other providers not in priority list
-            for provider in available_providers:
-                if provider not in self._fallback_order:
-                    self._fallback_order.append(provider)
-                    
-            logger.info(f"Initialized provider fallback order: {self._fallback_order}")
+            result_message = f"Initialized {initialized_count} providers"
+            if failed_providers:
+                result_message += f", failed: {', '.join(failed_providers)}"
+            
+            return ServiceOperationResult(
+                success=True,
+                message=result_message,
+                data={
+                    'initialized_providers': list(self._providers.keys()),
+                    'failed_providers': failed_providers,
+                    'total_configured': len(provider_configs),
+                    'initialized_count': initialized_count
+                }
+            )
             
         except Exception as e:
-            logger.error(f"Error initializing health monitoring: {e}")
-            self._fallback_order = []
+            logger.error(f"Provider registry initialization failed: {e}")
+            return ServiceOperationResult(
+                success=False,
+                message=f"Registry initialization failed: {e}",
+                error_code="initialization_failed"
+            )
     
-    async def health_check_all(self) -> Dict[str, Dict[str, Any]]:
+    def get_provider(self, provider_name: str) -> Optional[BaseProvider]:
         """
-        Check health of all providers with performance metrics.
+        Get provider by name.
         
+        Args:
+            provider_name: Provider name
+            
         Returns:
-            Dict mapping provider names to health status
+            Optional[BaseProvider]: Provider instance or None
         """
-        results = {}
+        if not self._initialized:
+            logger.warning("Registry not initialized, initializing now")
+            self.initialize()
         
-        for provider_name in self.list_providers():
-            try:
-                provider = self.get_provider(provider_name)
-                if not provider:
-                    results[provider_name] = {
-                        'status': 'unavailable',
-                        'error': 'Provider not loaded',
-                        'last_check': timezone.now().isoformat()
-                    }
-                    continue
-                
-                # Measure response time
-                start_time = time.time()
-                
-                try:
-                    # Use get_supported_currencies as health check endpoint
-                    health_response = provider.get_supported_currencies()
-                    response_time = int((time.time() - start_time) * 1000)  # ms
-                    
-                    if health_response.success:
-                        status = 'healthy'
-                        error = None
-                    else:
-                        status = 'degraded'
-                        error = health_response.error_message
-                        
-                except Exception as provider_error:
-                    response_time = int((time.time() - start_time) * 1000)  # ms
-                    status = 'unhealthy'
-                    error = str(provider_error)
-                
-                # Cache health status
-                health_data = {
-                    'status': status,
-                    'response_time_ms': response_time,
-                    'error': error,
-                    'last_check': timezone.now().isoformat(),
-                    'provider_enabled': provider.enabled
-                }
-                
-                # Store in cache for 5 minutes
-                cache_key = f"provider_health:{provider_name}"
-                cache.set(cache_key, health_data, timeout=300)
-                
-                results[provider_name] = health_data
-                
-            except Exception as e:
-                logger.error(f"Health check failed for {provider_name}: {e}")
-                results[provider_name] = {
-                    'status': 'error',
-                    'error': str(e),
-                    'last_check': timezone.now().isoformat()
-                }
+        provider = self._providers.get(provider_name)
+        if not provider:
+            logger.warning(f"Provider not found: {provider_name}")
+            return None
         
-        return results
+        # Check if provider is healthy
+        if not self._health_status.get(provider_name, False):
+            logger.warning(f"Provider {provider_name} is unhealthy")
+        
+        return provider
     
-    def get_healthy_providers(self, operation: str = None) -> List[str]:
+    def get_available_providers(self) -> List[str]:
         """
-        Get list of healthy providers in fallback order.
+        Get list of available (healthy) providers.
         
-        Args:
-            operation: Specific operation (e.g., 'payment_creation', 'webhook')
-            
         Returns:
-            List of provider names sorted by health and priority
+            List[str]: List of available provider names
         """
-        healthy_providers = []
+        if not self._initialized:
+            self.initialize()
         
-        for provider_name in self._fallback_order:
-            # Check cached health status
-            cache_key = f"provider_health:{provider_name}"
-            health_data = cache.get(cache_key)
-            
-            if health_data and health_data.get('status') in ['healthy', 'degraded']:
-                provider = self.get_provider(provider_name)
-                if provider and provider.enabled:
-                    healthy_providers.append(provider_name)
+        return [
+            name for name, provider in self._providers.items()
+            if self._health_status.get(name, False)
+        ]
+    
+    def get_primary_provider(self) -> Optional[BaseProvider]:
+        """
+        Get primary (preferred) provider.
+        
+        Returns:
+            Optional[BaseProvider]: Primary provider or None
+        """
+        available_providers = self.get_available_providers()
+        
+        if not available_providers:
+            logger.warning("No healthy providers available")
+            return None
+        
+        # Priority order: nowpayments first, then others
+        priority_order = ProviderEnum.get_priority_order()
         
-        return healthy_providers
+        for provider_name in priority_order:
+            if provider_name in available_providers:
+                return self._providers[provider_name]
+        
+        # Fallback to first available
+        return self._providers[available_providers[0]]
     
-    def get_provider_with_fallback(self, preferred_provider: str = None, operation: str = None) -> Optional[PaymentProvider]:
+    def get_provider_for_currency(self, currency_code: str) -> Optional[BaseProvider]:
         """
-        Get provider with automatic fallback to healthy alternatives.
+        Get best provider for specific currency.
         
         Args:
-            preferred_provider: Preferred provider name
-            operation: Operation type for provider selection
+            currency_code: Currency code
             
         Returns:
-            PaymentProvider instance or None if all providers are down
+            Optional[BaseProvider]: Best provider for currency or None
         """
-        # Start with preferred provider if specified and healthy
-        if preferred_provider:
-            provider = self.get_provider(preferred_provider)
-            if provider and provider.enabled:
-                # Quick health check from cache
-                cache_key = f"provider_health:{preferred_provider}"
-                health_data = cache.get(cache_key)
-                
-                if not health_data or health_data.get('status') in ['healthy', 'degraded']:
-                    logger.info(f"Using preferred provider: {preferred_provider}")
-                    return provider
-                else:
-                    logger.warning(f"Preferred provider {preferred_provider} is unhealthy, falling back")
+        available_providers = self.get_available_providers()
         
-        # Fallback to healthy providers in order
-        healthy_providers = self.get_healthy_providers(operation)
+        # Find providers that support the currency
+        supporting_providers = []
+        for provider_name in available_providers:
+            provider = self._providers[provider_name]
+            if currency_code in provider.config.supported_currencies:
+                supporting_providers.append(provider)
         
-        for provider_name in healthy_providers:
-            provider = self.get_provider(provider_name)
-            if provider:
-                logger.info(f"Using fallback provider: {provider_name}")
-                return provider
+        if not supporting_providers:
+            logger.warning(f"No providers support currency: {currency_code}")
+            return None
         
-        logger.error("No healthy providers available!")
-        return None
+        # Return first supporting provider (could be enhanced with more logic)
+        return supporting_providers[0]
     
-    def record_provider_performance(self, provider_name: str, operation: str, 
-                                  response_time_ms: int, success: bool) -> None:
+    def health_check_all(self) -> ServiceOperationResult:
         """
-        Record provider performance metrics.
+        Perform health check on all providers.
         
-        Args:
-            provider_name: Name of the provider
-            operation: Operation performed (e.g., 'create_payment', 'check_status')
-            response_time_ms: Response time in milliseconds
-            success: Whether operation was successful
+        Returns:
+            ServiceOperationResult: Overall health status
         """
         try:
-            # Store performance metrics in cache
-            metric_key = f"provider_metrics:{provider_name}:{operation}"
+            logger.debug("Performing health check on all providers")
+            
+            if not self._providers:
+                return ServiceOperationResult(
+                    success=False,
+                    message="No providers initialized",
+                    error_code="no_providers"
+                )
+            
+            health_results = {}
+            healthy_count = 0
+            
+            for provider_name, provider in self._providers.items():
+                try:
+                    health_result = provider.health_check()
+                    is_healthy = health_result.success
+                    
+                    self._health_status[provider_name] = is_healthy
+                    health_results[provider_name] = {
+                        'healthy': is_healthy,
+                        'message': health_result.message,
+                        'data': health_result.data
+                    }
+                    
+                    if is_healthy:
+                        healthy_count += 1
+                    
+                    logger.debug(f"Provider {provider_name} health: {is_healthy}")
+                    
+                except Exception as e:
+                    logger.error(f"Health check failed for {provider_name}: {e}")
+                    self._health_status[provider_name] = False
+                    health_results[provider_name] = {
+                        'healthy': False,
+                        'message': f"Health check error: {e}",
+                        'data': {}
+                    }
+            
+            overall_healthy = healthy_count > 0
             
-            # Get current metrics
-            current_metrics = cache.get(metric_key, {
-                'total_requests': 0,
-                'successful_requests': 0,
-                'average_response_time': 0,
-                'last_updated': timezone.now().isoformat()
-            })
+            return ServiceOperationResult(
+                success=overall_healthy,
+                message=f"{healthy_count}/{len(self._providers)} providers healthy",
+                data={
+                    'total_providers': len(self._providers),
+                    'healthy_providers': healthy_count,
+                    'unhealthy_providers': len(self._providers) - healthy_count,
+                    'provider_health': health_results,
+                    'available_providers': self.get_available_providers()
+                }
+            )
             
-            # Update metrics
-            total_requests = current_metrics['total_requests'] + 1
-            successful_requests = current_metrics['successful_requests'] + (1 if success else 0)
+        except Exception as e:
+            logger.error(f"Health check failed: {e}")
+            return ServiceOperationResult(
+                success=False,
+                message=f"Health check error: {e}",
+                error_code="health_check_error"
+            )
+    
+    def refresh_configurations(self) -> ServiceOperationResult:
+        """
+        Refresh provider configurations from config service.
+        
+        Returns:
+            ServiceOperationResult: Refresh result
+        """
+        try:
+            logger.info("Refreshing provider configurations")
             
-            # Calculate rolling average response time
-            current_avg = current_metrics['average_response_time']
-            new_avg = ((current_avg * current_metrics['total_requests']) + response_time_ms) / total_requests
+            # Clear current providers
+            self._providers.clear()
+            self._health_status.clear()
+            self._initialized = False
             
-            updated_metrics = {
-                'total_requests': total_requests,
-                'successful_requests': successful_requests,
-                'success_rate': (successful_requests / total_requests) * 100,
-                'average_response_time': int(new_avg),
-                'last_response_time': response_time_ms,
-                'last_updated': timezone.now().isoformat()
+            # Refresh config service
+            self.config_service.refresh_configuration()
+            
+            # Re-initialize providers
+            return self.initialize()
+            
+        except Exception as e:
+            logger.error(f"Configuration refresh failed: {e}")
+            return ServiceOperationResult(
+                success=False,
+                message=f"Configuration refresh failed: {e}",
+                error_code="refresh_failed"
+            )
+    
+    def get_registry_stats(self) -> ServiceOperationResult:
+        """
+        Get registry statistics.
+        
+        Returns:
+            ServiceOperationResult: Registry statistics
+        """
+        try:
+            stats = {
+                'initialized': self._initialized,
+                'total_providers': len(self._providers),
+                'healthy_providers': sum(1 for h in self._health_status.values() if h),
+                'available_provider_classes': list(self._provider_classes.keys()),
+                'configured_providers': list(self._providers.keys()),
+                'health_status': dict(self._health_status)
             }
             
-            # Store for 24 hours
-            cache.set(metric_key, updated_metrics, timeout=86400)
+            return ServiceOperationResult(
+                success=True,
+                message="Registry statistics",
+                data=stats
+            )
             
-            # Log performance issues
-            if not success:
-                logger.warning(f"Provider {provider_name} operation {operation} failed (response time: {response_time_ms}ms)")
-            elif response_time_ms > 5000:  # > 5 seconds
-                logger.warning(f"Provider {provider_name} operation {operation} slow (response time: {response_time_ms}ms)")
-                
         except Exception as e:
-            logger.error(f"Error recording provider performance: {e}")
+            logger.error(f"Failed to get registry stats: {e}")
+            return ServiceOperationResult(
+                success=False,
+                message=f"Stats error: {e}",
+                error_code="stats_error"
+            )
     
-    def get_provider_metrics(self, provider_name: str = None) -> Dict[str, Dict[str, Any]]:
+    def _create_provider(self, provider_name: str, config_data: Dict[str, Any]) -> Optional[BaseProvider]:
         """
-        Get performance metrics for providers.
+        Create provider instance from configuration.
         
         Args:
-            provider_name: Specific provider or None for all providers
+            provider_name: Provider name
+            config_data: Provider configuration data
             
         Returns:
-            Dict of provider metrics
+            Optional[BaseProvider]: Provider instance or None
         """
-        if provider_name:
-            providers_to_check = [provider_name]
-        else:
-            providers_to_check = self.list_providers()
-        
-        metrics = {}
-        
-        for provider in providers_to_check:
-            provider_metrics = {}
+        try:
+            # Get provider class
+            provider_class = self._provider_classes.get(provider_name)
+            if not provider_class:
+                logger.error(f"Unknown provider class: {provider_name}")
+                return None
             
-            # Common operations to check
-            operations = ['create_payment', 'check_status', 'process_webhook', 'get_currencies']
+            # Get config class
+            config_class = self._provider_configs.get(provider_name)
+            if not config_class:
+                logger.error(f"Unknown provider config class: {provider_name}")
+                return None
             
-            for operation in operations:
-                metric_key = f"provider_metrics:{provider}:{operation}"
-                operation_metrics = cache.get(metric_key)
-                
-                if operation_metrics:
-                    provider_metrics[operation] = operation_metrics
+            # Create configuration
+            config = config_class(**config_data)
             
-            if provider_metrics:
-                metrics[provider] = provider_metrics
+            # Create provider
+            provider = provider_class(config)
+            
+            logger.debug(f"Created provider: {provider}")
+            return provider
+            
+        except Exception as e:
+            logger.error(f"Failed to create provider {provider_name}: {e}")
+            return None
+    
+    def register_provider_class(
+        self, 
+        provider_name: str, 
+        provider_class: Type[BaseProvider],
+        config_class: Type[ProviderConfig]
+    ):
+        """
+        Register new provider class.
         
-        return metrics
+        Args:
+            provider_name: Provider name
+            provider_class: Provider class
+            config_class: Provider config class
+        """
+        self._provider_classes[provider_name] = provider_class
+        self._provider_configs[provider_name] = config_class
+        logger.info(f"Registered provider class: {provider_name}")
     
-    def reload_providers(self) -> None:
-        """Reload all providers from configuration."""
-        logger.info("Reloading providers from configuration")
-        self._providers.clear()
-        self._load_configurations()
-
+    def __len__(self) -> int:
+        """Get number of initialized providers."""
+        return len(self._providers)
+    
+    def __contains__(self, provider_name: str) -> bool:
+        """Check if provider is initialized."""
+        return provider_name in self._providers
+    
+    def __iter__(self):
+        """Iterate over provider names."""
+        return iter(self._providers.keys())
 
-# Global singleton instance  
-_registry_instance = None
 
-def get_provider_registry() -> ProviderRegistry:
-    """Get global provider registry instance."""
-    global _registry_instance
-    if _registry_instance is None:
-        _registry_instance = ProviderRegistry()
-    return _registry_instance
+# Global registry instance
+_global_registry: Optional[ProviderRegistry] = None
 
 
-def get_payment_provider(provider_name: str) -> Optional[PaymentProvider]:
+def get_provider_registry() -> ProviderRegistry:
     """
-    Get payment provider instance by name.
+    Get global provider registry instance.
     
-    Args:
-        provider_name: Name of provider (e.g. 'nowpayments', 'stripe')
-        
     Returns:
-        Provider instance or None if not found
+        ProviderRegistry: Global registry instance
     """
-    registry = get_provider_registry()
-    return registry.get_provider(provider_name)
+    global _global_registry
+    if _global_registry is None:
+        _global_registry = ProviderRegistry()
+    return _global_registry
 
 
-def get_available_providers() -> List[str]:
+def initialize_providers() -> ServiceOperationResult:
     """
-    Get list of available provider names.
+    Initialize global provider registry.
     
     Returns:
-        List of provider names that are configured
+        ServiceOperationResult: Initialization result
     """
     registry = get_provider_registry()
-    return registry.list_providers()
+    return registry.initialize()