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

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

@@ -5,20 +5,39 @@ Abstract base class for all payment providers.
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional, List
+from typing import Optional, List, Dict
+from django.db.models import QuerySet
 from decimal import Decimal
 
-from ..internal_types import ProviderResponse, WebhookData
+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
+
+
+logger = get_logger('base_provider')
 
 class PaymentProvider(ABC):
     """Abstract base class for payment providers."""
     
-    def __init__(self, config: dict):
+    # Class-level cache for all providers (5 min TTL)
+    _api_cache = TTLCache(maxsize=100, ttl=300)
+    
+    def __init__(self, config):
         """Initialize provider with config."""
         self.config = config
         self.name = self.__class__.__name__.lower().replace('provider', '')
-        self.enabled = config.get('enabled', True)
+        self.logger = get_logger(f"payment.{self.name}")
+        
+        # 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)
     
     @abstractmethod
     def create_payment(self, payment_data: dict) -> ProviderResponse:
@@ -61,16 +80,23 @@ class PaymentProvider(ABC):
         """
         pass
     
-    @abstractmethod
-    def get_supported_currencies(self) -> List[str]:
+    @abstractmethod 
+    def get_parsed_currencies(self) -> UniversalCurrenciesResponse:
         """
-        Get list of supported currencies.
+        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
         
         Returns:
-            List of supported currency codes
+            UniversalCurrenciesResponse with parsed data
         """
         pass
     
+    
+    
     def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
         """
         Validate webhook signature and data.
@@ -85,33 +111,6 @@ class PaymentProvider(ABC):
         # Default implementation - providers can override
         return True
     
-    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
-        """
-        Get minimum payment amount for currency pair.
-        
-        Args:
-            currency_from: Source currency
-            currency_to: Target currency
-            
-        Returns:
-            Minimum payment amount or None if not supported
-        """
-        # Optional method - providers can override
-        return None
-    
-    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
-        """
-        Estimate payment amount in target currency.
-        
-        Args:
-            amount: Amount to estimate
-            currency_code: Target currency
-            
-        Returns:
-            Dict with estimation data or None if not supported
-        """
-        # Optional method - providers can override
-        return None
     
     def check_api_status(self) -> bool:
         """
@@ -127,11 +126,113 @@ class PaymentProvider(ABC):
         """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(),
-        }
+    def sync_currencies_to_db(self) -> ProviderSyncResult:
+        """
+        Synchronize provider currencies with clean architecture.
+        Uses get_parsed_currencies() to get normalized data.
+        """
+        result = ProviderSyncResult()
+        
+        # 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)
+        
+        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
+            }
+        )

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

@@ -0,0 +1,4 @@
+from .provider import CryptAPIProvider
+from .models import CryptAPIConfig, CryptAPICurrency, CryptAPINetwork
+
+__all__ = ['CryptAPIProvider', 'CryptAPIConfig', 'CryptAPICurrency', 'CryptAPINetwork']

django_cfg/apps/payments/services/providers/cryptapi/config.py

@@ -0,0 +1,8 @@
+
+
+PUBLIC_KEY = """-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3FT0Ym8b3myVxhQW7ESuuu6lo
+dGAsUJs4fq+Ey//jm27jQ7HHHDmP1YJO7XE7Jf/0DTEJgcw4EZhJFVwsk6d3+4fy
+Bsn0tKeyGMiaE6cVkX0cy6Y85o8zgc/CwZKc0uw6d5siAo++xl2zl+RGMXCELQVE
+ox7pp208zTvown577wIDAQAB
+-----END PUBLIC KEY-----"""

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

@@ -0,0 +1,192 @@
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from typing import Optional, List, Dict, Any
+from decimal import Decimal
+
+from ...internal_types import ProviderConfig
+from .config import PUBLIC_KEY
+
+class CryptAPIConfig(ProviderConfig):
+    """CryptAPI provider configuration with Pydantic v2."""
+    
+    own_address: str = Field(..., description="Your cryptocurrency address")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    convert_payments: bool = Field(default=True, description="Auto-convert payments")
+    multi_token: bool = Field(default=True, description="Support multi-token payments")
+    priority: str = Field(default='default', description="Transaction priority")
+    verify_signatures: bool = Field(default=True, description="Enable webhook signature verification")
+    
+    # CryptAPI's official public key for signature verification
+    public_key: str = Field(
+        default=PUBLIC_KEY,
+        description="CryptAPI RSA public key for signature verification"
+    )
+
+
+class CryptAPICurrency(BaseModel):
+    """CryptAPI specific currency model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_code: str = Field(..., description="Currency symbol (e.g., BTC, ETH)")
+    name: str = Field(..., description="Full currency name")
+    minimum_transaction: Optional[Decimal] = Field(None, description="Minimum transaction amount")
+    maximum_transaction: Optional[Decimal] = Field(None, description="Maximum transaction amount")
+    fee_percent: Optional[Decimal] = Field(None, description="Fee percentage")
+    logo: Optional[str] = Field(None, description="Currency logo URL")
+
+
+class CryptAPINetwork(BaseModel):
+    """CryptAPI specific network model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency: str = Field(..., description="Currency code this network belongs to")
+    network: str = Field(..., description="Network code (e.g., mainnet, testnet)")
+    name: str = Field(..., description="Network display name")
+    confirmations: int = Field(1, description="Required confirmations")
+    fee: Optional[Decimal] = Field(None, description="Network fee")
+
+
+class CryptAPIPaymentRequest(BaseModel):
+    """CryptAPI payment creation request."""
+    ticker: str = Field(..., description="Currency ticker")
+    callback: str = Field(..., description="Callback URL")
+    address: Optional[str] = Field(None, description="Destination address")
+    pending: bool = Field(False, description="Accept pending transactions")
+    confirmations: int = Field(1, description="Required confirmations")
+    email: Optional[str] = Field(None, description="Email for notifications")
+    post: int = Field(0, description="POST data format")
+    json: int = Field(1, description="JSON response format")
+    priority: Optional[str] = Field(None, description="Priority level")
+    multi_token: bool = Field(False, description="Multi-token support")
+    convert: int = Field(1, description="Convert amounts")
+
+
+class CryptAPIPaymentResponse(BaseModel):
+    """CryptAPI payment creation response."""
+    address_in: str = Field(..., description="Payment address")
+    address_out: Optional[str] = Field(None, description="Destination address")
+    callback_url: str = Field(..., description="Callback URL")
+    priority: Optional[str] = Field(None, description="Priority level")
+    minimum: Optional[Decimal] = Field(None, description="Minimum amount")
+
+
+class CryptAPICallback(BaseModel):
+    """CryptAPI webhook callback data according to official documentation."""
+    model_config = ConfigDict(validate_assignment=True, extra="allow")  # Allow extra fields for custom params
+    
+    # Required fields from documentation
+    uuid: Optional[str] = Field(None, description="Unique identifier for each payment transaction")
+    address_in: str = Field(..., description="CryptAPI-generated payment address")
+    address_out: str = Field(..., description="Your destination address(es)")
+    txid_in: str = Field(..., description="Transaction hash of customer's payment")
+    coin: str = Field(..., description="Cryptocurrency ticker")
+    price: Optional[Decimal] = Field(None, description="Cryptocurrency price in USD")
+    pending: Optional[int] = Field(0, description="1=pending webhook, 0=confirmed webhook")
+    
+    # Confirmed webhook only fields
+    txid_out: Optional[str] = Field(None, description="CryptAPI's forwarding transaction hash")
+    confirmations: Optional[int] = Field(None, description="Number of blockchain confirmations")
+    value_coin: Optional[Decimal] = Field(None, description="Payment amount before fees")
+    value_forwarded_coin: Optional[Decimal] = Field(None, description="Amount forwarded after fees")
+    fee_coin: Optional[Decimal] = Field(None, description="CryptAPI service fee")
+    
+    # Optional conversion fields (when convert=1)
+    value_coin_convert: Optional[str] = Field(None, description="JSON FIAT conversions of value_coin")
+    value_forwarded_coin_convert: Optional[str] = Field(None, description="JSON FIAT conversions of value_forwarded_coin")
+    
+    @field_validator('pending')
+    @classmethod
+    def validate_pending(cls, v):
+        """Validate pending field is 0 or 1."""
+        if v not in [0, 1]:
+            raise ValueError("pending must be 0 (confirmed) or 1 (pending)")
+        return v
+    
+
+
+class CryptAPIInfoResponse(BaseModel):
+    """CryptAPI info endpoint response."""
+    ticker: str = Field(..., description="Currency ticker")
+    minimum_transaction: Decimal = Field(..., description="Minimum transaction amount")
+    maximum_transaction: Optional[Decimal] = Field(None, description="Maximum transaction amount")
+    fee_percent: Decimal = Field(..., description="Fee percentage")
+    network_fee: Decimal = Field(..., description="Network fee")
+    prices: Dict[str, Decimal] = Field(..., description="Price conversions")
+
+
+class CryptAPIEstimateFeeResponse(BaseModel):
+    """CryptAPI fee estimation response."""
+    estimated_cost: Decimal = Field(..., description="Estimated cost")
+    estimated_cost_currency: Dict[str, Decimal] = Field(..., description="Cost in different currencies")
+
+
+class CryptAPIConvertResponse(BaseModel):
+    """CryptAPI currency conversion response."""
+    value_coin: Decimal = Field(..., description="Value in cryptocurrency")
+    exchange_rate: Decimal = Field(..., description="Exchange rate used")
+
+
+class CryptAPIQRCodeResponse(BaseModel):
+    """CryptAPI QR code response."""
+    qr_code: str = Field(..., description="Base64 encoded QR code image")
+    payment_uri: str = Field(..., description="Payment URI for QR code")
+
+
+class CryptAPILogsResponse(BaseModel):
+    """CryptAPI logs response."""
+    callbacks: List[Dict[str, Any]] = Field(default_factory=list, description="Callback logs")
+    payments: List[Dict[str, Any]] = Field(default_factory=list, description="Payment logs")
+
+
+class CryptAPISupportedCoinsResponse(BaseModel):
+    """CryptAPI supported coins response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currencies: List[CryptAPICurrency] = Field(..., description="List of supported currencies")
+
+
+# =============================================================================
+# MONITORING & HEALTH CHECK MODELS
+# =============================================================================
+
+class CryptAPIInfoResponse(BaseModel):
+    """CryptAPI /btc/info/ response schema for health checks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    coin: str = Field(..., description="Cryptocurrency name")
+    logo: str = Field(..., description="Logo URL")
+    ticker: str = Field(..., description="Currency ticker")
+    minimum_transaction: int = Field(..., description="Minimum transaction in satoshis")
+    minimum_transaction_coin: str = Field(..., description="Minimum transaction in coin units")
+    minimum_fee: int = Field(..., description="Minimum fee in satoshis")
+    minimum_fee_coin: str = Field(..., description="Minimum fee in coin units")
+    fee_percent: str = Field(..., description="Fee percentage")
+    network_fee_estimation: str = Field(..., description="Network fee estimation")
+    status: str = Field(..., description="API status")
+    prices: Dict[str, str] = Field(..., description="Prices in various fiat currencies")
+    prices_updated: str = Field(..., description="Prices last updated timestamp")
+    
+    @field_validator('status')
+    @classmethod
+    def validate_status(cls, v):
+        """Validate that status is success."""
+        if v != 'success':
+            raise ValueError(f"Expected status 'success', got '{v}'")
+        return v
+    
+    @field_validator('prices')
+    @classmethod
+    def validate_prices_not_empty(cls, v):
+        """Validate that prices dict is not empty."""
+        if not v:
+            raise ValueError("Prices dictionary cannot be empty")
+        return v
+    
+    def get_usd_price(self) -> Optional[Decimal]:
+        """Get USD price as Decimal."""
+        usd_price = self.prices.get('USD')
+        if usd_price:
+            try:
+                return Decimal(usd_price)
+            except:
+                return None
+        return None