django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/payments/services/providers/{nowpayments.py → nowpayments/provider.py}

@@ -1,74 +1,97 @@
 """
-NowPayments provider for the Universal Payment System v2.0.
+NowPayments provider implementation for Universal Payment System v2.0.
 
-Implementation of NowPayments API integration with unified interface.
+Enhanced crypto payment provider with currency synchronization.
 """
 
-from typing import Dict, Any, Optional, List
+import requests
+import hashlib
+import hmac
+from typing import Optional, List, Dict, Any
 from decimal import Decimal
 from datetime import datetime
-from pydantic import BaseModel, Field
-import hmac
-import hashlib
-import json
-
-from .base import BaseProvider, ProviderConfig, PaymentRequest
-from ..types import ProviderResponse, ServiceOperationResult, NowPaymentsWebhook
-from django_cfg.modules.django_currency import convert_currency
 
+from django_cfg.modules.django_logger import get_logger
+from ..base import BaseProvider
+from ..models import PaymentRequest
+from ...types import ProviderResponse, ServiceOperationResult
+from .models import (
+    NowPaymentsProviderConfig, 
+    NowPaymentsCurrency, 
+    NowPaymentsFullCurrenciesResponse
+)
+from ..models import (
+    UniversalCurrency,
+    UniversalCurrenciesResponse,
+    CurrencySyncResult
+)
+from .sync import NowPaymentsCurrencySync
+from .parsers import NowPaymentsCurrencyParser
+from .config import NowPaymentsConfig as Config
 
-class NowPaymentsConfig(ProviderConfig):
-    """
-    NowPayments-specific configuration.
-    
-    Extends base config with NowPayments-specific fields.
-    """
-    
-    ipn_secret: Optional[str] = Field(None, description="IPN callback secret")
-    
-    def __init__(self, **data):
-        """Initialize with NowPayments defaults."""
-        # Set NowPayments-specific defaults
-        if 'provider_name' not in data:
-            data['provider_name'] = 'nowpayments'
-        
-        if 'api_url' not in data:
-            sandbox = data.get('sandbox', False)
-            data['api_url'] = (
-                'https://api-sandbox.nowpayments.io/v1' if sandbox 
-                else 'https://api.nowpayments.io/v1'
-            )
-        
-        if 'supported_currencies' not in data:
-            data['supported_currencies'] = [
-                'BTC', 'ETH', 'LTC', 'XMR', 'USDT', 'USDC', 'ADA', 'DOT'
-            ]
-        
-        super().__init__(**data)
+logger = get_logger("nowpayments")
 
 
 class NowPaymentsProvider(BaseProvider):
-    """
-    NowPayments provider implementation.
+    """NowPayments cryptocurrency payment provider."""
     
-    Handles payment creation, status checking, and webhook validation for NowPayments.
-    """
+    # Map NowPayments status to universal status
+    STATUS_MAPPING = {
+        'waiting': 'pending',
+        'confirming': 'processing', 
+        'confirmed': 'completed',
+        'sending': 'processing',
+        'partially_paid': 'pending',
+        'finished': 'completed',
+        'failed': 'failed',
+        'refunded': 'refunded',
+        'expired': 'expired'
+    }
     
-    def __init__(self, config: NowPaymentsConfig):
+    def __init__(self, config: NowPaymentsProviderConfig):
         """Initialize NowPayments provider."""
         super().__init__(config)
-        self.config: NowPaymentsConfig = config
+        self.config: NowPaymentsProviderConfig = config
+        self.sync_service = NowPaymentsCurrencySync(self.name)
+        self.parser = NowPaymentsCurrencyParser()
+        
+        # Log initialization
+        api_key_str = str(self.config.api_key)
+        if hasattr(self.config.api_key, 'get_secret_value'):
+            api_key_str = self.config.api_key.get_secret_value()
+        
+        logger.info(
+            f"🔑 NowPayments initialized: api_key={api_key_str[:10]}..., "
+            f"sandbox={self.is_sandbox}, base_url={self.config.api_url}"
+        )
+    
+    # Override BaseProvider configuration methods
+    def get_fee_percentage(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """Get NowPayments fee percentage."""
+        return Config.FEE_PERCENTAGE
+    
+    def get_fixed_fee_usd(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """Get NowPayments fixed fee."""
+        return Config.FIXED_FEE_USD
+    
+    def get_min_amount_usd(self, currency_code: str = None, currency_type: str = None, is_stable: bool = False) -> Decimal:
+        """Get NowPayments minimum amount."""
+        return Config.get_min_amount()
+    
+    def get_max_amount_usd(self, currency_code: str = None, currency_type: str = None) -> Decimal:
+        """Get NowPayments maximum amount."""
+        return Config.MAX_AMOUNT_USD
+    
+    def get_confirmation_blocks(self, network_code: str) -> int:
+        """Get confirmation blocks for network."""
+        return Config.get_confirmation_blocks(network_code)
+    
+    def get_network_name(self, network_code: str) -> str:
+        """Get human-readable network name."""
+        return Config.get_network_name(network_code)
     
     def create_payment(self, request: PaymentRequest) -> ProviderResponse:
-        """
-        Create payment with NowPayments.
-        
-        Args:
-            request: Payment creation request
-            
-        Returns:
-            ProviderResponse: NowPayments response
-        """
+        """Create payment with NowPayments."""
         try:
             self.logger.info("Creating NowPayments payment", extra={
                 'amount_usd': request.amount_usd,
@@ -76,20 +99,6 @@ class NowPaymentsProvider(BaseProvider):
                 'order_id': request.order_id
             })
             
-            # Convert USD to crypto amount
-            try:
-                crypto_amount = convert_currency(
-                    request.amount_usd, 
-                    'USD', 
-                    request.currency_code
-                )
-            except Exception as e:
-                return self._create_provider_response(
-                    success=False,
-                    raw_response={'error': f'Currency conversion failed: {e}'},
-                    error_message=f'Currency conversion failed: {e}'
-                )
-            
             # Prepare NowPayments request
             payment_data = {
                 'price_amount': request.amount_usd,
@@ -109,13 +118,13 @@ class NowPaymentsProvider(BaseProvider):
             if request.customer_email:
                 payment_data['customer_email'] = request.customer_email
             
-            # Add IPN callback URL (would be configured via webhook service)
-            if hasattr(self, '_ipn_callback_url'):
-                payment_data['ipn_callback_url'] = self._ipn_callback_url
+            # Add IPN callback URL if configured
+            if self.config.callback_url:
+                payment_data['ipn_callback_url'] = self.config.callback_url
             
             # Make API request
             headers = {
-                'x-api-key': self.config.api_key
+                'x-api-key': self._get_api_key()
             }
             
             response_data = self._make_request(
@@ -126,7 +135,7 @@ class NowPaymentsProvider(BaseProvider):
             )
             
             # Parse NowPayments response
-            if 'payment_id' in response_data:
+            if response_data and 'payment_id' in response_data:
                 # Successful payment creation
                 payment_url = response_data.get('invoice_url') or response_data.get('pay_url')
                 
@@ -135,19 +144,18 @@ class NowPaymentsProvider(BaseProvider):
                     raw_response=response_data,
                     provider_payment_id=response_data['payment_id'],
                     status='waiting',  # NowPayments initial status
-                    amount=Decimal(str(crypto_amount)),
+                    amount=Decimal(str(response_data.get('pay_amount', 0))),
                     currency=request.currency_code,
                     payment_url=payment_url,
                     wallet_address=response_data.get('pay_address'),
-                    qr_code_url=response_data.get('qr_code_url'),
                     expires_at=self._parse_expiry_time(response_data.get('expiration_estimate_date'))
                 )
             else:
                 # Error response
-                error_message = response_data.get('message', 'Unknown error')
+                error_message = response_data.get('message', 'Unknown error') if response_data else 'No response'
                 return self._create_provider_response(
                     success=False,
-                    raw_response=response_data,
+                    raw_response=response_data or {},
                     error_message=error_message
                 )
                 
@@ -163,22 +171,14 @@ class NowPaymentsProvider(BaseProvider):
             )
     
     def get_payment_status(self, provider_payment_id: str) -> ProviderResponse:
-        """
-        Get payment status from NowPayments.
-        
-        Args:
-            provider_payment_id: NowPayments payment ID
-            
-        Returns:
-            ProviderResponse: Current payment status
-        """
+        """Get payment status from NowPayments."""
         try:
             self.logger.debug("Getting NowPayments payment status", extra={
                 'payment_id': provider_payment_id
             })
             
             headers = {
-                'x-api-key': self.config.api_key
+                'x-api-key': self._get_api_key()
             }
             
             response_data = self._make_request(
@@ -187,21 +187,24 @@ class NowPaymentsProvider(BaseProvider):
                 headers=headers
             )
             
-            if 'payment_status' in response_data:
+            if response_data and 'payment_status' in response_data:
+                provider_status = response_data['payment_status']
+                universal_status = self.STATUS_MAPPING.get(provider_status, 'unknown')
+                
                 return self._create_provider_response(
                     success=True,
                     raw_response=response_data,
                     provider_payment_id=provider_payment_id,
-                    status=response_data['payment_status'],
+                    status=universal_status,
                     amount=Decimal(str(response_data.get('pay_amount', 0))),
                     currency=response_data.get('pay_currency'),
                     wallet_address=response_data.get('pay_address')
                 )
             else:
-                error_message = response_data.get('message', 'Payment not found')
+                error_message = response_data.get('message', 'Payment not found') if response_data else 'No response'
                 return self._create_provider_response(
                     success=False,
-                    raw_response=response_data,
+                    raw_response=response_data or {},
                     error_message=error_message
                 )
                 
@@ -217,26 +220,21 @@ class NowPaymentsProvider(BaseProvider):
             )
     
     def get_supported_currencies(self) -> ServiceOperationResult:
-        """
-        Get supported currencies from NowPayments.
-        
-        Returns:
-            ServiceOperationResult: List of supported currencies
-        """
+        """Get supported currencies from NowPayments."""
         try:
             self.logger.debug("Getting NowPayments supported currencies")
             
             headers = {
-                'x-api-key': self.config.api_key
+                'x-api-key': self._get_api_key()
             }
             
             response_data = self._make_request(
                 method='GET',
-                endpoint='currencies',
+                endpoint='full-currencies',
                 headers=headers
             )
             
-            if 'currencies' in response_data:
+            if response_data and 'currencies' in response_data:
                 currencies = response_data['currencies']
                 
                 return ServiceOperationResult(
@@ -264,17 +262,113 @@ class NowPaymentsProvider(BaseProvider):
                 error_code="currencies_fetch_error"
             )
     
-    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
-        """
-        Validate NowPayments IPN webhook.
-        
-        Args:
-            payload: Webhook payload
-            signature: HMAC signature (optional)
+    def get_parsed_currencies(self) -> UniversalCurrenciesResponse:
+        """Get parsed and normalized currencies from NowPayments."""
+        try:
+            # Use full-currencies endpoint to get detailed currency info
+            headers = {
+                'x-api-key': self._get_api_key()
+            }
+            
+            response_data = self._make_request(
+                method='GET',
+                endpoint='full-currencies',
+                headers=headers
+            )
+            
+            if not response_data or 'currencies' not in response_data:
+                return UniversalCurrenciesResponse(currencies=[])
+            
+            universal_currencies = []
             
-        Returns:
-            ServiceOperationResult: Validation result
-        """
+            for currency_data in response_data['currencies']:
+                if not currency_data.get('enable', True):
+                    continue  # Skip disabled currencies
+                
+                provider_code = currency_data.get('code', '').upper()
+                if not provider_code:
+                    continue
+                
+                # Parse provider code into base currency + network using API data
+                currency_name = currency_data.get('name', '')
+                api_network = currency_data.get('network')
+                ticker = currency_data.get('ticker', '')
+                
+                # Use parser to extract base currency and network
+                parse_result = self.parser.parse_currency_code(
+                    provider_code, currency_name, api_network, ticker
+                )
+                
+                # Skip currencies that should be filtered out (empty network duplicates)
+                if parse_result[0] is None:
+                    continue
+                
+                base_currency_code, network_code = parse_result
+                
+                # Determine currency type
+                currency_type = 'fiat' if network_code is None else 'crypto'
+                
+                # Generate proper currency name
+                proper_name = self.parser.generate_currency_name(
+                    base_currency_code, network_code, currency_name
+                )
+                
+                universal_currency = UniversalCurrency(
+                    provider_currency_code=provider_code,
+                    base_currency_code=base_currency_code,
+                    network_code=network_code,
+                    name=proper_name,  # Use generated name instead of API name
+                    currency_type=currency_type,
+                    is_enabled=currency_data.get('enable', True),
+                    is_popular=currency_data.get('is_popular', False),
+                    is_stable=currency_data.get('is_stable', False),
+                    priority=currency_data.get('priority', 0),
+                    logo_url=currency_data.get('logo_url', ''),
+                    available_for_payment=currency_data.get('available_for_payment', True),
+                    available_for_payout=currency_data.get('available_for_payout', True),
+                    raw_data=currency_data
+                )
+                
+                universal_currencies.append(universal_currency)
+            
+            return UniversalCurrenciesResponse(currencies=universal_currencies)
+            
+        except Exception as e:
+            logger.error(f"Error parsing currencies: {e}")
+            return UniversalCurrenciesResponse(currencies=[])
+    
+    def sync_currencies_to_db(self) -> CurrencySyncResult:
+        """Sync currencies from NowPayments API to database."""
+        try:
+            self.logger.info("Starting NowPayments currency synchronization")
+            
+            # Get parsed currencies from API
+            currencies_response = self.get_parsed_currencies()
+            
+            if not currencies_response.currencies:
+                return CurrencySyncResult(
+                    errors=["No currencies received from NowPayments API"]
+                )
+            
+            # Sync to database
+            result = self.sync_service.sync_currencies_to_db(currencies_response.currencies)
+            
+            self.logger.info(
+                f"NowPayments currency sync completed: "
+                f"{result.currencies_created} currencies created, "
+                f"{result.provider_currencies_created} provider currencies created, "
+                f"{len(result.errors)} errors"
+            )
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"Currency sync failed: {e}"
+            self.logger.error(error_msg)
+            return CurrencySyncResult(errors=[error_msg])
+    
+    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
+        """Validate NowPayments IPN webhook."""
         try:
             self.logger.debug("Validating NowPayments webhook", extra={
                 'has_signature': bool(signature),
@@ -283,6 +377,7 @@ class NowPaymentsProvider(BaseProvider):
             
             # Validate payload structure
             try:
+                from .models import NowPaymentsWebhook
                 webhook_data = NowPaymentsWebhook(**payload)
             except Exception as e:
                 return ServiceOperationResult(
@@ -322,74 +417,62 @@ class NowPaymentsProvider(BaseProvider):
                 error_code="validation_error"
             )
     
-    def get_exchange_rate(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
-        """
-        Get exchange rate from NowPayments.
-        
-        Args:
-            from_currency: Source currency
-            to_currency: Target currency
-            
-        Returns:
-            ServiceOperationResult: Exchange rate
-        """
+    def health_check(self) -> ServiceOperationResult:
+        """Perform NowPayments-specific health check."""
         try:
-            self.logger.debug("Getting NowPayments exchange rate", extra={
-                'from': from_currency,
-                'to': to_currency
-            })
-            
+            # Test API connectivity by getting status
             headers = {
-                'x-api-key': self.config.api_key
+                'x-api-key': self._get_api_key()
             }
             
             response_data = self._make_request(
                 method='GET',
-                endpoint=f'exchange-amount/{from_currency}-{to_currency}',
+                endpoint='status',
                 headers=headers
             )
             
-            if 'estimated_amount' in response_data:
-                rate = float(response_data['estimated_amount'])
+            if response_data and response_data.get('message') == 'OK':
+                # Also check currencies endpoint
+                currencies_result = self.get_supported_currencies()
+                currency_count = len(currencies_result.data.get('currencies', [])) if currencies_result.success else 0
                 
                 return ServiceOperationResult(
                     success=True,
-                    message="Exchange rate retrieved",
+                    message="NowPayments provider is healthy",
                     data={
-                        'from_currency': from_currency,
-                        'to_currency': to_currency,
-                        'rate': rate,
-                        'provider': self.name
+                        'provider': self.name,
+                        'sandbox': self.is_sandbox,
+                        'api_url': self.config.api_url,
+                        'supported_currencies': currency_count,
+                        'has_ipn_secret': bool(self.config.ipn_secret),
+                        'api_key_configured': bool(self.config.api_key)
                     }
                 )
             else:
                 return ServiceOperationResult(
                     success=False,
-                    message="Exchange rate not available",
-                    error_code="rate_not_available"
+                    message="NowPayments API connectivity failed",
+                    error_code="api_connectivity_failed",
+                    data={
+                        'provider': self.name,
+                        'response': response_data
+                    }
                 )
                 
         except Exception as e:
-            self.logger.error(f"NowPayments exchange rate failed: {e}")
-            
             return ServiceOperationResult(
                 success=False,
-                message=f"Exchange rate error: {e}",
-                error_code="rate_fetch_error"
+                message=f"NowPayments health check error: {e}",
+                error_code="health_check_error",
+                data={'provider': self.name}
             )
     
+    
     def _validate_ipn_signature(self, payload: Dict[str, Any], signature: str) -> bool:
-        """
-        Validate IPN signature using HMAC-SHA512.
-        
-        Args:
-            payload: Webhook payload
-            signature: Received signature
-            
-        Returns:
-            bool: True if signature is valid
-        """
+        """Validate IPN signature using HMAC-SHA512."""
         try:
+            import json
+            
             # Sort payload and create canonical string
             sorted_payload = json.dumps(payload, separators=(',', ':'), sort_keys=True)
             
@@ -408,15 +491,7 @@ class NowPaymentsProvider(BaseProvider):
             return False
     
     def _parse_expiry_time(self, expiry_str: Optional[str]) -> Optional[datetime]:
-        """
-        Parse NowPayments expiry time string.
-        
-        Args:
-            expiry_str: Expiry time string from NowPayments
-            
-        Returns:
-            Optional[datetime]: Parsed expiry time
-        """
+        """Parse NowPayments expiry time string."""
         if not expiry_str:
             return None
         
@@ -427,52 +502,8 @@ class NowPaymentsProvider(BaseProvider):
             self.logger.warning(f"Failed to parse expiry time: {expiry_str}")
             return None
     
-    def set_ipn_callback_url(self, callback_url: str):
-        """
-        Set IPN callback URL for payments.
-        
-        Args:
-            callback_url: IPN callback URL
-        """
-        self._ipn_callback_url = callback_url
-        self.logger.info(f"Set IPN callback URL: {callback_url}")
-    
-    def health_check(self) -> ServiceOperationResult:
-        """Perform NowPayments-specific health check."""
-        try:
-            # Test API connectivity by getting currencies
-            currencies_result = self.get_supported_currencies()
-            
-            if currencies_result.success:
-                currency_count = len(currencies_result.data.get('currencies', []))
-                
-                return ServiceOperationResult(
-                    success=True,
-                    message="NowPayments provider is healthy",
-                    data={
-                        'provider': self.name,
-                        'sandbox': self.is_sandbox,
-                        'api_url': self.config.api_url,
-                        'supported_currencies': currency_count,
-                        'has_ipn_secret': bool(self.config.ipn_secret),
-                        'api_key_configured': bool(self.config.api_key)
-                    }
-                )
-            else:
-                return ServiceOperationResult(
-                    success=False,
-                    message="NowPayments API connectivity failed",
-                    error_code="api_connectivity_failed",
-                    data={
-                        'provider': self.name,
-                        'error': currencies_result.message
-                    }
-                )
-                
-        except Exception as e:
-            return ServiceOperationResult(
-                success=False,
-                message=f"NowPayments health check error: {e}",
-                error_code="health_check_error",
-                data={'provider': self.name}
-            )
+    def _get_api_key(self) -> str:
+        """Get API key as string."""
+        if hasattr(self.config.api_key, 'get_secret_value'):
+            return self.config.api_key.get_secret_value()
+        return str(self.config.api_key)