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

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

@@ -1,238 +1,298 @@
 """
-Base payment provider interface.
+Base provider class for the Universal Payment System v2.0.
 
-Abstract base class for all payment providers.
+Abstract base class for all payment providers with unified interface.
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional, List, Dict
-from django.db.models import QuerySet
+from typing import Dict, Any, Optional, List
 from decimal import Decimal
+from pydantic import BaseModel, Field
+from django_cfg.modules.django_logger import get_logger
+from ..types import ProviderResponse, ServiceOperationResult
 
-from django.db import models, transaction
-from cachetools import TTLCache
 
-from ..internal_types import ProviderResponse, WebhookData, PaymentAmountEstimate, ProviderInfo, UniversalCurrency, UniversalCurrenciesResponse, ProviderSyncResult
-from ...models import Currency, Network, ProviderCurrency
-from django_cfg.modules.django_logger import get_logger
+class ProviderConfig(BaseModel):
+    """
+    Base provider configuration.
+    
+    Common configuration fields for all payment providers.
+    """
+    
+    provider_name: str = Field(description="Provider name")
+    api_key: str = Field(description="Provider API key")
+    api_url: str = Field(description="Provider API URL")
+    sandbox: bool = Field(default=False, description="Sandbox mode")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    retry_attempts: int = Field(default=3, description="Number of retry attempts")
+    retry_delay: int = Field(default=5, description="Delay between retries in seconds")
+    min_amount_usd: float = Field(default=1.0, description="Minimum amount in USD")
+    max_amount_usd: float = Field(default=50000.0, description="Maximum amount in USD")
+    supported_currencies: List[str] = Field(default_factory=list, description="Supported currencies")
+    webhook_secret: Optional[str] = Field(None, description="Webhook secret for validation")
 
 
-logger = get_logger('base_provider')
+class PaymentRequest(BaseModel):
+    """
+    Universal payment request for providers.
+    
+    Standardized payment creation request across all providers.
+    """
+    
+    amount_usd: float = Field(gt=0, description="Amount in USD")
+    currency_code: str = Field(description="Cryptocurrency code")
+    order_id: str = Field(description="Internal order/payment ID")
+    callback_url: Optional[str] = Field(None, description="Success callback URL")
+    cancel_url: Optional[str] = Field(None, description="Cancel URL")
+    description: Optional[str] = Field(None, description="Payment description")
+    customer_email: Optional[str] = Field(None, description="Customer email")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
 
-class PaymentProvider(ABC):
-    """Abstract base class for payment providers."""
+class BaseProvider(ABC):
+    """
+    Abstract base class for payment providers.
     
-    # Class-level cache for all providers (5 min TTL)
-    _api_cache = TTLCache(maxsize=100, ttl=300)
+    Defines the unified interface that all providers must implement.
+    """
     
-    def __init__(self, config):
-        """Initialize provider with config."""
-        self.config = config
-        self.name = self.__class__.__name__.lower().replace('provider', '')
-        self.logger = get_logger(f"payment.{self.name}")
+    def __init__(self, config: ProviderConfig):
+        """
+        Initialize provider with configuration.
         
-        # Handle both dict and Pydantic model configs
-        if hasattr(config, 'enabled'):
-            self.enabled = config.enabled
-        elif hasattr(config, 'get'):
-            self.enabled = config.get('enabled', True)
-        else:
-            self.enabled = getattr(config, 'enabled', True)
+        Args:
+            config: Provider configuration
+        """
+        self.config = config
+        self.logger = get_logger(f"providers.{config.provider_name}")
+        self._session = None
+    
+    @property
+    def name(self) -> str:
+        """Get provider name."""
+        return self.config.provider_name
+    
+    @property
+    def is_sandbox(self) -> bool:
+        """Check if provider is in sandbox mode."""
+        return self.config.sandbox
     
     @abstractmethod
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
+    def create_payment(self, request: PaymentRequest) -> ProviderResponse:
         """
-        Create a payment request.
+        Create payment with provider.
         
         Args:
-            amount: Payment amount
-            currency: Payment currency
-            **kwargs: Additional parameters (order_id, description, etc.)
+            request: Payment creation request
             
         Returns:
-            Dict with payment creation result
+            ProviderResponse: Provider response with payment details
         """
         pass
     
     @abstractmethod
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
+    def get_payment_status(self, provider_payment_id: str) -> ProviderResponse:
         """
-        Check payment status.
+        Get payment status from provider.
         
         Args:
-            payment_id: Payment ID from provider
+            provider_payment_id: Provider's payment ID
             
         Returns:
-            Dict with payment status
+            ProviderResponse: Current payment status
         """
         pass
     
     @abstractmethod
-    def process_webhook(self, payload: dict) -> WebhookData:
+    def get_supported_currencies(self) -> ServiceOperationResult:
         """
-        Process webhook payload.
+        Get list of supported currencies from provider.
         
-        Args:
-            payload: Webhook data from provider
-            
         Returns:
-            Dict with processed webhook data
+            ServiceOperationResult: List of supported currencies
         """
         pass
     
-    @abstractmethod 
-    def get_parsed_currencies(self) -> UniversalCurrenciesResponse:
+    @abstractmethod
+    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
         """
-        Get parsed and normalized currencies ready for database sync.
-        
-        This method should:
-        1. Fetch data from provider API
-        2. Parse provider codes into base_currency + network
-        3. Return universal format
+        Validate webhook from provider.
         
+        Args:
+            payload: Webhook payload
+            signature: Webhook signature (if any)
+            
         Returns:
-            UniversalCurrenciesResponse with parsed data
+            ServiceOperationResult: Validation result
         """
         pass
     
-    
-    
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
+    def get_exchange_rate(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
         """
-        Validate webhook signature and data.
+        Get exchange rate from provider (optional).
         
         Args:
-            payload: Webhook data
-            signature: Webhook signature (if applicable)
+            from_currency: Source currency
+            to_currency: Target currency
             
         Returns:
-            True if webhook is valid
+            ServiceOperationResult: Exchange rate or not supported
         """
-        # Default implementation - providers can override
-        return True
-    
+        return ServiceOperationResult(
+            success=False,
+            message=f"Exchange rates not supported by {self.name}",
+            error_code="not_supported"
+        )
     
-    def check_api_status(self) -> bool:
+    def health_check(self) -> ServiceOperationResult:
         """
-        Check if provider API is available.
+        Perform provider health check.
         
         Returns:
-            True if API is available
+            ServiceOperationResult: Health check result
         """
-        # Optional method - providers can override
-        return True
-    
-    def is_enabled(self) -> bool:
-        """Check if provider is enabled."""
-        return self.enabled
+        try:
+            # Basic connectivity test - can be overridden by providers
+            result = self.get_supported_currencies()
+            
+            if result.success:
+                return ServiceOperationResult(
+                    success=True,
+                    message=f"{self.name} provider is healthy",
+                    data={
+                        'provider': self.name,
+                        'sandbox': self.is_sandbox,
+                        'api_url': self.config.api_url,
+                        'supported_currencies_count': len(result.data.get('currencies', []))
+                    }
+                )
+            else:
+                return ServiceOperationResult(
+                    success=False,
+                    message=f"{self.name} provider health check failed",
+                    error_code="health_check_failed",
+                    data={'provider': self.name, 'error': result.message}
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Health check failed for {self.name}: {e}")
+            return ServiceOperationResult(
+                success=False,
+                message=f"{self.name} provider health check error: {e}",
+                error_code="health_check_error",
+                data={'provider': self.name}
+            )
     
-    def sync_currencies_to_db(self) -> ProviderSyncResult:
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
         """
-        Synchronize provider currencies with clean architecture.
-        Uses get_parsed_currencies() to get normalized data.
+        Make HTTP request to provider API.
+        
+        Args:
+            method: HTTP method
+            endpoint: API endpoint
+            data: Request data
+            headers: Request headers
+            
+        Returns:
+            Dict[str, Any]: Response data
+            
+        Raises:
+            Exception: If request fails
         """
-        result = ProviderSyncResult()
+        import requests
+        from requests.adapters import HTTPAdapter
+        from urllib3.util.retry import Retry
         
-        # Get parsed data from provider
-        try:
-            parsed_response = self.get_parsed_currencies()
-        except Exception as e:
-            result.errors.append(f"Failed to get parsed currencies: {str(e)}")
-            return result
-        
-        logger.info(f"Processing {len(parsed_response.currencies)} currencies from {self.name}")
-        
-        with transaction.atomic():
-            for universal_currency in parsed_response.currencies:
-                try:
-                    # 1. Create/update base Currency using normalized manager
-                    currency, created = Currency.objects.get_or_create_normalized(
-                        code=universal_currency.base_currency_code,
-                        defaults={
-                            'name': universal_currency.name,
-                            'currency_type': universal_currency.currency_type
-                        }
-                    )
-                    
-                    if created:
-                        result.currencies_created += 1
-                        logger.debug(f"Created currency: {universal_currency.base_currency_code}")
-                    else:
-                        result.currencies_updated += 1
-                    
-                    # 2. Create/update Network (if needed) using normalized manager
-                    network = None
-                    if universal_currency.network_code:
-                        network, created = Network.objects.get_or_create_normalized(
-                            code=universal_currency.network_code,
-                            defaults={
-                                'name': universal_currency.network_code.title()
-                            }
-                        )
-                        
-                        if created:
-                            result.networks_created += 1
-                            logger.debug(f"Created network: {universal_currency.network_code}")
-                        else:
-                            result.networks_updated += 1
-                    
-                    # 3. Create/update ProviderCurrency mapping
-                    provider_currency, created = ProviderCurrency.objects.get_or_create(
-                        provider_name=self.name,
-                        provider_currency_code=universal_currency.provider_currency_code,
-                        defaults={
-                            'base_currency': currency,
-                            'network': network,
-                            'is_enabled': universal_currency.is_enabled,
-                            'is_popular': universal_currency.is_popular,
-                            'is_stable': universal_currency.is_stable,
-                            'priority': universal_currency.priority,
-                            'logo_url': universal_currency.logo_url,
-                            'available_for_payment': universal_currency.available_for_payment,
-                            'available_for_payout': universal_currency.available_for_payout,
-                            'min_amount': universal_currency.min_amount,
-                            'max_amount': universal_currency.max_amount,
-                            'metadata': universal_currency.raw_data
-                        }
-                    )
-                    
-                    if created:
-                        result.provider_currencies_created += 1
-                        logger.debug(f"Created provider currency: {universal_currency.provider_currency_code}")
-                    else:
-                        # Update existing record
-                        provider_currency.is_enabled = universal_currency.is_enabled
-                        provider_currency.is_popular = universal_currency.is_popular
-                        provider_currency.is_stable = universal_currency.is_stable
-                        provider_currency.priority = universal_currency.priority
-                        provider_currency.logo_url = universal_currency.logo_url
-                        provider_currency.save()
-                        result.provider_currencies_updated += 1
-                
-                except Exception as e:
-                    error_msg = f"Error processing {universal_currency.provider_currency_code}: {str(e)}"
-                    result.errors.append(error_msg)
-                    logger.error(error_msg)
+        # Create session if not exists
+        if self._session is None:
+            self._session = requests.Session()
+            
+            # Configure retries
+            retry_strategy = Retry(
+                total=self.config.retry_attempts,
+                backoff_factor=self.config.retry_delay,
+                status_forcelist=[429, 500, 502, 503, 504],
+            )
+            adapter = HTTPAdapter(max_retries=retry_strategy)
+            self._session.mount("http://", adapter)
+            self._session.mount("https://", adapter)
+        
+        # Build URL
+        url = f"{self.config.api_url.rstrip('/')}/{endpoint.lstrip('/')}"
+        
+        # Prepare headers
+        request_headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': f'django-cfg-payments/2.0 ({self.name})',
+        }
+        if headers:
+            request_headers.update(headers)
+        
+        # Log request
+        self.logger.debug(f"Making {method} request to {url}", extra={
+            'method': method,
+            'url': url,
+            'has_data': bool(data)
+        })
+        
+        # Make request
+        response = self._session.request(
+            method=method,
+            url=url,
+            json=data if data else None,
+            headers=request_headers,
+            timeout=self.config.timeout
+        )
+        
+        # Log response
+        self.logger.debug(f"Received response: {response.status_code}", extra={
+            'status_code': response.status_code,
+            'response_size': len(response.content)
+        })
+        
+        # Handle response
+        response.raise_for_status()
         
-        logger.info(f"Sync completed: {result}")
-        return result
-    
-    def get_provider_info(self) -> ProviderInfo:
-        """Get provider information using parsed currencies."""
         try:
-            parsed_response = self.get_parsed_currencies()
-            supported_currencies = [c.base_currency_code for c in parsed_response.currencies]
-        except Exception:
-            supported_currencies = []
-        
-        return ProviderInfo(
-            name=self.name,
-            display_name=self.name.title(),
-            supported_currencies=supported_currencies,
-            is_active=self.enabled and self.check_api_status(),
-            features={
-                'supports_networks': True,
-                'supports_webhooks': True,
-                'supports_refunds': True
-            }
+            return response.json()
+        except ValueError:
+            # Non-JSON response
+            return {'raw_response': response.text, 'status_code': response.status_code}
+    
+    def _create_provider_response(
+        self,
+        success: bool,
+        raw_response: Dict[str, Any],
+        **kwargs
+    ) -> ProviderResponse:
+        """
+        Create standardized provider response.
+        
+        Args:
+            success: Operation success
+            raw_response: Raw provider response
+            **kwargs: Additional response fields
+            
+        Returns:
+            ProviderResponse: Standardized response
+        """
+        return ProviderResponse(
+            provider=self.name,
+            success=success,
+            raw_response=raw_response,
+            **kwargs
         )
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.name}Provider(sandbox={self.is_sandbox})"
+    
+    def __repr__(self) -> str:
+        """Detailed representation."""
+        return f"{self.__class__.__name__}(name='{self.name}', sandbox={self.is_sandbox}, api_url='{self.config.api_url}')"