django-cfg 1.4.21__py3-none-any.whl → 1.4.24__py3-none-any.whl

django_cfg/apps/payments/services/providers/nowpayments/provider.py

@@ -4,41 +4,37 @@ NowPayments provider implementation for Universal Payment System v2.0.
 Enhanced crypto payment provider with currency synchronization.
 """
 
-import requests
 import hashlib
 import hmac
-from typing import Optional, List, Dict, Any
-from decimal import Decimal
 from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, Optional
 
 from django_cfg.modules.django_logging import get_logger
-from ..base import BaseProvider
-from ..models import PaymentRequest
+
 from ...types import ProviderResponse, ServiceOperationResult
-from .models import (
-    NowPaymentsProviderConfig, 
-    NowPaymentsCurrency, 
-    NowPaymentsFullCurrenciesResponse
-)
+from ..base import BaseProvider
 from ..models import (
-    UniversalCurrency,
+    CurrencySyncResult,
+    PaymentRequest,
     UniversalCurrenciesResponse,
-    CurrencySyncResult
+    UniversalCurrency,
 )
-from .sync import NowPaymentsCurrencySync
-from .parsers import NowPaymentsCurrencyParser
 from .config import NowPaymentsConfig as Config
+from .models import NowPaymentsProviderConfig
+from .parsers import NowPaymentsCurrencyParser
+from .sync import NowPaymentsCurrencySync
 
 logger = get_logger("nowpayments")
 
 
 class NowPaymentsProvider(BaseProvider):
     """NowPayments cryptocurrency payment provider."""
-    
+
     # Map NowPayments status to universal status
     STATUS_MAPPING = {
         'waiting': 'pending',
-        'confirming': 'processing', 
+        'confirming': 'processing',
         'confirmed': 'completed',
         'sending': 'processing',
         'partially_paid': 'pending',
@@ -47,49 +43,49 @@ class NowPaymentsProvider(BaseProvider):
         'refunded': 'refunded',
         'expired': 'expired'
     }
-    
+
     def __init__(self, config: NowPaymentsProviderConfig):
         """Initialize NowPayments provider."""
         super().__init__(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."""
         try:
@@ -98,10 +94,10 @@ class NowPaymentsProvider(BaseProvider):
                 'currency': request.currency_code,
                 'order_id': request.order_id
             })
-            
+
             # Use provider_currency_code from metadata if available, otherwise use original currency_code
             provider_currency_code = request.metadata.get('provider_currency_code', request.currency_code)
-            
+
             # Prepare NowPayments request
             payment_data = {
                 'price_amount': request.amount_usd,
@@ -110,7 +106,7 @@ class NowPaymentsProvider(BaseProvider):
                 'order_id': request.order_id,
                 'order_description': request.description or f'Payment {request.order_id}',
             }
-            
+
             # Log the request data for debugging
             self.logger.info("NowPayments request data", extra={
                 'payment_data': payment_data,
@@ -119,33 +115,33 @@ class NowPaymentsProvider(BaseProvider):
                 'request_amount_usd': request.amount_usd,
                 'request_order_id': request.order_id
             })
-            
+
             # Add optional fields
             if request.callback_url:
                 payment_data['success_url'] = request.callback_url
-            
+
             if request.cancel_url:
                 payment_data['cancel_url'] = request.cancel_url
-            
+
             if request.customer_email:
                 payment_data['customer_email'] = request.customer_email
-            
+
             # 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._get_api_key()
             }
-            
+
             response_data = self._make_request(
                 method='POST',
                 endpoint='payment',
                 data=payment_data,
                 headers=headers
             )
-            
+
             # Parse NowPayments response
             if response_data and 'payment_id' in response_data:
                 # Log the full response for debugging
@@ -155,10 +151,10 @@ class NowPaymentsProvider(BaseProvider):
                     'pay_amount': response_data.get('pay_amount'),
                     'full_response': response_data
                 })
-                
+
                 # Successful payment creation
                 payment_url = response_data.get('invoice_url') or response_data.get('pay_url')
-                
+
                 return self._create_provider_response(
                     success=True,
                     raw_response=response_data,
@@ -178,14 +174,14 @@ class NowPaymentsProvider(BaseProvider):
                     raw_response=response_data or {},
                     error_message=error_message
                 )
-                
+
         except Exception as e:
             error_msg = str(e)
             self.logger.error(f"NowPayments payment creation failed: {error_msg}", extra={
                 'order_id': request.order_id,
                 'error_type': type(e).__name__
             })
-            
+
             # Provide user-friendly error messages
             if "IP address blocked" in error_msg:
                 user_message = "NowPayments has blocked this IP address. Please contact support or try from a different location."
@@ -199,34 +195,34 @@ class NowPaymentsProvider(BaseProvider):
                 user_message = "NowPayments service is temporarily unavailable. Please try again later."
             else:
                 user_message = f"Payment creation failed: {error_msg}"
-            
+
             return self._create_provider_response(
                 success=False,
                 raw_response={'error': error_msg, 'error_type': type(e).__name__},
                 error_message=user_message
             )
-    
+
     def get_payment_status(self, provider_payment_id: str) -> ProviderResponse:
         """Get payment status from NowPayments."""
         try:
             self.logger.debug("Getting NowPayments payment status", extra={
                 'payment_id': provider_payment_id
             })
-            
+
             headers = {
                 'x-api-key': self._get_api_key()
             }
-            
+
             response_data = self._make_request(
                 method='GET',
                 endpoint=f'payment/{provider_payment_id}',
                 headers=headers
             )
-            
+
             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,
@@ -243,14 +239,14 @@ class NowPaymentsProvider(BaseProvider):
                     raw_response=response_data or {},
                     error_message=error_message
                 )
-                
+
         except Exception as e:
             error_msg = str(e)
             self.logger.error(f"NowPayments status check failed: {error_msg}", extra={
                 'payment_id': provider_payment_id,
                 'error_type': type(e).__name__
             })
-            
+
             # Provide user-friendly error messages
             if "IP address blocked" in error_msg:
                 user_message = "NowPayments has blocked this IP address. Cannot check payment status."
@@ -260,31 +256,31 @@ class NowPaymentsProvider(BaseProvider):
                 user_message = "NowPayments service is temporarily unavailable. Please try again later."
             else:
                 user_message = f"Status check failed: {error_msg}"
-            
+
             return self._create_provider_response(
                 success=False,
                 raw_response={'error': error_msg, 'error_type': type(e).__name__},
                 error_message=user_message
             )
-    
+
     def get_supported_currencies(self) -> ServiceOperationResult:
         """Get supported currencies from NowPayments."""
         try:
             self.logger.debug("Getting NowPayments supported currencies")
-            
+
             headers = {
                 'x-api-key': self._get_api_key()
             }
-            
+
             response_data = self._make_request(
                 method='GET',
                 endpoint='full-currencies',
                 headers=headers
             )
-            
+
             if response_data and 'currencies' in response_data:
                 currencies = response_data['currencies']
-                
+
                 return ServiceOperationResult(
                     success=True,
                     message=f"Retrieved {len(currencies)} supported currencies",
@@ -300,16 +296,16 @@ class NowPaymentsProvider(BaseProvider):
                     message="Failed to get currencies from NowPayments",
                     error_code="currencies_fetch_failed"
                 )
-                
+
         except Exception as e:
             self.logger.error(f"NowPayments currencies fetch failed: {e}")
-            
+
             return ServiceOperationResult(
                 success=False,
                 message=f"Currencies fetch error: {e}",
                 error_code="currencies_fetch_error"
             )
-    
+
     def get_parsed_currencies(self) -> UniversalCurrenciesResponse:
         """Get parsed and normalized currencies from NowPayments."""
         try:
@@ -317,50 +313,50 @@ class NowPaymentsProvider(BaseProvider):
             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 = []
-            
+
             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,
@@ -376,45 +372,45 @@ class NowPaymentsProvider(BaseProvider):
                     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:
@@ -422,7 +418,7 @@ class NowPaymentsProvider(BaseProvider):
                 'has_signature': bool(signature),
                 'payment_id': payload.get('payment_id')
             })
-            
+
             # Validate payload structure
             try:
                 from .models import NowPaymentsWebhook
@@ -433,7 +429,7 @@ class NowPaymentsProvider(BaseProvider):
                     message=f"Invalid webhook payload: {e}",
                     error_code="invalid_payload"
                 )
-            
+
             # Validate signature if provided and secret is configured
             if signature and self.config.ipn_secret:
                 is_valid_signature = self._validate_ipn_signature(payload, signature)
@@ -443,7 +439,7 @@ class NowPaymentsProvider(BaseProvider):
                         message="Invalid webhook signature",
                         error_code="invalid_signature"
                     )
-            
+
             return ServiceOperationResult(
                 success=True,
                 message="Webhook validated successfully",
@@ -455,16 +451,16 @@ class NowPaymentsProvider(BaseProvider):
                     'webhook_data': webhook_data.model_dump()
                 }
             )
-            
+
         except Exception as e:
             self.logger.error(f"NowPayments webhook validation failed: {e}")
-            
+
             return ServiceOperationResult(
                 success=False,
                 message=f"Webhook validation error: {e}",
                 error_code="validation_error"
             )
-    
+
     def health_check(self) -> ServiceOperationResult:
         """Perform NowPayments-specific health check."""
         try:
@@ -472,18 +468,18 @@ class NowPaymentsProvider(BaseProvider):
             headers = {
                 'x-api-key': self._get_api_key()
             }
-            
+
             response_data = self._make_request(
                 method='GET',
                 endpoint='status',
                 headers=headers
             )
-            
+
             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="NowPayments provider is healthy",
@@ -506,7 +502,7 @@ class NowPaymentsProvider(BaseProvider):
                         'response': response_data
                     }
                 )
-                
+
         except Exception as e:
             return ServiceOperationResult(
                 success=False,
@@ -514,42 +510,42 @@ class NowPaymentsProvider(BaseProvider):
                 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."""
         try:
             import json
-            
+
             # Sort payload and create canonical string
             sorted_payload = json.dumps(payload, separators=(',', ':'), sort_keys=True)
-            
+
             # Calculate expected signature
             expected_signature = hmac.new(
                 self.config.ipn_secret.encode('utf-8'),
                 sorted_payload.encode('utf-8'),
                 hashlib.sha512
             ).hexdigest()
-            
+
             # Compare signatures
             return hmac.compare_digest(expected_signature, signature)
-            
+
         except Exception as e:
             self.logger.error(f"Signature validation error: {e}")
             return False
-    
+
     def _parse_expiry_time(self, expiry_str: Optional[str]) -> Optional[datetime]:
         """Parse NowPayments expiry time string."""
         if not expiry_str:
             return None
-        
+
         try:
             # NowPayments typically returns ISO format
             return datetime.fromisoformat(expiry_str.replace('Z', '+00:00'))
         except Exception:
             self.logger.warning(f"Failed to parse expiry time: {expiry_str}")
             return None
-    
+
     def _get_api_key(self) -> str:
         """Get API key as string."""
         if hasattr(self.config.api_key, 'get_secret_value'):