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

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

@@ -1,137 +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
+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 ..internal_types import ProviderResponse, WebhookData
+
+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")
+
+
+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.
+    
+    Defines the unified interface that all providers must implement.
+    """
     
-    def __init__(self, config: dict):
-        """Initialize provider with config."""
+    def __init__(self, config: ProviderConfig):
+        """
+        Initialize provider with configuration.
+        
+        Args:
+            config: Provider configuration
+        """
         self.config = config
-        self.name = self.__class__.__name__.lower().replace('provider', '')
-        self.enabled = config.get('enabled', True)
+        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_supported_currencies(self) -> List[str]:
+    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
         """
-        Get list of supported currencies.
+        Validate webhook from provider.
         
+        Args:
+            payload: Webhook payload
+            signature: Webhook signature (if any)
+            
         Returns:
-            List of supported currency codes
+            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 get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
+    def health_check(self) -> ServiceOperationResult:
         """
-        Get minimum payment amount for currency pair.
+        Perform provider health check.
         
-        Args:
-            currency_from: Source currency
-            currency_to: Target currency
-            
         Returns:
-            Minimum payment amount or None if not supported
+            ServiceOperationResult: Health check result
         """
-        # Optional method - providers can override
-        return None
+        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 estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
         """
-        Estimate payment amount in target currency.
+        Make HTTP request to provider API.
         
         Args:
-            amount: Amount to estimate
-            currency_code: Target currency
+            method: HTTP method
+            endpoint: API endpoint
+            data: Request data
+            headers: Request headers
             
         Returns:
-            Dict with estimation data or None if not supported
+            Dict[str, Any]: Response data
+            
+        Raises:
+            Exception: If request fails
         """
-        # Optional method - providers can override
-        return None
+        import requests
+        from requests.adapters import HTTPAdapter
+        from urllib3.util.retry import Retry
+        
+        # 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()
+        
+        try:
+            return response.json()
+        except ValueError:
+            # Non-JSON response
+            return {'raw_response': response.text, 'status_code': response.status_code}
     
-    def check_api_status(self) -> bool:
+    def _create_provider_response(
+        self,
+        success: bool,
+        raw_response: Dict[str, Any],
+        **kwargs
+    ) -> ProviderResponse:
         """
-        Check if provider API is available.
+        Create standardized provider response.
         
+        Args:
+            success: Operation success
+            raw_response: Raw provider response
+            **kwargs: Additional response fields
+            
         Returns:
-            True if API is available
-        """
-        # Optional method - providers can override
-        return True
-    
-    def is_enabled(self) -> bool:
-        """Check if provider is enabled."""
-        return self.enabled
-    
-    def get_provider_info(self) -> dict:
-        """Get provider information."""
-        return {
-            'name': self.name,
-            'enabled': self.enabled,
-            'supported_currencies': self.get_supported_currencies(),
-            'api_status': self.check_api_status(),
-        }
+            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}')"