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

django_cfg/apps/payments/services/core/webhook_service.py

@@ -0,0 +1,410 @@
+"""
+Webhook service for the Universal Payment System v2.0.
+
+Handles webhook validation and processing from payment providers.
+"""
+
+from typing import Optional, Dict, Any
+import json
+from django.utils import timezone
+from django.db import models
+
+from .base import BaseService
+from ..types import (
+    WebhookValidationRequest, WebhookProcessingResult, NowPaymentsWebhook,
+    WebhookSignature, ServiceOperationResult
+)
+from ...models import UniversalPayment
+from .payment_service import PaymentService
+from .balance_service import BalanceService
+# ConfigService removed - using direct Constance access
+
+
+class WebhookService(BaseService):
+    """
+    Webhook service with validation and processing logic.
+    
+    Handles webhook operations using Pydantic validation and provider-specific logic.
+    """
+    
+    def __init__(self):
+        """Initialize webhook service with dependencies."""
+        super().__init__()
+        self.payment_service = PaymentService()
+        self.balance_service = BalanceService()
+        # Direct Constance access instead of ConfigService
+    
+    def validate_webhook(self, request: WebhookValidationRequest) -> ServiceOperationResult:
+        """
+        Validate webhook signature and payload.
+        
+        Args:
+            request: Webhook validation request
+            
+        Returns:
+            ServiceOperationResult: Validation result
+        """
+        try:
+            # Validate request
+            if isinstance(request, dict):
+                request = WebhookValidationRequest(**request)
+            
+            self.logger.info("Validating webhook", extra={
+                'provider': request.provider,
+                'has_signature': bool(request.signature)
+            })
+            
+            # Provider-specific validation
+            if request.provider.lower() == 'nowpayments':
+                return self._validate_nowpayments_webhook(request)
+            else:
+                return self._create_error_result(
+                    f"Unsupported provider: {request.provider}",
+                    "unsupported_provider"
+                )
+                
+        except Exception as e:
+            return self._handle_exception(
+                "validate_webhook", e,
+                provider=request.provider if hasattr(request, 'provider') else None
+            )
+    
+    def process_webhook(self, request: WebhookValidationRequest) -> WebhookProcessingResult:
+        """
+        Process validated webhook and update payment status.
+        
+        Args:
+            request: Webhook validation request
+            
+        Returns:
+            WebhookProcessingResult: Processing result with actions taken
+        """
+        try:
+            # First validate webhook
+            validation_result = self.validate_webhook(request)
+            if not validation_result.success:
+                return WebhookProcessingResult(
+                    success=False,
+                    provider=request.provider,
+                    error_message=validation_result.message,
+                    processed=False
+                )
+            
+            self.logger.info("Processing webhook", extra={
+                'provider': request.provider,
+                'payload_keys': list(request.payload.keys())
+            })
+            
+            # Provider-specific processing
+            if request.provider.lower() == 'nowpayments':
+                return self._process_nowpayments_webhook(request)
+            else:
+                return WebhookProcessingResult(
+                    success=False,
+                    provider=request.provider,
+                    error_message=f"Unsupported provider: {request.provider}",
+                    processed=False
+                )
+                
+        except Exception as e:
+            error_result = self._handle_exception(
+                "process_webhook", e,
+                provider=request.provider if hasattr(request, 'provider') else None
+            )
+            
+            return WebhookProcessingResult(
+                success=False,
+                provider=request.provider if hasattr(request, 'provider') else 'unknown',
+                error_message=error_result.message,
+                processed=False
+            )
+    
+    def _validate_nowpayments_webhook(self, request: WebhookValidationRequest) -> ServiceOperationResult:
+        """Validate NowPayments webhook."""
+        try:
+            # Validate payload structure
+            try:
+                webhook_data = NowPaymentsWebhook(**request.payload)
+            except Exception as e:
+                return self._create_error_result(
+                    f"Invalid NowPayments webhook payload: {e}",
+                    "invalid_payload"
+                )
+            
+            # Validate signature if provided
+            signature_valid = True
+            if request.signature:
+                signature_result = self._validate_nowpayments_signature(request)
+                signature_valid = signature_result.success
+                
+                if not signature_valid:
+                    return self._create_error_result(
+                        "Invalid webhook signature",
+                        "invalid_signature"
+                    )
+            
+            return self._create_success_result(
+                "NowPayments webhook validated successfully",
+                {
+                    'provider': 'nowpayments',
+                    'payment_id': webhook_data.payment_id,
+                    'status': webhook_data.payment_status,
+                    'signature_valid': signature_valid,
+                    'parsed_data': webhook_data.model_dump()
+                }
+            )
+            
+        except Exception as e:
+            return self._create_error_result(
+                f"NowPayments validation error: {e}",
+                "validation_error"
+            )
+    
+    def _validate_nowpayments_signature(self, request: WebhookValidationRequest) -> ServiceOperationResult:
+        """Validate NowPayments webhook signature."""
+        try:
+            # Get secret key from Constance settings
+            constance_settings = self.config_service.get_constance_settings()
+            provider_keys = constance_settings.get_provider_keys('nowpayments')
+            secret_key = provider_keys.get('ipn_secret', '')
+            
+            if not secret_key:
+                return self._create_error_result(
+                    "NowPayments IPN secret not configured",
+                    "missing_secret_key"
+                )
+            
+            # Create signature validator
+            payload_string = json.dumps(request.payload, separators=(',', ':'), sort_keys=True)
+            
+            signature_validator = WebhookSignature(
+                provider='nowpayments',
+                signature=request.signature,
+                payload=payload_string,
+                secret_key=secret_key,
+                algorithm='sha512'
+            )
+            
+            is_valid = signature_validator.validate_signature()
+            
+            if is_valid:
+                return self._create_success_result("Signature is valid")
+            else:
+                return self._create_error_result(
+                    "Invalid signature",
+                    "invalid_signature"
+                )
+                
+        except Exception as e:
+            return self._create_error_result(
+                f"Signature validation error: {e}",
+                "signature_validation_error"
+            )
+    
+    def _process_nowpayments_webhook(self, request: WebhookValidationRequest) -> WebhookProcessingResult:
+        """Process NowPayments webhook."""
+        try:
+            # Parse webhook data
+            webhook_data = NowPaymentsWebhook(**request.payload)
+            
+            # Find payment by provider payment ID
+            try:
+                payment = UniversalPayment.objects.get(
+                    provider_payment_id=webhook_data.payment_id
+                )
+            except UniversalPayment.DoesNotExist:
+                return WebhookProcessingResult(
+                    success=False,
+                    provider='nowpayments',
+                    error_message=f"Payment not found: {webhook_data.payment_id}",
+                    processed=False
+                )
+            
+            # Store original status
+            original_status = payment.status
+            actions_taken = []
+            
+            # Convert NowPayments status to universal status
+            new_status = webhook_data.to_universal_status()
+            
+            # Process status change
+            def process_webhook_transaction():
+                nonlocal actions_taken
+                
+                if new_status == 'completed' and original_status != 'completed':
+                    # Mark payment as completed
+                    success = payment.mark_completed(
+                        actual_amount_usd=float(webhook_data.actually_paid) if webhook_data.actually_paid else None,
+                        transaction_hash=webhook_data.txn_id
+                    )
+                    
+                    if success:
+                        actions_taken.append("payment_completed")
+                        
+                        # Add funds to user balance
+                        balance_result = self.balance_service.add_funds(
+                            user_id=payment.user_id,
+                            amount=payment.amount_usd,
+                            description=f"Payment completed: {payment.id}",
+                            payment_id=str(payment.id)
+                        )
+                        
+                        if balance_result.success:
+                            actions_taken.append("balance_updated")
+                        else:
+                            self.logger.error("Failed to update balance", extra={
+                                'payment_id': str(payment.id),
+                                'user_id': payment.user_id,
+                                'error': balance_result.message
+                            })
+                
+                elif new_status == 'failed' and original_status not in ['failed', 'cancelled']:
+                    # Mark payment as failed
+                    success = payment.mark_failed(
+                        reason=f"Provider status: {webhook_data.payment_status}",
+                        error_code=webhook_data.payment_status
+                    )
+                    
+                    if success:
+                        actions_taken.append("payment_failed")
+                
+                elif new_status == 'expired' and original_status not in ['failed', 'cancelled', 'expired']:
+                    # Mark payment as failed due to expiration
+                    success = payment.mark_failed(
+                        reason="Payment expired",
+                        error_code="expired"
+                    )
+                    
+                    if success:
+                        actions_taken.append("payment_expired")
+                
+                # Update provider-specific fields
+                if webhook_data.txn_id and not payment.transaction_hash:
+                    payment.transaction_hash = webhook_data.txn_id
+                    payment.save(update_fields=['transaction_hash', 'updated_at'])
+                    actions_taken.append("transaction_hash_updated")
+                
+                return True
+            
+            # Execute in transaction
+            self._execute_with_transaction(process_webhook_transaction)
+            
+            # Refresh payment
+            payment.refresh_from_db()
+            
+            self._log_operation(
+                "process_nowpayments_webhook",
+                True,
+                payment_id=str(payment.id),
+                provider_payment_id=webhook_data.payment_id,
+                status_change=f"{original_status} -> {payment.status}",
+                actions_taken=actions_taken
+            )
+            
+            return WebhookProcessingResult(
+                success=True,
+                provider='nowpayments',
+                payment_id=str(payment.id),
+                status_before=original_status,
+                status_after=payment.status,
+                actions_taken=actions_taken,
+                processed=True,
+                balance_updated='balance_updated' in actions_taken
+            )
+            
+        except Exception as e:
+            error_result = self._handle_exception(
+                "process_nowpayments_webhook", e,
+                provider_payment_id=webhook_data.payment_id if 'webhook_data' in locals() else None
+            )
+            
+            return WebhookProcessingResult(
+                success=False,
+                provider='nowpayments',
+                error_message=error_result.message,
+                processed=False
+            )
+    
+    def get_webhook_stats(self, days: int = 30) -> ServiceOperationResult:
+        """
+        Get webhook processing statistics.
+        
+        Args:
+            days: Number of days to analyze
+            
+        Returns:
+            ServiceOperationResult: Webhook statistics
+        """
+        try:
+            # This would typically query a webhook log table
+            # For now, return basic stats from payments
+            from datetime import timedelta
+            
+            since = timezone.now() - timedelta(days=days)
+            
+            # Count payments updated recently (proxy for webhook activity)
+            recent_updates = UniversalPayment.objects.filter(
+                updated_at__gte=since
+            ).exclude(
+                created_at=models.F('updated_at')  # Exclude newly created payments
+            ).count()
+            
+            # Status distribution of recent updates
+            status_distribution = UniversalPayment.objects.filter(
+                updated_at__gte=since
+            ).values('status').annotate(
+                count=models.Count('id')
+            ).order_by('-count')
+            
+            stats = {
+                'period_days': days,
+                'recent_payment_updates': recent_updates,
+                'status_distribution': list(status_distribution),
+                'generated_at': timezone.now().isoformat()
+            }
+            
+            return self._create_success_result(
+                f"Webhook statistics for {days} days",
+                stats
+            )
+            
+        except Exception as e:
+            return self._handle_exception("get_webhook_stats", e)
+    
+    def health_check(self) -> ServiceOperationResult:
+        """Perform webhook service health check."""
+        try:
+            # Check dependencies
+            payment_health = self.payment_service.health_check()
+            balance_health = self.balance_service.health_check()
+            
+            # Check recent webhook activity (payments with provider_payment_id)
+            recent_webhooks = UniversalPayment.objects.filter(
+                provider_payment_id__isnull=False,
+                updated_at__gte=timezone.now() - timezone.timedelta(hours=1)
+            ).count()
+            
+            stats = {
+                'service_name': 'WebhookService',
+                'payment_service_healthy': payment_health.success,
+                'balance_service_healthy': balance_health.success,
+                'recent_webhook_activity': recent_webhooks,
+                'supported_providers': ['nowpayments']
+            }
+            
+            overall_healthy = payment_health.success and balance_health.success
+            
+            if overall_healthy:
+                return self._create_success_result(
+                    "WebhookService is healthy",
+                    stats
+                )
+            else:
+                return self._create_error_result(
+                    "WebhookService has dependency issues",
+                    "dependency_unhealthy",
+                    stats
+                )
+                
+        except Exception as e:
+            return self._handle_exception("health_check", e)

django_cfg/apps/payments/services/integrations/__init__.py

@@ -0,0 +1,29 @@
+"""
+Integration utilities for the Universal Payment System v2.0.
+
+External service integrations and development tools.
+"""
+
+from .ngrok_service import (
+    get_webhook_url_for_provider,
+    get_all_webhook_urls,
+    get_api_base_url,
+    is_ngrok_available,
+)
+from .providers_config import (
+    get_supported_providers,
+    get_webhook_provider_info,
+    get_all_providers_info,
+    is_provider_supported,
+)
+
+__all__ = [
+    'get_webhook_url_for_provider',
+    'get_all_webhook_urls', 
+    'get_api_base_url',
+    'is_ngrok_available',
+    'get_supported_providers',
+    'get_webhook_provider_info',
+    'get_all_providers_info',
+    'is_provider_supported',
+]

django_cfg/apps/payments/services/integrations/ngrok_service.py

@@ -0,0 +1,47 @@
+"""
+Ngrok utilities for webhook development.
+
+Simple helper functions using django_ngrok module.
+"""
+
+from typing import Dict
+from .providers_config import get_supported_providers
+
+
+def get_webhook_url_for_provider(provider: str) -> str:
+    """
+    Get webhook URL for specific provider.
+    
+    Uses django_ngrok if available, otherwise localhost fallback.
+    """
+    try:
+        from django_cfg.modules.django_ngrok import get_webhook_url
+        return get_webhook_url(f"{provider}/")
+    except ImportError:
+        return f"http://localhost:8000/api/webhooks/{provider}/"
+
+
+def get_all_webhook_urls() -> Dict[str, str]:
+    """Get webhook URLs for all supported providers."""
+    return {
+        provider: get_webhook_url_for_provider(provider)
+        for provider in get_supported_providers()
+    }
+
+
+def get_api_base_url() -> str:
+    """Get API base URL (ngrok tunnel or localhost)."""
+    try:
+        from django_cfg.modules.django_ngrok import get_api_url
+        return get_api_url()
+    except ImportError:
+        return "http://localhost:8000"
+
+
+def is_ngrok_available() -> bool:
+    """Check if ngrok tunnel is available."""
+    try:
+        from django_cfg.modules.django_ngrok import get_tunnel_url
+        return get_tunnel_url() is not None
+    except ImportError:
+        return False

django_cfg/apps/payments/services/integrations/providers_config.py

@@ -0,0 +1,107 @@
+"""
+Dynamic webhook providers configuration.
+
+Uses ProviderRegistry to get available providers dynamically.
+"""
+
+from typing import Dict, Any, List
+from dataclasses import dataclass
+from ..providers.registry import get_provider_registry
+
+
+@dataclass
+class WebhookProviderInfo:
+    """Webhook information for a provider."""
+    name: str
+    display_name: str
+    signature_header: str
+    signature_algorithm: str
+    content_type: str = 'application/json'
+    icon: str = '🔌'
+
+
+# Provider webhook metadata (only what's needed for webhooks)
+WEBHOOK_METADATA = {
+    'nowpayments': WebhookProviderInfo(
+        name='nowpayments',
+        display_name='NowPayments',
+        signature_header='x-nowpayments-sig',
+        signature_algorithm='HMAC-SHA512',
+        icon='💎'
+    ),
+    # 'stripe': WebhookProviderInfo(
+    #     name='stripe',
+    #     display_name='Stripe',
+    #     signature_header='stripe-signature',
+    #     signature_algorithm='HMAC-SHA256'
+    # ),
+    # 'cryptapi': WebhookProviderInfo(
+    #     name='cryptapi',
+    #     display_name='CryptAPI',
+    #     signature_header='x-cryptapi-signature',
+    #     signature_algorithm='HMAC-SHA256'
+    # ),
+    # 'cryptomus': WebhookProviderInfo(
+    #     name='cryptomus',
+    #     display_name='Cryptomus',
+    #     signature_header='sign',
+    #     signature_algorithm='HMAC-SHA256'
+    # )
+}
+
+
+def get_supported_providers() -> List[str]:
+    """Get list of supported providers from ProviderRegistry."""
+    try:
+        registry = get_provider_registry()
+        return registry.get_available_providers()
+    except Exception:
+        # Fallback to providers with webhook metadata
+        return list(WEBHOOK_METADATA.keys())
+
+
+def get_webhook_provider_info(provider: str) -> WebhookProviderInfo:
+    """Get webhook info for a specific provider."""
+    if provider not in WEBHOOK_METADATA:
+        # Default webhook info for unknown providers
+        return WebhookProviderInfo(
+            name=provider,
+            display_name=provider.title(),
+            signature_header='signature',
+            signature_algorithm='HMAC-SHA256',
+            icon='🔌'
+        )
+    return WEBHOOK_METADATA[provider]
+
+
+def get_signature_header(provider: str) -> str:
+    """Get signature header name for provider."""
+    return get_webhook_provider_info(provider).signature_header
+
+
+def get_signature_algorithm(provider: str) -> str:
+    """Get signature algorithm for provider."""
+    return get_webhook_provider_info(provider).signature_algorithm
+
+
+def is_provider_supported(provider: str) -> bool:
+    """Check if provider is supported (from registry)."""
+    return provider in get_supported_providers()
+
+
+def get_all_providers_info() -> Dict[str, Dict[str, Any]]:
+    """Get all providers information as dict."""
+    supported_providers = get_supported_providers()
+    
+    return {
+        name: {
+            'name': info.name,
+            'display_name': info.display_name,
+            'signature_header': info.signature_header,
+            'signature_algorithm': info.signature_algorithm,
+            'content_type': info.content_type,
+            'icon': info.icon
+        }
+        for name in supported_providers
+        for info in [get_webhook_provider_info(name)]
+    }

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

@@ -1,22 +1,17 @@
 """
-Payment provider services.
+Payment providers for the Universal Payment System v2.0.
 
-All payment provider implementations and abstractions.
+Provider implementations with unified interface and Pydantic validation.
 """
 
-from .base import PaymentProvider
-from .registry import ProviderRegistry
-from .nowpayments import NowPaymentsProvider, NowPaymentsConfig
-from .cryptapi import CryptAPIProvider, CryptAPIConfig
-from .cryptomus import CryptomusProvider, CryptomusConfig
+from .base import BaseProvider
+from .nowpayments import NowPaymentsProvider
+from .registry import ProviderRegistry, get_provider_registry, initialize_providers
 
 __all__ = [
-    'PaymentProvider',
-    'ProviderRegistry',
+    'BaseProvider',
     'NowPaymentsProvider',
-    'NowPaymentsConfig',
-    'CryptAPIProvider',
-    'CryptAPIConfig',
-    'CryptomusProvider',
-    'CryptomusConfig',
+    'ProviderRegistry',
+    'get_provider_registry',
+    'initialize_providers',
 ]