django-cfg 1.3.7__py3-none-any.whl → 1.3.11__py3-none-any.whl

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

@@ -5,48 +5,13 @@ Abstract base class for all payment providers with unified interface.
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional
 from decimal import Decimal
-from pydantic import BaseModel, Field
+import requests
+from django.utils import timezone
 from django_cfg.modules.django_logger import get_logger
 from ..types import ProviderResponse, ServiceOperationResult
-
-
-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")
+from .models import ProviderConfig, PaymentRequest, WithdrawalRequest
 
 
 class BaseProvider(ABC):
@@ -75,7 +40,90 @@ class BaseProvider(ABC):
     @property
     def is_sandbox(self) -> bool:
         """Check if provider is in sandbox mode."""
-        return self.config.sandbox
+        return self.config.sandbox_mode
+    
+    # Provider configuration methods (to be overridden by specific providers)
+    def get_fee_percentage(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """
+        Get fee percentage for currency.
+        
+        Args:
+            currency_code: Currency code (e.g., 'BTC', 'ETH')
+            currency_type: Currency type ('fiat', 'crypto')
+            
+        Returns:
+            Fee percentage as decimal (0.005 = 0.5%)
+        """
+        return Decimal('0.005')  # Default 0.5%
+    
+    def get_fixed_fee_usd(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """
+        Get fixed fee in USD for currency.
+        
+        Args:
+            currency_code: Currency code (e.g., 'BTC', 'ETH')
+            currency_type: Currency type ('fiat', 'crypto')
+            
+        Returns:
+            Fixed fee in USD
+        """
+        return Decimal('0.0')  # Default no fixed fee
+    
+    def get_min_amount_usd(self, currency_code: str = None, currency_type: str = None, is_stable: bool = False) -> Decimal:
+        """
+        Get minimum amount in USD for currency.
+        
+        Args:
+            currency_code: Currency code (e.g., 'BTC', 'ETH')
+            currency_type: Currency type ('fiat', 'crypto')
+            is_stable: Whether currency is a stablecoin
+            
+        Returns:
+            Minimum amount in USD
+        """
+        if currency_type == 'fiat':
+            return Decimal('1.0')
+        elif is_stable:
+            return Decimal('0.01')
+        else:
+            return Decimal('0.000001')
+    
+    def get_max_amount_usd(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """
+        Get maximum amount in USD for currency.
+        
+        Args:
+            currency_code: Currency code (e.g., 'BTC', 'ETH')
+            currency_type: Currency type ('fiat', 'crypto')
+            
+        Returns:
+            Maximum amount in USD
+        """
+        return Decimal('1000000.0')  # Default 1M USD
+    
+    def get_confirmation_blocks(self, network_code: str) -> int:
+        """
+        Get confirmation blocks for network.
+        
+        Args:
+            network_code: Network code (e.g., 'btc', 'eth')
+            
+        Returns:
+            Number of confirmation blocks
+        """
+        return 1  # Default 1 confirmation
+    
+    def get_network_name(self, network_code: str) -> str:
+        """
+        Get human-readable network name.
+        
+        Args:
+            network_code: Network code (e.g., 'btc', 'eth')
+            
+        Returns:
+            Human-readable network name
+        """
+        return network_code.upper() if network_code else 'Unknown'
     
     @abstractmethod
     def create_payment(self, request: PaymentRequest) -> ProviderResponse:
@@ -103,6 +151,61 @@ class BaseProvider(ABC):
         """
         pass
     
+    def refresh_payment_status(self, provider_payment_id: str, force_update: bool = True) -> ProviderResponse:
+        """
+        Refresh payment status with enhanced error handling and caching control.
+        
+        This method provides additional functionality over get_payment_status:
+        - Enhanced error handling
+        - Optional caching control
+        - Detailed logging
+        
+        Args:
+            provider_payment_id: Provider's payment ID
+            force_update: Whether to bypass cache and force fresh data
+            
+        Returns:
+            ProviderResponse: Current payment status with enhanced metadata
+        """
+        self.logger.info(f"Refreshing payment status for {provider_payment_id}", extra={
+            'provider': self.name,
+            'payment_id': provider_payment_id,
+            'force_update': force_update
+        })
+        
+        try:
+            # Call the provider-specific implementation
+            result = self.get_payment_status(provider_payment_id)
+            
+            # Add refresh metadata
+            if result.success and hasattr(result, 'raw_response') and result.raw_response:
+                result.raw_response['_refresh_metadata'] = {
+                    'refreshed_at': timezone.now().isoformat(),
+                    'provider': self.name,
+                    'force_update': force_update
+                }
+            
+            self.logger.info(f"Payment status refreshed successfully", extra={
+                'provider': self.name,
+                'payment_id': provider_payment_id,
+                'status': getattr(result, 'status', 'unknown')
+            })
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Failed to refresh payment status", extra={
+                'provider': self.name,
+                'payment_id': provider_payment_id,
+                'error': str(e)
+            })
+            
+            return ProviderResponse(
+                success=False,
+                error_message=f"Failed to refresh payment status: {str(e)}",
+                raw_response={'error': str(e), 'provider': self.name}
+            )
+    
     @abstractmethod
     def get_supported_currencies(self) -> ServiceOperationResult:
         """
@@ -113,6 +216,16 @@ class BaseProvider(ABC):
         """
         pass
     
+    @abstractmethod
+    def sync_currencies_to_db(self):
+        """
+        Sync currencies from provider API to database.
+        
+        Returns:
+            CurrencySyncResult: Synchronization result
+        """
+        pass
+    
     @abstractmethod
     def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
         """
@@ -127,6 +240,129 @@ class BaseProvider(ABC):
         """
         pass
     
+    # Withdrawal/Payout Methods
+    
+    def supports_withdrawals(self) -> bool:
+        """
+        Check if provider supports withdrawals/payouts.
+        
+        Returns:
+            bool: True if provider supports withdrawals
+        """
+        return False  # Default: most payment processors don't support withdrawals
+    
+    def create_withdrawal(self, request: WithdrawalRequest) -> ProviderResponse:
+        """
+        Create withdrawal/payout request with provider.
+        
+        Args:
+            request: Withdrawal creation request
+            
+        Returns:
+            ProviderResponse: Provider response with withdrawal details
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawals
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        raise NotImplementedError("Subclasses must implement create_withdrawal if they support withdrawals")
+    
+    def get_withdrawal_status(self, provider_withdrawal_id: str) -> ProviderResponse:
+        """
+        Get withdrawal status from provider.
+        
+        Args:
+            provider_withdrawal_id: Provider's withdrawal ID
+            
+        Returns:
+            ProviderResponse: Current withdrawal status
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawals
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        raise NotImplementedError("Subclasses must implement get_withdrawal_status if they support withdrawals")
+    
+    def cancel_withdrawal(self, provider_withdrawal_id: str) -> ProviderResponse:
+        """
+        Cancel pending withdrawal.
+        
+        Args:
+            provider_withdrawal_id: Provider's withdrawal ID
+            
+        Returns:
+            ProviderResponse: Cancellation result
+            
+        Raises:
+            NotImplementedError: If provider doesn't support withdrawal cancellation
+        """
+        if not self.supports_withdrawals():
+            return ProviderResponse(
+                success=False,
+                error_message=f"Provider {self.name} does not support withdrawals",
+                raw_response={'error': 'withdrawals_not_supported'}
+            )
+        
+        return ProviderResponse(
+            success=False,
+            error_message=f"Provider {self.name} does not support withdrawal cancellation",
+            raw_response={'error': 'withdrawal_cancellation_not_supported'}
+        )
+    
+    def get_withdrawal_fees(self, currency_code: str) -> ServiceOperationResult:
+        """
+        Get withdrawal fees for specific currency.
+        
+        Args:
+            currency_code: Currency code
+            
+        Returns:
+            ServiceOperationResult: Fee information or not supported
+        """
+        if not self.supports_withdrawals():
+            return ServiceOperationResult(
+                success=False,
+                message=f"Provider {self.name} does not support withdrawals"
+            )
+        
+        return ServiceOperationResult(
+            success=False,
+            message="Withdrawal fee information not available"
+        )
+    
+    def get_minimum_withdrawal_amount(self, currency_code: str) -> ServiceOperationResult:
+        """
+        Get minimum withdrawal amount for specific currency.
+        
+        Args:
+            currency_code: Currency code
+            
+        Returns:
+            ServiceOperationResult: Minimum amount or not supported
+        """
+        if not self.supports_withdrawals():
+            return ServiceOperationResult(
+                success=False,
+                message=f"Provider {self.name} does not support withdrawals"
+            )
+        
+        return ServiceOperationResult(
+            success=False,
+            message="Minimum withdrawal amount information not available"
+        )
+    
     def get_exchange_rate(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
         """
         Get exchange rate from provider (optional).
@@ -257,7 +493,33 @@ class BaseProvider(ABC):
         })
         
         # Handle response
-        response.raise_for_status()
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            # Log the error with response content for debugging
+            error_content = response.text if response.text else "No response content"
+            self.logger.error(f"HTTP {response.status_code} error from {self.name}", extra={
+                'status_code': response.status_code,
+                'error_content': error_content[:500],  # Limit content length
+                'url': response.url
+            })
+            
+            # Handle specific HTTP errors
+            if response.status_code == 403:
+                if "blocked" in error_content.lower() or "nowpayments.io" in error_content:
+                    raise Exception(f"IP address blocked by {self.name}. Please contact {self.name} support or use a different IP/VPN.")
+                else:
+                    raise Exception(f"Access forbidden by {self.name}. Check API key and permissions.")
+            elif response.status_code == 401:
+                raise Exception(f"Authentication failed with {self.name}. Check API key.")
+            elif response.status_code == 400:
+                raise Exception(f"Bad request to {self.name}: {error_content[:200]}")
+            elif response.status_code == 429:
+                raise Exception(f"Rate limit exceeded for {self.name}. Please try again later.")
+            elif response.status_code >= 500:
+                raise Exception(f"{self.name} server error ({response.status_code}). Please try again later.")
+            else:
+                raise Exception(f"HTTP {response.status_code} error from {self.name}: {error_content[:200]}")
         
         try:
             return response.json()

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

@@ -0,0 +1,42 @@
+"""
+Universal provider models for Universal Payment System v2.0.
+
+Common models used across all payment providers.
+"""
+
+from .base import (
+    ProviderConfig,
+    PaymentRequest,
+    WithdrawalRequest,
+    ProviderMetadata,
+    ProviderType,
+    ProviderStatus
+)
+from .universal import (
+    UniversalCurrency,
+    UniversalCurrenciesResponse,
+    CurrencySyncResult
+)
+from .providers import (
+    ProviderEnum,
+    PROVIDER_METADATA
+)
+
+__all__ = [
+    # Base models
+    'ProviderConfig',
+    'PaymentRequest',
+    'WithdrawalRequest',
+    'ProviderMetadata',
+    'ProviderType',
+    'ProviderStatus',
+    
+    # Universal models
+    'UniversalCurrency',
+    'UniversalCurrenciesResponse',
+    'CurrencySyncResult',
+    
+    # Provider definitions
+    'ProviderEnum',
+    'PROVIDER_METADATA'
+]

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

@@ -0,0 +1,145 @@
+"""
+Base provider models for Universal Payment System v2.0.
+
+Core Pydantic models for provider configuration and requests.
+"""
+
+from typing import Dict, Any, Optional, List
+from decimal import Decimal
+from pydantic import BaseModel, Field, ConfigDict
+from enum import Enum
+
+
+class ProviderType(str, Enum):
+    """Provider type classification."""
+    
+    CRYPTO = "crypto"
+    FIAT = "fiat"
+    HYBRID = "hybrid"  # Supports both fiat and crypto
+
+
+class ProviderStatus(str, Enum):
+    """Provider operational status."""
+    
+    ACTIVE = "active"
+    MAINTENANCE = "maintenance"
+    DEPRECATED = "deprecated"
+    DISABLED = "disabled"
+
+
+class ProviderConfig(BaseModel):
+    """
+    Base provider configuration with Pydantic v2.
+    
+    Common configuration fields for all payment providers.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        str_strip_whitespace=True,
+        frozen=False
+    )
+    
+    provider_name: str = Field(..., description="Provider name")
+    api_key: str = Field(..., description="Provider API key")
+    api_url: str = Field(..., description="Provider API URL")
+    enabled: bool = Field(default=True, description="Whether provider is enabled")
+    sandbox_mode: bool = Field(default=False, description="Sandbox mode")
+    timeout: int = Field(default=30, ge=5, le=300, description="Request timeout in seconds")
+    retry_attempts: int = Field(default=3, ge=0, le=10, description="Number of retry attempts")
+    retry_delay: int = Field(default=5, ge=1, le=60, description="Delay between retries in seconds")
+    min_amount_usd: float = Field(default=1.0, ge=0.01, description="Minimum amount in USD")
+    max_amount_usd: float = Field(default=50000.0, ge=1.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 with Pydantic v2.
+    
+    Standardized payment creation request across all providers.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        str_strip_whitespace=True
+    )
+    
+    amount_usd: float = Field(..., gt=0, description="Amount in USD")
+    currency_code: str = Field(..., min_length=3, max_length=10, description="Currency code")
+    order_id: str = Field(..., min_length=1, max_length=100, 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, max_length=500, description="Payment description")
+    customer_email: Optional[str] = Field(None, description="Customer email")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class WithdrawalRequest(BaseModel):
+    """
+    Universal withdrawal request for providers with Pydantic v2.
+    
+    Standardized withdrawal/payout request across all providers.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        str_strip_whitespace=True
+    )
+    
+    amount: float = Field(..., gt=0, description="Withdrawal amount in crypto currency")
+    currency_code: str = Field(..., min_length=3, max_length=10, description="Cryptocurrency code")
+    destination_address: str = Field(..., min_length=10, description="Destination wallet address")
+    withdrawal_id: str = Field(..., min_length=1, max_length=100, description="Internal withdrawal ID")
+    callback_url: Optional[str] = Field(None, description="Withdrawal status callback URL")
+    description: Optional[str] = Field(None, max_length=500, description="Withdrawal description")
+    extra_id: Optional[str] = Field(None, description="Extra ID for destination (memo, tag, etc.)")
+    priority: Optional[str] = Field(default="normal", description="Transaction priority (low, normal, high)")
+    
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class ProviderMetadata(BaseModel):
+    """
+    Provider metadata with classification and features.
+    
+    Contains provider-specific information for routing and display.
+    """
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        frozen=True  # Metadata should be immutable
+    )
+    
+    name: str = Field(..., description="Human-readable provider name")
+    provider_type: ProviderType = Field(..., description="Provider type (crypto/fiat/hybrid)")
+    status: ProviderStatus = Field(default=ProviderStatus.ACTIVE, description="Provider status")
+    priority: int = Field(default=100, ge=0, le=1000, description="Provider priority (lower = higher priority)")
+    
+    # Feature flags
+    supports_fiat: bool = Field(default=False, description="Supports fiat currencies")
+    supports_crypto: bool = Field(default=True, description="Supports cryptocurrencies")
+    supports_webhooks: bool = Field(default=True, description="Supports webhook notifications")
+    supports_refunds: bool = Field(default=False, description="Supports payment refunds")
+    supports_partial_payments: bool = Field(default=False, description="Supports partial payments")
+    
+    # Limits and fees
+    min_amount_usd: float = Field(default=1.0, ge=0.01, description="Minimum payment amount in USD")
+    max_amount_usd: float = Field(default=50000.0, ge=1.0, description="Maximum payment amount in USD")
+    fee_percentage: float = Field(default=0.0, ge=0.0, le=100.0, description="Fee percentage")
+    fixed_fee_usd: float = Field(default=0.0, ge=0.0, description="Fixed fee in USD")
+    
+    # Geographic and regulatory
+    supported_countries: List[str] = Field(default_factory=list, description="Supported country codes")
+    restricted_countries: List[str] = Field(default_factory=list, description="Restricted country codes")
+    requires_kyc: bool = Field(default=False, description="Requires KYC verification")
+    
+    # Technical details
+    api_version: str = Field(default="v1", description="API version")
+    documentation_url: Optional[str] = Field(None, description="API documentation URL")
+    status_page_url: Optional[str] = Field(None, description="Provider status page URL")
+    
+    # Additional metadata
+    tags: List[str] = Field(default_factory=list, description="Provider tags for categorization")
+    description: Optional[str] = Field(None, max_length=500, description="Provider description")

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

@@ -0,0 +1,87 @@
+"""
+Provider enums and metadata for Universal Payment System v2.0.
+
+Provider definitions with comprehensive metadata.
+"""
+
+from enum import Enum
+from typing import List, Dict
+from .base import ProviderMetadata, ProviderType, ProviderStatus
+
+
+class ProviderEnum(Enum):
+    """Enumeration of supported payment providers."""
+    
+    NOWPAYMENTS = "nowpayments"
+
+    @classmethod
+    def get_all_providers(cls) -> List[str]:
+        """Get list of all provider values."""
+        return [provider.value for provider in cls]
+    
+    @classmethod
+    def is_valid_provider(cls, provider_name: str) -> bool:
+        """Check if provider name is valid."""
+        return provider_name in cls.get_all_providers()
+    
+    @classmethod
+    def get_crypto_providers(cls) -> List[str]:
+        """Get list of crypto-supporting providers."""
+        return [
+            provider.value for provider in cls
+            if PROVIDER_METADATA[provider.value].supports_crypto
+        ]
+    
+    @classmethod
+    def get_fiat_providers(cls) -> List[str]:
+        """Get list of fiat-supporting providers."""
+        return [
+            provider.value for provider in cls
+            if PROVIDER_METADATA[provider.value].supports_fiat
+        ]
+    
+    @classmethod
+    def get_active_providers(cls) -> List[str]:
+        """Get list of active providers."""
+        return [
+            provider.value for provider in cls
+            if PROVIDER_METADATA[provider.value].status == ProviderStatus.ACTIVE
+        ]
+
+
+# Provider metadata registry
+PROVIDER_METADATA: Dict[str, ProviderMetadata] = {
+    ProviderEnum.NOWPAYMENTS.value: ProviderMetadata(
+        name="NowPayments",
+        provider_type=ProviderType.CRYPTO,
+        status=ProviderStatus.ACTIVE,
+        priority=10,  # High priority
+        
+        # Features
+        supports_fiat=False,
+        supports_crypto=True,
+        supports_webhooks=True,
+        supports_refunds=False,
+        supports_partial_payments=False,
+        
+        # Limits and fees
+        min_amount_usd=1.0,
+        max_amount_usd=50000.0,
+        fee_percentage=0.5,  # 0.5% fee
+        fixed_fee_usd=0.0,
+        
+        # Geographic
+        supported_countries=[],  # Global support
+        restricted_countries=["US"],  # Example restriction
+        requires_kyc=False,
+        
+        # Technical
+        api_version="v1",
+        documentation_url="https://documenter.getpostman.com/view/7907941/S1a32n38",
+        status_page_url="https://status.nowpayments.io/",
+        
+        # Additional
+        tags=["crypto", "bitcoin", "ethereum", "altcoins", "instant"],
+        description="Cryptocurrency payment processor supporting 300+ cryptocurrencies with instant settlements"
+    )
+}