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

django_cfg/apps/payments/services/types/webhooks.py

@@ -0,0 +1,232 @@
+"""
+Webhook types for the Universal Payment System v2.0.
+
+Pydantic models for webhook validation and processing.
+"""
+
+from decimal import Decimal
+from typing import Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from datetime import datetime, timedelta
+
+
+class WebhookData(BaseModel):
+    """Base webhook data structure."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    provider: str = Field(description="Provider name")
+    payment_id: str = Field(description="Payment ID")
+    status: str = Field(description="Payment status")
+    timestamp: datetime = Field(description="Webhook timestamp")
+    signature: Optional[str] = Field(None, description="Webhook signature")
+    raw_payload: Dict[str, Any] = Field(description="Raw webhook payload")
+
+
+class NowPaymentsWebhook(BaseModel):
+    """
+    NowPayments webhook structure.
+    
+    Based on NowPayments IPN (Instant Payment Notification) format.
+    """
+    model_config = ConfigDict(validate_assignment=True, extra="allow")
+    
+    # Required fields from NowPayments
+    payment_id: str = Field(description="NowPayments payment ID")
+    payment_status: Literal[
+        'waiting', 'confirming', 'confirmed', 'sending', 'partially_paid', 
+        'finished', 'failed', 'refunded', 'expired'
+    ] = Field(description="Payment status")
+    pay_address: str = Field(description="Payment address")
+    price_amount: Decimal = Field(description="Original price amount")
+    price_currency: str = Field(description="Original price currency (USD)")
+    pay_amount: Decimal = Field(description="Amount to pay in crypto")
+    pay_currency: str = Field(description="Cryptocurrency code")
+    order_id: Optional[str] = Field(None, description="Order ID")
+    order_description: Optional[str] = Field(None, description="Order description")
+    
+    # Optional fields
+    actually_paid: Optional[Decimal] = Field(None, description="Actually paid amount")
+    outcome_amount: Optional[Decimal] = Field(None, description="Outcome amount")
+    outcome_currency: Optional[str] = Field(None, description="Outcome currency")
+    
+    # Network information
+    network: Optional[str] = Field(None, description="Blockchain network")
+    txn_id: Optional[str] = Field(None, description="Transaction ID")
+    
+    # Timestamps
+    created_at: Optional[datetime] = Field(None, description="Creation timestamp")
+    updated_at: Optional[datetime] = Field(None, description="Update timestamp")
+    
+    # Additional data
+    purchase_id: Optional[str] = Field(None, description="Purchase ID")
+    smart_contract: Optional[str] = Field(None, description="Smart contract address")
+    burning_percent: Optional[str] = Field(None, description="Burning percentage")
+    
+    @field_validator('payment_status')
+    @classmethod
+    def validate_status(cls, v: str) -> str:
+        """Validate payment status."""
+        valid_statuses = [
+            'waiting', 'confirming', 'confirmed', 'sending', 'partially_paid',
+            'finished', 'failed', 'refunded', 'expired'
+        ]
+        if v not in valid_statuses:
+            raise ValueError(f"Invalid payment status: {v}")
+        return v
+    
+    @field_validator('price_currency')
+    @classmethod
+    def validate_price_currency(cls, v: str) -> str:
+        """Validate price currency is USD."""
+        if v.upper() != 'USD':
+            raise ValueError("Price currency must be USD")
+        return v.upper()
+    
+    def to_universal_status(self) -> str:
+        """Convert NowPayments status to universal payment status."""
+        status_mapping = {
+            'waiting': 'pending',
+            'confirming': 'confirming',
+            'confirmed': 'confirmed',
+            'sending': 'processing',
+            'partially_paid': 'partial',
+            'finished': 'completed',
+            'failed': 'failed',
+            'refunded': 'refunded',
+            'expired': 'expired'
+        }
+        return status_mapping.get(self.payment_status, 'unknown')
+    
+    def is_final_status(self) -> bool:
+        """Check if payment status is final."""
+        final_statuses = ['finished', 'failed', 'refunded', 'expired']
+        return self.payment_status in final_statuses
+    
+    def is_successful(self) -> bool:
+        """Check if payment is successful."""
+        return self.payment_status == 'finished'
+
+
+class WebhookProcessingResult(BaseModel):
+    """Result of webhook processing."""
+    model_config = ConfigDict(validate_assignment=True)
+    
+    success: bool = Field(description="Processing success")
+    webhook_id: Optional[str] = Field(None, description="Webhook ID")
+    payment_id: Optional[str] = Field(None, description="Related payment ID")
+    provider: str = Field(description="Provider name")
+    status_before: Optional[str] = Field(None, description="Status before processing")
+    status_after: Optional[str] = Field(None, description="Status after processing")
+    actions_taken: list[str] = Field(default_factory=list, description="Actions performed")
+    balance_updated: bool = Field(default=False, description="Whether balance was updated")
+    notifications_sent: list[str] = Field(default_factory=list, description="Notifications sent")
+    error_message: Optional[str] = Field(None, description="Error message if failed")
+    processing_time_ms: Optional[int] = Field(None, description="Processing time in milliseconds")
+    processed: bool = Field(default=False, description="Whether webhook was processed")
+    timestamp: datetime = Field(default_factory=datetime.utcnow, description="Processing timestamp")
+
+
+class WebhookValidationResult(BaseModel):
+    """Result of webhook validation."""
+    model_config = ConfigDict(validate_assignment=True)
+    
+    is_valid: bool = Field(description="Validation result")
+    provider: str = Field(description="Provider name")
+    signature_valid: Optional[bool] = Field(None, description="Signature validation result")
+    payload_valid: bool = Field(description="Payload validation result")
+    error_message: Optional[str] = Field(None, description="Validation error message")
+    parsed_data: Optional[Dict[str, Any]] = Field(None, description="Parsed webhook data")
+
+
+class WebhookSignature(BaseModel):
+    """Webhook signature validation data."""
+    model_config = ConfigDict(validate_assignment=True)
+    
+    provider: str = Field(description="Provider name")
+    signature: str = Field(description="Webhook signature")
+    payload: str = Field(description="Raw payload string")
+    secret_key: str = Field(description="Secret key for validation")
+    algorithm: str = Field(default="sha512", description="Signature algorithm")
+    
+    def validate_signature(self) -> bool:
+        """Validate webhook signature."""
+        import hmac
+        import hashlib
+        
+        if self.algorithm == "sha512":
+            expected = hmac.new(
+                self.secret_key.encode('utf-8'),
+                self.payload.encode('utf-8'),
+                hashlib.sha512
+            ).hexdigest()
+        elif self.algorithm == "sha256":
+            expected = hmac.new(
+                self.secret_key.encode('utf-8'),
+                self.payload.encode('utf-8'),
+                hashlib.sha256
+            ).hexdigest()
+        else:
+            raise ValueError(f"Unsupported algorithm: {self.algorithm}")
+        
+        return hmac.compare_digest(expected, self.signature)
+
+
+class WebhookRetry(BaseModel):
+    """Webhook retry configuration."""
+    model_config = ConfigDict(validate_assignment=True)
+    
+    webhook_id: str = Field(description="Webhook ID")
+    attempt_number: int = Field(description="Retry attempt number")
+    max_attempts: int = Field(default=3, description="Maximum retry attempts")
+    delay_seconds: int = Field(default=60, description="Delay between retries")
+    last_error: Optional[str] = Field(None, description="Last error message")
+    next_retry_at: Optional[datetime] = Field(None, description="Next retry timestamp")
+    
+    def should_retry(self) -> bool:
+        """Check if webhook should be retried."""
+        return self.attempt_number < self.max_attempts
+    
+    def calculate_next_retry(self) -> datetime:
+        """Calculate next retry timestamp with exponential backoff."""
+        import math
+        
+        # Exponential backoff: delay * (2 ^ attempt_number)
+        delay = self.delay_seconds * (2 ** self.attempt_number)
+        # Cap at 1 hour
+        delay = min(delay, 3600)
+        
+        return datetime.utcnow() + timedelta(seconds=delay)
+
+
+class WebhookEvent(BaseModel):
+    """Webhook event for logging and monitoring."""
+    model_config = ConfigDict(validate_assignment=True)
+    
+    event_id: str = Field(description="Event ID")
+    webhook_id: str = Field(description="Webhook ID")
+    provider: str = Field(description="Provider name")
+    event_type: Literal['received', 'validated', 'processed', 'failed', 'retried'] = Field(
+        description="Event type"
+    )
+    payment_id: Optional[str] = Field(None, description="Related payment ID")
+    status: Optional[str] = Field(None, description="Payment status")
+    message: Optional[str] = Field(None, description="Event message")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+    timestamp: datetime = Field(default_factory=datetime.utcnow, description="Event timestamp")
+    ip_address: Optional[str] = Field(None, description="Source IP address")
+    user_agent: Optional[str] = Field(None, description="User agent")
+    
+    def to_log_entry(self) -> Dict[str, Any]:
+        """Convert to structured log entry."""
+        return {
+            'event_id': self.event_id,
+            'webhook_id': self.webhook_id,
+            'provider': self.provider,
+            'event_type': self.event_type,
+            'payment_id': self.payment_id,
+            'status': self.status,
+            'message': self.message,
+            'timestamp': self.timestamp.isoformat(),
+            'ip_address': self.ip_address,
+            'metadata': self.metadata
+        }

django_cfg/apps/payments/signals/__init__.py

@@ -1,13 +1,38 @@
 """
-Universal Payment Signals.
+Optimized Signals for the Universal Payment System v2.0.
 
-Automatically imports all signal handlers when the payments app is loaded.
+Minimal signals that only handle:
+- Cache invalidation
+- Event notifications
+- Audit logging
+
+All business logic is in managers to avoid duplication.
 """
 
-from .api_key_signals import *  # noqa: F401,F403
-from .payment_signals import *  # noqa: F401,F403
-from .subscription_signals import *  # noqa: F401,F403
+from django.apps import apps
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("payment_signals")
+
+
+def register_signals():
+    """
+    Register all payment system signals.
+    
+    Called from apps.py when Django starts.
+    """
+    try:
+        # Import signal modules to register them
+        from . import payment_signals
+        from . import balance_signals
+        from . import subscription_signals
+        from . import api_key_signals
+        
+        logger.info("Payment signals registered successfully")
+        
+    except ImportError as e:
+        logger.error(f"Failed to register payment signals: {e}")
+
 
-__all__ = [
-    # Signal functions are automatically exported by Django
-]
+# Auto-register signals when module is imported
+register_signals()

django_cfg/apps/payments/signals/api_key_signals.py

@@ -1,160 +1,241 @@
 """
-🔄 Universal API Keys Auto-Creation Signals
+API Key Signals for the Universal Payment System v2.0.
 
-Automatic API key creation and management via Django signals.
-Enhanced version of CarAPI signals with universal support.
+Minimal signals focused on cache invalidation and security notifications.
+Business logic stays in APIKeyManager.
 """
 
 from django.db.models.signals import post_save, post_delete, pre_save
 from django.dispatch import receiver
-from django.contrib.auth import get_user_model
-from django.db import transaction
+from django.core.cache import cache
 from django.utils import timezone
-import logging
 
 from ..models import APIKey
+from django_cfg.modules.django_logger import get_logger
 
-User = get_user_model()
-logger = logging.getLogger(__name__)
-
-
-@receiver(post_save, sender=User)
-def create_default_api_key(sender, instance, created, **kwargs):
-    """
-    Automatically create default API key for new users.
-    This ensures every user can immediately start using the API.
-    """
-    if created:
-        try:
-            with transaction.atomic():
-                import secrets
-                key_value = f"ak_{secrets.token_urlsafe(32)}"
-                
-                api_key = APIKey.objects.create(
-                    user=instance,
-                    name="Default API Key",
-                    key_value=key_value,
-                    key_prefix=key_value[:8],
-                    is_active=True
-                )
-                
-                logger.info(
-                    f"Created default API key for user {instance.email}: {api_key.key_prefix}***"
-                )
-                
-                # Optional: Send welcome email with API key info
-                # This would be handled in custom project implementations
-                # from .tasks import send_api_key_welcome_email
-                # send_api_key_welcome_email.delay(instance.id, api_key.id)
-                
-        except Exception as e:
-            logger.error(f"Failed to create default API key for user {instance.email}: {e}")
-
-
-@receiver(post_save, sender=User)
-def ensure_user_has_api_key(sender, instance, **kwargs):
-    """
-    Ensure user always has at least one API key.
-    Creates one if user has no active keys.
-    """
-    # Skip if this is a new user (handled by create_default_api_key)
-    if kwargs.get('created', False):
-        return
-    
-    # Check if user has any active keys
-    if not APIKey.objects.filter(user=instance, is_active=True).exists():
-        try:
-            with transaction.atomic():
-                import secrets
-                key_value = f"ak_{secrets.token_urlsafe(32)}"
-                
-                api_key = APIKey.objects.create(
-                    user=instance,
-                    name="Recovery API Key",
-                    key_value=key_value,
-                    key_prefix=key_value[:8],
-                    is_active=True
-                )
-                logger.info(
-                    f"Created recovery API key for user {instance.email}: {api_key.key_prefix}***"
-                )
-        except Exception as e:
-            logger.error(f"Failed to create recovery API key for user {instance.email}: {e}")
+logger = get_logger("api_key_signals")
 
 
 @receiver(pre_save, sender=APIKey)
-def store_original_status(sender, instance, **kwargs):
-    """Store original status for change detection."""
+def store_original_api_key_data(sender, instance: APIKey, **kwargs):
+    """Store original API key data for change detection."""
     if instance.pk:
         try:
-            old_instance = APIKey.objects.get(pk=instance.pk)
-            instance._original_is_active = old_instance.is_active
+            original = APIKey.objects.get(pk=instance.pk)
+            instance._original_is_active = original.is_active
+            instance._original_total_requests = original.total_requests
         except APIKey.DoesNotExist:
             instance._original_is_active = None
+            instance._original_total_requests = None
+    else:
+        instance._original_is_active = None
+        instance._original_total_requests = None
 
 
 @receiver(post_save, sender=APIKey)
-def log_api_key_changes(sender, instance, created, **kwargs):
-    """Log API key creation and status changes for security monitoring."""
+def handle_api_key_changes(sender, instance: APIKey, created: bool, **kwargs):
+    """
+    Handle API key changes - only cache clearing and security notifications.
+    
+    Business logic (usage tracking, validation) stays in managers.
+    """
     if created:
-        logger.info(
-            f"New API key created: {instance.name} ({instance.key_prefix}***) "
-            f"for user {instance.user.email}"
+        logger.info(f"New API key created", extra={
+            'api_key_id': str(instance.id),
+            'user_id': instance.user.id,
+            'name': instance.name,
+            'expires_at': instance.expires_at.isoformat() if instance.expires_at else None
+        })
+        
+        # Set creation notification in cache
+        cache.set(
+            f"api_key_created:{instance.user.id}:{instance.id}",
+            {
+                'api_key_id': str(instance.id),
+                'name': instance.name,
+                'timestamp': timezone.now().isoformat()
+            },
+            timeout=86400  # 24 hours
         )
+        
     else:
-        # Check if status changed
+        # Check for status changes
         if hasattr(instance, '_original_is_active'):
-            old_status = instance._original_is_active
-            new_status = instance.is_active
+            old_active = instance._original_is_active
+            new_active = instance.is_active
             
-            if old_status is not None and old_status != new_status:
-                status_text = "activated" if new_status else "deactivated"
-                logger.warning(
-                    f"API key {status_text}: {instance.name} ({instance.key_prefix}***) "
-                    f"for user {instance.user.email}"
-                )
-
-
-@receiver(post_save, sender=APIKey)
-def update_last_used_on_activation(sender, instance, created, **kwargs):
-    """Update last_used when API key is activated."""
-    if not created and instance.is_active and hasattr(instance, '_original_is_active'):
-        if instance._original_is_active is False and instance.is_active is True:
-            # Key was just activated
-            APIKey.objects.filter(pk=instance.pk).update(
-                last_used=timezone.now()
-            )
+            if old_active != new_active:
+                if new_active:
+                    _handle_api_key_activated(instance)
+                else:
+                    _handle_api_key_deactivated(instance)
+        
+        # Check for usage increases (security monitoring)
+        if hasattr(instance, '_original_total_requests'):
+            old_requests = instance._original_total_requests or 0
+            new_requests = instance.total_requests
+            
+            if new_requests > old_requests:
+                request_increase = new_requests - old_requests
+                
+                # Log high usage increases (potential security concern)
+                if request_increase > 100:  # More than 100 requests at once
+                    logger.warning(f"High API key usage increase", extra={
+                        'api_key_id': str(instance.id),
+                        'user_id': instance.user.id,
+                        'old_requests': old_requests,
+                        'new_requests': new_requests,
+                        'increase': request_increase
+                    })
+                    
+                    _handle_high_usage_alert(instance, request_increase)
+    
+    # Clear API key-related caches
+    _clear_api_key_caches(instance)
 
 
 @receiver(post_delete, sender=APIKey)
-def log_api_key_deletion(sender, instance, **kwargs):
-    """Log API key deletions for security audit."""
-    logger.warning(
-        f"API key deleted: {instance.name} ({instance.key_prefix}***) "
-        f"for user {instance.user.email} - Status was: {'active' if instance.is_active else 'inactive'}"
+def handle_api_key_deletion(sender, instance: APIKey, **kwargs):
+    """Handle API key deletion."""
+    logger.warning(f"API key deleted", extra={
+        'api_key_id': str(instance.id),
+        'user_id': instance.user.id,
+        'name': instance.name,
+        'total_requests': instance.total_requests,
+        'deletion_timestamp': timezone.now().isoformat()
+    })
+    
+    # Set deletion notification in cache
+    cache.set(
+        f"api_key_deleted:{instance.user.id}:{instance.id}",
+        {
+            'api_key_id': str(instance.id),
+            'name': instance.name,
+            'total_requests': instance.total_requests,
+            'timestamp': timezone.now().isoformat()
+        },
+        timeout=86400 * 30  # 30 days for audit
     )
-
-
-@receiver(post_delete, sender=APIKey)
-def ensure_user_has_remaining_key(sender, instance, **kwargs):
-    """
-    Ensure user still has at least one API key after deletion.
-    Creates a new one if this was the last active key.
-    """
-    user = instance.user
     
-    # Check if user has any remaining active keys
-    if not APIKey.objects.filter(user=user, is_active=True).exists():
-        try:
-            with transaction.atomic():
-                api_key = APIKey.objects.create(
-                    user=user,
-                    name="Auto Recovery API Key",
-                    is_active=True
-                )
-                logger.info(
-                    f"Created auto-recovery API key for user {user.email}: {api_key.key_prefix}*** "
-                    f"(previous key was deleted)"
-                )
-        except Exception as e:
-            logger.error(f"Failed to create auto-recovery API key for user {user.email}: {e}")
+    # Clear caches
+    _clear_api_key_caches(instance)
+
+
+# Helper functions (notifications and security monitoring only)
+
+def _handle_api_key_activated(api_key: APIKey):
+    """Handle API key activation (notification only)."""
+    try:
+        logger.info(f"API key activated", extra={
+            'api_key_id': str(api_key.id),
+            'user_id': api_key.user.id,
+            'name': api_key.name
+        })
+        
+        # Set activation notification in cache
+        cache.set(
+            f"api_key_activated:{api_key.user.id}:{api_key.id}",
+            {
+                'api_key_id': str(api_key.id),
+                'name': api_key.name,
+                'timestamp': timezone.now().isoformat()
+            },
+            timeout=86400  # 24 hours
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to handle API key activation: {e}")
+
+
+def _handle_api_key_deactivated(api_key: APIKey):
+    """Handle API key deactivation (security notification)."""
+    try:
+        logger.warning(f"API key deactivated", extra={
+            'api_key_id': str(api_key.id),
+            'user_id': api_key.user.id,
+            'name': api_key.name,
+            'total_requests': api_key.total_requests
+        })
+        
+        # Set deactivation notification in cache
+        cache.set(
+            f"api_key_deactivated:{api_key.user.id}:{api_key.id}",
+            {
+                'api_key_id': str(api_key.id),
+                'name': api_key.name,
+                'total_requests': api_key.total_requests,
+                'timestamp': timezone.now().isoformat()
+            },
+            timeout=86400 * 7  # 7 days
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to handle API key deactivation: {e}")
+
+
+def _handle_high_usage_alert(api_key: APIKey, request_increase: int):
+    """Handle high usage alert (security monitoring)."""
+    try:
+        logger.warning(f"High API key usage detected", extra={
+            'api_key_id': str(api_key.id),
+            'user_id': api_key.user.id,
+            'request_increase': request_increase,
+            'total_requests': api_key.total_requests
+        })
+        
+        # Set high usage alert in cache
+        cache.set(
+            f"high_usage_alert:{api_key.user.id}:{api_key.id}",
+            {
+                'api_key_id': str(api_key.id),
+                'request_increase': request_increase,
+                'total_requests': api_key.total_requests,
+                'timestamp': timezone.now().isoformat()
+            },
+            timeout=86400  # 24 hours
+        )
+        
+        # Check if we should temporarily disable the key (security measure)
+        if request_increase > 1000:  # More than 1000 requests at once
+            logger.critical(f"Extremely high API usage - potential abuse", extra={
+                'api_key_id': str(api_key.id),
+                'user_id': api_key.user.id,
+                'request_increase': request_increase
+            })
+            
+            # Set critical alert flag
+            cache.set(
+                f"critical_usage_alert:{api_key.user.id}:{api_key.id}",
+                {
+                    'api_key_id': str(api_key.id),
+                    'request_increase': request_increase,
+                    'timestamp': timezone.now().isoformat(),
+                    'action_required': True
+                },
+                timeout=86400 * 7  # 7 days
+            )
+        
+    except Exception as e:
+        logger.error(f"Failed to handle high usage alert: {e}")
+
+
+def _clear_api_key_caches(api_key: APIKey):
+    """Clear API key-related cache entries."""
+    try:
+        cache_keys = [
+            f"api_key_validation:{api_key.key[:10]}...",  # Partial key for security
+            f"user_api_keys:{api_key.user.id}",
+            f"api_key_stats:{api_key.user.id}",
+            f"api_key_usage:{api_key.id}",
+        ]
+        
+        cache.delete_many(cache_keys)
+        
+        logger.debug(f"Cleared API key caches", extra={
+            'api_key_id': str(api_key.id),
+            'user_id': api_key.user.id,
+            'cache_keys_cleared': len(cache_keys)
+        })
+        
+    except Exception as e:
+        logger.warning(f"Failed to clear API key caches: {e}")