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

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

@@ -4,30 +4,42 @@ Provider registry for managing payment providers.
 Central registry with lazy loading and typed configuration.
 """
 
-import logging
-from typing import Optional, List
+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 .nowpayments import NowPaymentsProvider, NowPaymentsConfig
-from .cryptapi import CryptAPIProvider, CryptAPIConfig
-from .cryptomus import CryptomusProvider, CryptomusConfig
+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 django_cfg.modules.django_logger import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger("provider_registry")
 
 
 class ProviderRegistry:
     """Central registry for payment providers with typed configs."""
     
     def __init__(self):
-        """Initialize registry with lazy loading."""
+        """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()
     
     def _load_configurations(self) -> None:
         """Load provider configurations."""
         try:
-            from ...utils.config_utils import get_payments_config
             config = get_payments_config()
             
             self._provider_configs = {}
@@ -52,8 +64,8 @@ class ProviderRegistry:
                 config = CryptomusConfig(**config_dict)
                 return CryptomusProvider(config)
             elif name == 'stripe':
-                # TODO: Implement StripeProvider with StripeConfig
-                return None
+                config = StripeConfig(**config_dict)
+                return StripeProvider(config)
             else:
                 logger.warning(f"Unknown provider type: {name}")
                 return None
@@ -92,12 +104,283 @@ class ProviderRegistry:
         active = []
         for name in self.list_providers():
             provider = self.get_provider(name)
-            if provider and provider.is_enabled():
+            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()
+            
+            # Default priority: NowPayments -> CryptAPI -> Cryptomus -> Stripe
+            priority_order = ['nowpayments', 'cryptapi', 'cryptomus', 'stripe']
+            
+            self._fallback_order = [p for p in priority_order if p in available_providers]
+            
+            # 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}")
+            
+        except Exception as e:
+            logger.error(f"Error initializing health monitoring: {e}")
+            self._fallback_order = []
+    
+    async def health_check_all(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Check health of all providers with performance metrics.
+        
+        Returns:
+            Dict mapping provider names to health status
+        """
+        results = {}
+        
+        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()
+                }
+        
+        return results
+    
+    def get_healthy_providers(self, operation: str = None) -> List[str]:
+        """
+        Get list of healthy providers in fallback order.
+        
+        Args:
+            operation: Specific operation (e.g., 'payment_creation', 'webhook')
+            
+        Returns:
+            List of provider names sorted by health and priority
+        """
+        healthy_providers = []
+        
+        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 healthy_providers
+    
+    def get_provider_with_fallback(self, preferred_provider: str = None, operation: str = None) -> Optional[PaymentProvider]:
+        """
+        Get provider with automatic fallback to healthy alternatives.
+        
+        Args:
+            preferred_provider: Preferred provider name
+            operation: Operation type for provider selection
+            
+        Returns:
+            PaymentProvider instance or None if all providers are down
+        """
+        # 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")
+        
+        # Fallback to healthy providers in order
+        healthy_providers = self.get_healthy_providers(operation)
+        
+        for provider_name in healthy_providers:
+            provider = self.get_provider(provider_name)
+            if provider:
+                logger.info(f"Using fallback provider: {provider_name}")
+                return provider
+        
+        logger.error("No healthy providers available!")
+        return None
+    
+    def record_provider_performance(self, provider_name: str, operation: str, 
+                                  response_time_ms: int, success: bool) -> None:
+        """
+        Record provider performance metrics.
+        
+        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
+        """
+        try:
+            # Store performance metrics in cache
+            metric_key = f"provider_metrics:{provider_name}:{operation}"
+            
+            # Get current metrics
+            current_metrics = cache.get(metric_key, {
+                'total_requests': 0,
+                'successful_requests': 0,
+                'average_response_time': 0,
+                'last_updated': timezone.now().isoformat()
+            })
+            
+            # Update metrics
+            total_requests = current_metrics['total_requests'] + 1
+            successful_requests = current_metrics['successful_requests'] + (1 if success else 0)
+            
+            # 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
+            
+            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()
+            }
+            
+            # Store for 24 hours
+            cache.set(metric_key, updated_metrics, timeout=86400)
+            
+            # 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}")
+    
+    def get_provider_metrics(self, provider_name: str = None) -> Dict[str, Dict[str, Any]]:
+        """
+        Get performance metrics for providers.
+        
+        Args:
+            provider_name: Specific provider or None for all providers
+            
+        Returns:
+            Dict of provider metrics
+        """
+        if provider_name:
+            providers_to_check = [provider_name]
+        else:
+            providers_to_check = self.list_providers()
+        
+        metrics = {}
+        
+        for provider in providers_to_check:
+            provider_metrics = {}
+            
+            # Common operations to check
+            operations = ['create_payment', 'check_status', 'process_webhook', 'get_currencies']
+            
+            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
+            
+            if provider_metrics:
+                metrics[provider] = provider_metrics
+        
+        return metrics
+    
     def reload_providers(self) -> None:
         """Reload all providers from configuration."""
         logger.info("Reloading providers from configuration")
         self._providers.clear()
         self._load_configurations()
+
+
+# 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
+
+
+def get_payment_provider(provider_name: str) -> Optional[PaymentProvider]:
+    """
+    Get payment provider instance by name.
+    
+    Args:
+        provider_name: Name of provider (e.g. 'nowpayments', 'stripe')
+        
+    Returns:
+        Provider instance or None if not found
+    """
+    registry = get_provider_registry()
+    return registry.get_provider(provider_name)
+
+
+def get_available_providers() -> List[str]:
+    """
+    Get list of available provider names.
+    
+    Returns:
+        List of provider names that are configured
+    """
+    registry = get_provider_registry()
+    return registry.list_providers()

django_cfg/apps/payments/services/providers/stripe/__init__.py

@@ -0,0 +1,4 @@
+from .provider import StripeProvider
+from .models import StripeConfig, StripeCurrency, StripeNetwork
+
+__all__ = ['StripeProvider', 'StripeConfig', 'StripeCurrency', 'StripeNetwork']

django_cfg/apps/payments/services/providers/stripe/models.py

@@ -0,0 +1,184 @@
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from typing import Optional, List, Dict, Any
+from decimal import Decimal
+
+from ...internal_types import ProviderConfig
+
+
+class StripeConfig(ProviderConfig):
+    """Stripe provider configuration with Pydantic v2."""
+    
+    webhook_secret: Optional[str] = Field(None, description="Webhook endpoint secret")
+    success_url: Optional[str] = Field(None, description="Payment success redirect URL")
+    cancel_url: Optional[str] = Field(None, description="Payment cancel redirect URL")
+    
+    @field_validator('api_key')
+    @classmethod
+    def validate_api_key(cls, v: str) -> str:
+        if not v or not v.startswith(('sk_test_', 'sk_live_')):
+            raise ValueError("Stripe API key must start with sk_test_ or sk_live_")
+        return v
+
+
+class StripeCurrency(BaseModel):
+    """Stripe specific currency model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_code: str = Field(..., description="Currency symbol (e.g., USD, EUR)")
+    name: str = Field(..., description="Full currency name")
+    decimal_digits: int = Field(..., description="Number of decimal digits")
+    min_amount: Optional[Decimal] = Field(None, description="Minimum charge amount")
+    max_amount: Optional[Decimal] = Field(None, description="Maximum charge amount")
+    is_zero_decimal: bool = Field(False, description="Zero-decimal currency (like JPY)")
+
+
+class StripeNetwork(BaseModel):
+    """Stripe network model (not applicable for fiat payments)."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    code: str = Field(..., description="Network code (always 'stripe')")
+    name: str = Field(..., description="Network display name")
+    currency: str = Field(..., description="Currency this network belongs to")
+
+
+class StripePaymentIntentRequest(BaseModel):
+    """Stripe PaymentIntent creation request."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    amount: int = Field(..., description="Amount in smallest currency unit")
+    currency: str = Field(..., description="Three-letter ISO currency code")
+    payment_method_types: List[str] = Field(default=["card"], description="Payment method types")
+    confirm: bool = Field(False, description="Confirm PaymentIntent immediately")
+    capture_method: str = Field("automatic", description="Capture method")
+    confirmation_method: str = Field("automatic", description="Confirmation method")
+    description: Optional[str] = Field(None, description="Payment description")
+    metadata: Optional[Dict[str, str]] = Field(None, description="Metadata")
+    receipt_email: Optional[str] = Field(None, description="Receipt email")
+    return_url: Optional[str] = Field(None, description="Return URL")
+    success_url: Optional[str] = Field(None, description="Success URL")
+    cancel_url: Optional[str] = Field(None, description="Cancel URL")
+
+
+class StripePaymentIntentResponse(BaseModel):
+    """Stripe PaymentIntent response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str = Field(..., description="PaymentIntent ID")
+    object: str = Field(..., description="Object type")
+    amount: int = Field(..., description="Amount in smallest currency unit")
+    currency: str = Field(..., description="Currency code")
+    status: str = Field(..., description="PaymentIntent status")
+    client_secret: str = Field(..., description="Client secret for confirmation")
+    created: int = Field(..., description="Creation timestamp")
+    description: Optional[str] = Field(None, description="Payment description")
+    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
+    payment_method: Optional[str] = Field(None, description="Payment method ID")
+    receipt_email: Optional[str] = Field(None, description="Receipt email")
+    latest_charge: Optional[str] = Field(None, description="Latest charge ID")
+
+
+class StripeWebhookEvent(BaseModel):
+    """Stripe webhook event data."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str = Field(..., description="Event ID")
+    object: str = Field(..., description="Object type")
+    api_version: str = Field(..., description="API version")
+    created: int = Field(..., description="Creation timestamp")
+    type: str = Field(..., description="Event type")
+    data: Dict[str, Any] = Field(..., description="Event data")
+    livemode: bool = Field(..., description="Live mode flag")
+    pending_webhooks: int = Field(..., description="Pending webhooks count")
+    request: Optional[Dict[str, Any]] = Field(None, description="Request info")
+
+
+class StripeCharge(BaseModel):
+    """Stripe charge object."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str = Field(..., description="Charge ID")
+    object: str = Field(..., description="Object type")
+    amount: int = Field(..., description="Amount charged")
+    currency: str = Field(..., description="Currency code")
+    status: str = Field(..., description="Charge status")
+    created: int = Field(..., description="Creation timestamp")
+    description: Optional[str] = Field(None, description="Charge description")
+    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
+    payment_intent: Optional[str] = Field(None, description="PaymentIntent ID")
+    receipt_email: Optional[str] = Field(None, description="Receipt email")
+    receipt_url: Optional[str] = Field(None, description="Receipt URL")
+
+
+class StripeCustomer(BaseModel):
+    """Stripe customer object."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str = Field(..., description="Customer ID")
+    object: str = Field(..., description="Object type")
+    created: int = Field(..., description="Creation timestamp")
+    email: Optional[str] = Field(None, description="Customer email")
+    name: Optional[str] = Field(None, description="Customer name")
+    phone: Optional[str] = Field(None, description="Customer phone")
+    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
+
+
+class StripeError(BaseModel):
+    """Stripe error response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    type: str = Field(..., description="Error type")
+    code: Optional[str] = Field(None, description="Error code")
+    message: str = Field(..., description="Error message")
+    param: Optional[str] = Field(None, description="Parameter causing error")
+    decline_code: Optional[str] = Field(None, description="Decline code")
+
+
+class StripeErrorResponse(BaseModel):
+    """Stripe error response wrapper."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    error: StripeError = Field(..., description="Error details")
+
+
+class StripeCurrenciesResponse(BaseModel):
+    """Stripe supported currencies response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currencies: List[StripeCurrency] = Field(..., description="List of supported currencies")
+
+
+class StripeWebhookEndpoint(BaseModel):
+    """Stripe webhook endpoint configuration."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    id: str = Field(..., description="Webhook endpoint ID")
+    object: str = Field(..., description="Object type")
+    api_version: Optional[str] = Field(None, description="API version")
+    created: int = Field(..., description="Creation timestamp")
+    enabled_events: List[str] = Field(..., description="Enabled event types")
+    livemode: bool = Field(..., description="Live mode flag")
+    status: str = Field(..., description="Endpoint status")
+    url: str = Field(..., description="Endpoint URL")
+
+
+# =============================================================================
+# MONITORING & HEALTH CHECK MODELS
+# =============================================================================
+
+class StripeHealthErrorResponse(BaseModel):
+    """Stripe API error response schema for health checks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    class StripeHealthError(BaseModel):
+        message: str = Field(..., description="Error message")
+        type: str = Field(..., description="Error type")
+        
+    error: StripeHealthError = Field(..., description="Error details")
+    
+    @field_validator('error')
+    @classmethod
+    def validate_auth_error(cls, v):
+        """Validate this is an authentication error (meaning API is healthy)."""
+        if v.type != 'invalid_request_error':
+            raise ValueError(f"Expected auth error, got '{v.type}'")
+        return v

django_cfg/apps/payments/services/providers/stripe/provider.py

@@ -0,0 +1,109 @@
+from typing import Dict, Any, Optional, List
+from decimal import Decimal
+
+from ..base import PaymentProvider
+from ...internal_types import ProviderResponse, WebhookData
+from .models import StripeConfig, StripeCurrency, StripeNetwork
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("stripe")
+
+
+class StripeProvider(PaymentProvider):
+    """Stripe payment provider implementation."""
+    
+    name = "stripe"
+    
+    def __init__(self, config: StripeConfig):
+        super().__init__(config)
+        self.config = config
+        self.api_key = config.api_key
+        self.webhook_secret = config.webhook_secret
+        self.base_url = "https://api.stripe.com/v1"
+    
+    def create_payment(self, amount_usd: Decimal, currency_code: str, description: str = None, **kwargs) -> ProviderResponse:
+        """Create a payment intent with Stripe."""
+        # TODO: Implement Stripe payment creation
+        return ProviderResponse(
+            success=False,
+            error_message="Stripe provider not implemented yet"
+        )
+    
+    def check_payment_status(self, payment_id: str) -> ProviderResponse:
+        """Check payment status from Stripe."""
+        # TODO: Implement Stripe payment status check
+        return ProviderResponse(
+            success=False,
+            error_message="Stripe provider not implemented yet"
+        )
+    
+    def process_webhook(self, webhook_data: WebhookData) -> ProviderResponse:
+        """Process Stripe webhook."""
+        # TODO: Implement Stripe webhook processing
+        return ProviderResponse(
+            success=False,
+            error_message="Stripe provider not implemented yet"
+        )
+    
+    def validate_webhook_signature(self, payload: str, signature: str) -> bool:
+        """Validate Stripe webhook signature."""
+        # TODO: Implement Stripe signature validation
+        return False
+    
+    def get_supported_currencies(self) -> ProviderResponse:
+        """Get supported currencies from Stripe."""
+        # Common fiat currencies supported by Stripe
+        currencies = [
+            StripeCurrency(
+                currency_code='USD',
+                name='US Dollar',
+                decimal_digits=2,
+                min_amount=Decimal('0.50'),
+                is_zero_decimal=False
+            ),
+            StripeCurrency(
+                currency_code='EUR',
+                name='Euro',
+                decimal_digits=2,
+                min_amount=Decimal('0.50'),
+                is_zero_decimal=False
+            ),
+            StripeCurrency(
+                currency_code='GBP',
+                name='British Pound',
+                decimal_digits=2,
+                min_amount=Decimal('0.30'),
+                is_zero_decimal=False
+            ),
+            StripeCurrency(
+                currency_code='JPY',
+                name='Japanese Yen',
+                decimal_digits=0,
+                min_amount=Decimal('50'),
+                is_zero_decimal=True
+            ),
+        ]
+        
+        return ProviderResponse(
+            success=True,
+            data={'currencies': [c.model_dump() for c in currencies]}
+        )
+    
+    def get_supported_networks(self, currency_code: str = None) -> ProviderResponse:
+        """Get supported networks (not applicable for Stripe fiat payments)."""
+        return ProviderResponse(
+            success=True,
+            data={'networks': {}}
+        )
+    
+    def get_currency_network_mapping(self) -> Dict[str, List[str]]:
+        """Get currency network mapping (not applicable for Stripe)."""
+        return {}
+    
+    def check_api_status(self) -> Dict[str, Any]:
+        """Check Stripe API status."""
+        # TODO: Implement actual API health check
+        return {
+            'status': 'unknown',
+            'message': 'Stripe provider not implemented yet'
+        }

django_cfg/apps/payments/services/security/error_handler.py

@@ -4,21 +4,22 @@ Critical Foundation Security Component.
 """
 
 import json
-import logging
+from django_cfg.modules.django_logger import get_logger
 import traceback
 from typing import Dict, Any, Optional, Union, Type
 from enum import Enum
-from datetime import datetime
+from datetime import datetime, timedelta
 from pydantic import BaseModel, Field
 from django.http import JsonResponse, HttpResponse
 from django.utils import timezone
 from django.conf import settings
-from .payment_notifications import payment_notifications
 from django.core.cache import cache
+from django.db.models import Count
 
-from ..models.events import PaymentEvent
+from .payment_notifications import payment_notifications
+from ...models.events import PaymentEvent
 
-logger = logging.getLogger(__name__)
+logger = get_logger("error_handler")
 
 
 class ErrorSeverity(Enum):
@@ -593,9 +594,6 @@ class CentralizedErrorHandler:
     def get_error_statistics(self, hours: int = 24) -> Dict[str, Any]:
         """Get error statistics for monitoring dashboard."""
         
-        from datetime import timedelta
-        from django.db.models import Count
-        
         since = timezone.now() - timedelta(hours=hours)
         
         # Get error events from database