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

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

@@ -1,293 +1,478 @@
 """
-NowPayments provider implementation.
+NowPayments provider for the Universal Payment System v2.0.
 
-Enhanced crypto payment provider with minimal typing.
+Implementation of NowPayments API integration with unified interface.
 """
 
-import logging
-import requests
-import hashlib
-import hmac
-from typing import Optional, List
+from typing import Dict, Any, Optional, List
 from decimal import Decimal
+from datetime import datetime
 from pydantic import BaseModel, Field
+import hmac
+import hashlib
+import json
 
-from .base import PaymentProvider
-from ..internal_types import ProviderResponse, WebhookData
-
-logger = logging.getLogger(__name__)
+from .base import BaseProvider, ProviderConfig, PaymentRequest
+from ..types import ProviderResponse, ServiceOperationResult, NowPaymentsWebhook
+from django_cfg.modules.django_currency import convert_currency
 
 
-class NowPaymentsConfig(BaseModel):
-    """NowPayments provider configuration."""
-    api_key: str = Field(..., description="NowPayments API key")
-    sandbox: bool = Field(default=False, description="Use sandbox mode")
-    ipn_secret: Optional[str] = Field(default=None, description="IPN secret for webhook validation")
-    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
-    success_url: Optional[str] = Field(default=None, description="Payment success redirect URL")
-    cancel_url: Optional[str] = Field(default=None, description="Payment cancel redirect URL")
-    enabled: bool = Field(default=True, description="Provider enabled")
+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)
 
 
-class NowPaymentsProvider(PaymentProvider):
-    """NowPayments cryptocurrency payment provider."""
+class NowPaymentsProvider(BaseProvider):
+    """
+    NowPayments provider implementation.
+    
+    Handles payment creation, status checking, and webhook validation for NowPayments.
+    """
     
     def __init__(self, config: NowPaymentsConfig):
         """Initialize NowPayments provider."""
-        super().__init__(config.dict())
-        self.config = config
-        self.api_key = config.api_key
-        self.sandbox = config.sandbox
-        self.ipn_secret = config.ipn_secret or ''
-        self.base_url = self._get_base_url()
-        
-        # Configurable URLs 
-        self.callback_url = config.callback_url
-        self.success_url = config.success_url
-        self.cancel_url = config.cancel_url
-        
-        self.headers = {
-            'x-api-key': self.api_key,
-            'Content-Type': 'application/json'
-        }
+        super().__init__(config)
+        self.config: NowPaymentsConfig = config
     
-    def _get_base_url(self) -> str:
-        """Get base URL based on sandbox mode."""
-        if self.sandbox:
-            return 'https://api-sandbox.nowpayments.io/v1'
-        return 'https://api.nowpayments.io/v1'
-    
-    def _make_request(self, method: str, endpoint: str, data: Optional[dict] = None) -> Optional[dict]:
-        """Make HTTP request to NowPayments API with error handling."""
+    def create_payment(self, request: PaymentRequest) -> ProviderResponse:
+        """
+        Create payment with NowPayments.
+        
+        Args:
+            request: Payment creation request
+            
+        Returns:
+            ProviderResponse: NowPayments response
+        """
         try:
-            url = f"{self.base_url}/{endpoint}"
-            
-            response = requests.request(
-                method=method,
-                url=url,
-                headers=self.headers,
-                json=data,
-                timeout=30
-            )
+            self.logger.info("Creating NowPayments payment", extra={
+                'amount_usd': request.amount_usd,
+                'currency': request.currency_code,
+                'order_id': request.order_id
+            })
             
-            response.raise_for_status()
-            return response.json()
+            # 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}'
+                )
             
-        except requests.exceptions.RequestException as e:
-            logger.error(f"NowPayments API request failed: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Unexpected error in NowPayments request: {e}")
-            return None
-    
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """Create payment via NowPayments API."""
-        try:
-            amount = Decimal(str(payment_data['amount']))
-            currency = payment_data['currency']
-            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}_{currency}')
-            
-            payment_request = {
-                'price_amount': float(amount),
-                'price_currency': 'usd',  # Base currency
-                'pay_currency': currency,
-                'order_id': order_id,
-                'order_description': payment_data.get('description', f'Payment {order_id}'),
+            # Prepare NowPayments request
+            payment_data = {
+                'price_amount': request.amount_usd,
+                'price_currency': 'USD',
+                'pay_currency': request.currency_code,
+                'order_id': request.order_id,
+                'order_description': request.description or f'Payment {request.order_id}',
             }
             
-            # Add optional URLs
-            if self.success_url:
-                payment_request['success_url'] = self.success_url
-            if self.cancel_url:
-                payment_request['cancel_url'] = self.cancel_url
-            if self.callback_url:
-                payment_request['ipn_callback_url'] = self.callback_url
+            # 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
             
-            response = self._make_request('POST', 'payment', payment_request)
+            # 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
             
-            if response:
-                return ProviderResponse(
+            # Make API request
+            headers = {
+                'x-api-key': self.config.api_key
+            }
+            
+            response_data = self._make_request(
+                method='POST',
+                endpoint='payment',
+                data=payment_data,
+                headers=headers
+            )
+            
+            # Parse NowPayments response
+            if 'payment_id' in 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,
-                    provider_payment_id=response.get('payment_id'),
-                    payment_url=response.get('invoice_url'),
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency'),
-                    status='pending'
+                    raw_response=response_data,
+                    provider_payment_id=response_data['payment_id'],
+                    status='waiting',  # NowPayments initial status
+                    amount=Decimal(str(crypto_amount)),
+                    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:
-                return ProviderResponse(
+                # Error response
+                error_message = response_data.get('message', 'Unknown error')
+                return self._create_provider_response(
                     success=False,
-                    error_message='Failed to create payment'
+                    raw_response=response_data,
+                    error_message=error_message
                 )
                 
         except Exception as e:
-            logger.error(f"NowPayments create_payment error: {e}")
-            return ProviderResponse(
+            self.logger.error(f"NowPayments payment creation failed: {e}", extra={
+                'order_id': request.order_id
+            })
+            
+            return self._create_provider_response(
                 success=False,
-                error_message=str(e)
+                raw_response={'error': str(e)},
+                error_message=f'Payment creation failed: {e}'
             )
     
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Check payment status via NowPayments API."""
+    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
+        """
         try:
-            response = self._make_request('GET', f'payment/{payment_id}')
-            
-            if response:
-                # 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'
-                }
-                
-                provider_status = response.get('payment_status', 'unknown')
-                universal_status = status_mapping.get(provider_status, 'unknown')
-                
-                return ProviderResponse(
+            self.logger.debug("Getting NowPayments payment status", extra={
+                'payment_id': provider_payment_id
+            })
+            
+            headers = {
+                'x-api-key': self.config.api_key
+            }
+            
+            response_data = self._make_request(
+                method='GET',
+                endpoint=f'payment/{provider_payment_id}',
+                headers=headers
+            )
+            
+            if 'payment_status' in response_data:
+                return self._create_provider_response(
                     success=True,
-                    provider_payment_id=response.get('payment_id'),
-                    status=universal_status,
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency')
+                    raw_response=response_data,
+                    provider_payment_id=provider_payment_id,
+                    status=response_data['payment_status'],
+                    amount=Decimal(str(response_data.get('pay_amount', 0))),
+                    currency=response_data.get('pay_currency'),
+                    wallet_address=response_data.get('pay_address')
                 )
             else:
-                return ProviderResponse(
+                error_message = response_data.get('message', 'Payment not found')
+                return self._create_provider_response(
                     success=False,
-                    error_message='Payment not found'
+                    raw_response=response_data,
+                    error_message=error_message
                 )
                 
         except Exception as e:
-            logger.error(f"NowPayments check_payment_status error: {e}")
-            return ProviderResponse(
+            self.logger.error(f"NowPayments status check failed: {e}", extra={
+                'payment_id': provider_payment_id
+            })
+            
+            return self._create_provider_response(
                 success=False,
-                error_message=str(e)
+                raw_response={'error': str(e)},
+                error_message=f'Status check failed: {e}'
             )
     
-    def process_webhook(self, payload: dict) -> WebhookData:
-        """Process NowPayments webhook."""
+    def get_supported_currencies(self) -> ServiceOperationResult:
+        """
+        Get supported currencies from NowPayments.
+        
+        Returns:
+            ServiceOperationResult: List of supported currencies
+        """
         try:
-            # Map status
-            status_mapping = {
-                'waiting': 'pending',
-                'confirming': 'processing', 
-                'confirmed': 'completed',
-                'sending': 'processing',
-                'partially_paid': 'pending',
-                'finished': 'completed',
-                'failed': 'failed',
-                'refunded': 'refunded',
-                'expired': 'expired'
-            }
+            self.logger.debug("Getting NowPayments supported currencies")
             
-            provider_status = payload.get('payment_status', 'unknown')
-            universal_status = status_mapping.get(provider_status, 'unknown')
+            headers = {
+                'x-api-key': self.config.api_key
+            }
             
-            return WebhookData(
-                provider_payment_id=str(payload.get('payment_id', '')),
-                status=universal_status,
-                pay_amount=Decimal(str(payload.get('pay_amount', 0))),
-                actually_paid=Decimal(str(payload.get('actually_paid', 0))),
-                order_id=payload.get('order_id'),
-                signature=payload.get('signature')
+            response_data = self._make_request(
+                method='GET',
+                endpoint='currencies',
+                headers=headers
             )
             
-        except Exception as e:
-            logger.error(f"NowPayments webhook processing error: {e}")
-            raise
-    
-    def get_supported_currencies(self) -> List[str]:
-        """Get list of supported currencies."""
-        try:
-            response = self._make_request('GET', 'currencies')
-            
-            if response and 'currencies' in response:
-                return response['currencies']
+            if 'currencies' in response_data:
+                currencies = response_data['currencies']
+                
+                return ServiceOperationResult(
+                    success=True,
+                    message=f"Retrieved {len(currencies)} supported currencies",
+                    data={
+                        'currencies': currencies,
+                        'count': len(currencies),
+                        'provider': self.name
+                    }
+                )
             else:
-                # Fallback currencies
-                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX', 'BNB']
+                return ServiceOperationResult(
+                    success=False,
+                    message="Failed to get currencies from NowPayments",
+                    error_code="currencies_fetch_failed"
+                )
                 
         except Exception as e:
-            logger.error(f"Error getting supported currencies: {e}")
-            return ['BTC', 'ETH', 'LTC']  # Minimal fallback
+            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_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
-        """Get minimum payment amount for currency pair."""
+    def validate_webhook(self, payload: Dict[str, Any], signature: str = None) -> ServiceOperationResult:
+        """
+        Validate NowPayments IPN webhook.
+        
+        Args:
+            payload: Webhook payload
+            signature: HMAC signature (optional)
+            
+        Returns:
+            ServiceOperationResult: Validation result
+        """
         try:
-            response = self._make_request('GET', 'min-amount', {
-                'currency_from': currency_from,
-                'currency_to': currency_to
+            self.logger.debug("Validating NowPayments webhook", extra={
+                'has_signature': bool(signature),
+                'payment_id': payload.get('payment_id')
             })
             
-            if response and 'min_amount' in response:
-                return Decimal(str(response['min_amount']))
+            # Validate payload structure
+            try:
+                webhook_data = NowPaymentsWebhook(**payload)
+            except Exception as e:
+                return ServiceOperationResult(
+                    success=False,
+                    message=f"Invalid webhook payload: {e}",
+                    error_code="invalid_payload"
+                )
             
-            return None
+            # Validate signature if provided and secret is configured
+            if signature and self.config.ipn_secret:
+                is_valid_signature = self._validate_ipn_signature(payload, signature)
+                if not is_valid_signature:
+                    return ServiceOperationResult(
+                        success=False,
+                        message="Invalid webhook signature",
+                        error_code="invalid_signature"
+                    )
+            
+            return ServiceOperationResult(
+                success=True,
+                message="Webhook validated successfully",
+                data={
+                    'provider': self.name,
+                    'payment_id': webhook_data.payment_id,
+                    'status': webhook_data.payment_status,
+                    'signature_validated': bool(signature and self.config.ipn_secret),
+                    'webhook_data': webhook_data.model_dump()
+                }
+            )
             
         except Exception as e:
-            logger.error(f"Error getting minimum amount: {e}")
-            return None
+            self.logger.error(f"NowPayments webhook validation failed: {e}")
+            
+            return ServiceOperationResult(
+                success=False,
+                message=f"Webhook validation error: {e}",
+                error_code="validation_error"
+            )
     
-    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
-        """Estimate payment amount in target currency."""
+    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
+        """
         try:
-            response = self._make_request('GET', 'estimate', {
-                'amount': float(amount),
-                'currency_from': 'usd',
-                'currency_to': currency_code
+            self.logger.debug("Getting NowPayments exchange rate", extra={
+                'from': from_currency,
+                'to': to_currency
             })
             
-            if response and 'estimated_amount' in response:
-                return {
-                    'estimated_amount': Decimal(str(response['estimated_amount'])),
-                    'currency_from': response.get('currency_from'),
-                    'currency_to': response.get('currency_to'),
-                    'fee_amount': Decimal(str(response.get('fee_amount', 0)))
-                }
+            headers = {
+                'x-api-key': self.config.api_key
+            }
             
-            return None
+            response_data = self._make_request(
+                method='GET',
+                endpoint=f'exchange-amount/{from_currency}-{to_currency}',
+                headers=headers
+            )
             
+            if 'estimated_amount' in response_data:
+                rate = float(response_data['estimated_amount'])
+                
+                return ServiceOperationResult(
+                    success=True,
+                    message="Exchange rate retrieved",
+                    data={
+                        'from_currency': from_currency,
+                        'to_currency': to_currency,
+                        'rate': rate,
+                        'provider': self.name
+                    }
+                )
+            else:
+                return ServiceOperationResult(
+                    success=False,
+                    message="Exchange rate not available",
+                    error_code="rate_not_available"
+                )
+                
         except Exception as e:
-            logger.error(f"Error estimating payment amount: {e}")
-            return None
+            self.logger.error(f"NowPayments exchange rate failed: {e}")
+            
+            return ServiceOperationResult(
+                success=False,
+                message=f"Exchange rate error: {e}",
+                error_code="rate_fetch_error"
+            )
     
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
-        """Validate NowPayments webhook signature."""
-        try:
-            if not self.ipn_secret:
-                logger.warning("IPN secret not configured, skipping webhook validation")
-                return True
+    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
             
-            if not headers:
-                logger.warning("No headers provided for webhook validation")
-                return False
+        Returns:
+            bool: True if signature is valid
+        """
+        try:
+            # Sort payload and create canonical string
+            sorted_payload = json.dumps(payload, separators=(',', ':'), sort_keys=True)
             
-            # Get signature from headers
-            signature = headers.get('x-nowpayments-sig')
-            if not signature:
-                logger.warning("No signature found in webhook headers")
-                return False
+            # Calculate expected signature
+            expected_signature = hmac.new(
+                self.config.ipn_secret.encode('utf-8'),
+                sorted_payload.encode('utf-8'),
+                hashlib.sha512
+            ).hexdigest()
             
-            # TODO: Implement proper HMAC signature validation
-            # This requires the raw payload body for proper validation
-            logger.info("Webhook signature validation placeholder")
-            return True
+            # Compare signatures
+            return hmac.compare_digest(expected_signature, signature)
             
         except Exception as e:
-            logger.error(f"Webhook validation error: {e}")
+            self.logger.error(f"Signature validation error: {e}")
             return False
     
-    def check_api_status(self) -> bool:
-        """Check if NowPayments API is available."""
+    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
+        """
+        if not expiry_str:
+            return None
+        
         try:
-            response = self._make_request('GET', 'status')
-            return response is not None and response.get('message') == 'OK'
-        except:
-            return False
+            # 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 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}
+            )