django-cfg 1.2.22__py3-none-any.whl → 1.2.25__py3-none-any.whl

django_cfg/apps/payments/signals/payment_signals.py

@@ -0,0 +1,128 @@
+"""
+🔄 Universal Payment Signals
+
+Automatic payment processing and balance management via Django signals.
+"""
+
+from django.db.models.signals import post_save, pre_save
+from django.dispatch import receiver
+from django.db import transaction
+from django.utils import timezone
+import logging
+
+from ..models import UniversalPayment, UserBalance, Transaction
+from ..services.cache import SimpleCache
+from django_cfg.core.redis import RedisService
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(pre_save, sender=UniversalPayment)
+def store_original_payment_status(sender, instance, **kwargs):
+    """Store original payment status for change detection."""
+    if instance.pk:
+        try:
+            old_instance = UniversalPayment.objects.get(pk=instance.pk)
+            instance._original_status = old_instance.status
+        except UniversalPayment.DoesNotExist:
+            instance._original_status = None
+
+
+@receiver(post_save, sender=UniversalPayment)
+def process_payment_status_changes(sender, instance, created, **kwargs):
+    """Process payment status changes and update user balance."""
+    if created:
+        logger.info(f"New payment created: {instance.internal_payment_id} for user {instance.user.email}")
+        return
+    
+    # Check if status changed to completed
+    if hasattr(instance, '_original_status'):
+        old_status = instance._original_status
+        new_status = instance.status
+        
+        if old_status != new_status:
+            logger.info(
+                f"Payment status changed: {instance.internal_payment_id} "
+                f"for user {instance.user.email} - {old_status} → {new_status}"
+            )
+            
+            # Process completed payment
+            if new_status == UniversalPayment.PaymentStatus.COMPLETED and old_status != new_status:
+                _process_completed_payment(instance)
+
+
+def _process_completed_payment(payment: UniversalPayment):
+    """Process completed payment and add funds to user balance."""
+    try:
+        with transaction.atomic():
+            # Get or create user balance
+            balance, created = UserBalance.objects.get_or_create(
+                user=payment.user,
+                defaults={
+                    'amount_usd': 0,
+                    'reserved_usd': 0
+                }
+            )
+            
+            # Add funds to balance
+            old_balance = balance.amount_usd
+            balance.amount_usd += payment.amount_usd
+            balance.save()
+            
+            # Create transaction record
+            Transaction.objects.create(
+                user=payment.user,
+                transaction_type=Transaction.TransactionType.PAYMENT,
+                amount_usd=payment.amount_usd,
+                balance_before=old_balance,
+                balance_after=balance.amount_usd,
+                description=f"Payment completed: {payment.internal_payment_id}",
+                payment=payment,
+                metadata={
+                    'provider': payment.provider,
+                    'provider_payment_id': payment.provider_payment_id,
+                    'amount_usd': str(payment.amount_usd),
+                    'currency_code': payment.currency_code
+                }
+            )
+            
+            # Mark payment as processed
+            payment.processed_at = timezone.now()
+            payment.save(update_fields=['processed_at'])
+            
+            # Clear Redis cache for user
+            try:
+                redis_service = RedisService()
+                redis_service.invalidate_user_cache(payment.user.id)
+            except Exception as e:
+                logger.warning(f"Failed to clear Redis cache for user {payment.user.id}: {e}")
+            
+            logger.info(
+                f"Payment {payment.internal_payment_id} processed successfully. "
+                f"User {payment.user.email} balance: ${balance.amount_usd}"
+            )
+            
+    except Exception as e:
+        logger.error(f"Error processing completed payment {payment.internal_payment_id}: {e}")
+        raise
+
+
+@receiver(post_save, sender=UniversalPayment)
+def log_payment_webhook_data(sender, instance, created, **kwargs):
+    """Log webhook data for audit purposes."""
+    if not created and instance.webhook_data:
+        logger.info(
+            f"Webhook data received for payment {instance.internal_payment_id}: "
+            f"status={instance.status}, provider={instance.provider}"
+        )
+
+
+@receiver(post_save, sender=Transaction)
+def log_transaction_creation(sender, instance, created, **kwargs):
+    """Log transaction creation for audit trail."""
+    if created:
+        logger.info(
+            f"New transaction: {instance.transaction_type} "
+            f"${instance.amount_usd} for user {instance.user.email} "
+            f"(balance: ${instance.balance_after})"
+        )

django_cfg/apps/payments/signals/subscription_signals.py

@@ -0,0 +1,196 @@
+"""
+🔄 Universal Subscription Signals
+
+Automatic subscription management and lifecycle handling via Django signals.
+"""
+
+from django.db.models.signals import post_save, pre_save, post_delete
+from django.dispatch import receiver
+from django.db import transaction
+from django.utils import timezone
+from datetime import timedelta
+import logging
+
+from ..models import Subscription, EndpointGroup, UserBalance, Transaction
+from ..services.cache import SimpleCache
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(pre_save, sender=Subscription)
+def store_original_subscription_status(sender, instance, **kwargs):
+    """Store original subscription status for change detection."""
+    if instance.pk:
+        try:
+            old_instance = Subscription.objects.get(pk=instance.pk)
+            instance._original_status = old_instance.status
+            instance._original_expires_at = old_instance.expires_at
+        except Subscription.DoesNotExist:
+            instance._original_status = None
+            instance._original_expires_at = None
+
+
+@receiver(post_save, sender=Subscription)
+def process_subscription_status_changes(sender, instance, created, **kwargs):
+    """Process subscription status changes and handle lifecycle events."""
+    if created:
+        logger.info(
+            f"New subscription created: {instance.endpoint_group.name} "
+            f"for user {instance.user.email} (expires: {instance.expires_at})"
+        )
+        _clear_user_cache(instance.user.id)
+        return
+    
+    # Check if status changed
+    if hasattr(instance, '_original_status'):
+        old_status = instance._original_status
+        new_status = instance.status
+        
+        if old_status != new_status:
+            logger.info(
+                f"Subscription status changed: {instance.endpoint_group.name} "
+                f"for user {instance.user.email} - {old_status} → {new_status}"
+            )
+            
+            # Handle specific status changes
+            if new_status == Subscription.SubscriptionStatus.ACTIVE:
+                _handle_subscription_activation(instance)
+            elif new_status == Subscription.SubscriptionStatus.CANCELLED:
+                _handle_subscription_cancellation(instance)
+            elif new_status == Subscription.SubscriptionStatus.EXPIRED:
+                _handle_subscription_expiration(instance)
+            
+            _clear_user_cache(instance.user.id)
+
+
+@receiver(post_save, sender=Subscription)
+def handle_subscription_renewal(sender, instance, created, **kwargs):
+    """Handle subscription renewal and billing."""
+    if created or not hasattr(instance, '_original_expires_at'):
+        return
+    
+    old_expires_at = instance._original_expires_at
+    new_expires_at = instance.expires_at
+    
+    # Check if subscription was renewed (expires_at extended)
+    if old_expires_at and new_expires_at and new_expires_at > old_expires_at:
+        logger.info(
+            f"Subscription renewed: {instance.endpoint_group.name} "
+            f"for user {instance.user.email} - extended to {new_expires_at}"
+        )
+        _clear_user_cache(instance.user.id)
+
+
+@receiver(post_delete, sender=Subscription)
+def log_subscription_deletion(sender, instance, **kwargs):
+    """Log subscription deletions for audit purposes."""
+    logger.warning(
+        f"Subscription deleted: {instance.endpoint_group.name} "
+        f"for user {instance.user.email} - Status was: {instance.status}"
+    )
+    _clear_user_cache(instance.user.id)
+
+
+@receiver(post_save, sender=EndpointGroup)
+def log_endpoint_group_changes(sender, instance, created, **kwargs):
+    """Log endpoint group changes that may affect subscriptions."""
+    if created:
+        logger.info(f"New endpoint group created: {instance.name}")
+    else:
+        # Check if important fields changed
+        if instance.tracker.has_changed('is_active'):
+            logger.warning(
+                f"Endpoint group activity changed: {instance.name} "
+                f"- active: {instance.is_active}"
+            )
+            # Clear cache for all users with subscriptions to this group
+            _clear_endpoint_group_cache(instance)
+
+
+def _handle_subscription_activation(subscription: Subscription):
+    """Handle subscription activation logic."""
+    try:
+        # Reset usage counters
+        subscription.usage_current = 0
+        
+        # Set next billing date
+        if not subscription.next_billing:
+            subscription.next_billing = timezone.now() + timedelta(days=30)  # Monthly by default
+        
+        subscription.save(update_fields=['usage_current', 'next_billing'])
+        
+        logger.info(f"Subscription activated: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription activation: {e}")
+
+
+def _handle_subscription_cancellation(subscription: Subscription):
+    """Handle subscription cancellation logic."""
+    try:
+        # Mark as cancelled
+        subscription.cancelled_at = timezone.now()
+        subscription.save(update_fields=['cancelled_at'])
+        
+        logger.info(f"Subscription cancelled: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription cancellation: {e}")
+
+
+def _handle_subscription_expiration(subscription: Subscription):
+    """Handle subscription expiration logic."""
+    try:
+        # Mark as expired
+        subscription.expired_at = timezone.now()
+        subscription.save(update_fields=['expired_at'])
+        
+        logger.info(f"Subscription expired: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription expiration: {e}")
+
+
+def _clear_user_cache(user_id: int):
+    """Clear cache for specific user."""
+    try:
+        cache = SimpleCache("subscriptions")
+        cache_keys = [
+            f"access:{user_id}",
+            f"subscriptions:{user_id}",
+            f"user_summary:{user_id}",
+        ]
+        
+        for key in cache_keys:
+            cache.delete(key)
+            
+    except Exception as e:
+        logger.warning(f"Failed to clear cache for user {user_id}: {e}")
+
+
+def _clear_endpoint_group_cache(endpoint_group: EndpointGroup):
+    """Clear cache for all users with subscriptions to this endpoint group."""
+    try:
+        # Get all users with active subscriptions to this group
+        user_ids = Subscription.objects.filter(
+            endpoint_group=endpoint_group,
+            status=Subscription.SubscriptionStatus.ACTIVE
+        ).values_list('user_id', flat=True)
+        
+        for user_id in user_ids:
+            _clear_user_cache(user_id)
+            
+    except Exception as e:
+        logger.warning(f"Failed to clear cache for endpoint group {endpoint_group.name}: {e}")
+
+
+@receiver(post_save, sender=Subscription)
+def update_usage_statistics(sender, instance, created, **kwargs):
+    """Update usage statistics when subscription is modified."""
+    if not created and hasattr(instance, '_original_status'):
+        # Only update stats if usage-related fields might have changed
+        if instance.usage_current != getattr(instance, '_original_usage_current', instance.usage_current):
+            logger.debug(
+                f"Usage updated for subscription {instance.endpoint_group.name}: "
+                f"{instance.usage_current} requests"
+            )

django_cfg/apps/payments/tasks/__init__.py

@@ -0,0 +1,12 @@
+"""
+Payment Background Tasks
+
+Minimal task infrastructure for webhook processing using existing Dramatiq setup.
+Uses django-cfg task configuration from knowbase module.
+"""
+
+from .webhook_processing import process_webhook_async
+
+__all__ = [
+    'process_webhook_async',
+]

django_cfg/apps/payments/tasks/webhook_processing.py

@@ -0,0 +1,177 @@
+"""
+Webhook Processing Tasks
+
+Simple webhook processing with fallback to sync processing.
+Uses existing Dramatiq configuration and graceful degradation.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from django.db import transaction
+from django.utils import timezone
+
+# Use existing dramatiq setup
+import dramatiq
+
+from ..services.core.payment_service import PaymentService
+from ..models.events import PaymentEvent
+
+logger = logging.getLogger(__name__)
+
+
+@dramatiq.actor(
+    queue_name="payments",
+    priority=3          # High priority for webhooks
+)
+def process_webhook_async(
+    provider: str, 
+    webhook_data: dict, 
+    idempotency_key: str,
+    request_headers: Optional[dict] = None
+) -> Dict[str, Any]:
+    """
+    Process payment webhook asynchronously.
+    
+    Args:
+        provider: Payment provider name (nowpayments, cryptapi, etc.)
+        webhook_data: Raw webhook payload from provider
+        idempotency_key: Unique key to prevent duplicate processing
+        request_headers: HTTP headers for webhook validation
+        
+    Returns:
+        Processing results with success/error status
+        
+    Raises:
+        Exception: If processing fails after retries
+    """
+    start_time = timezone.now()
+    
+    try:
+        # Log task start
+        logger.info(f"🚀 Processing webhook async: {provider}, key: {idempotency_key}")
+        
+        # Check for duplicate processing
+        if _is_webhook_already_processed(idempotency_key):
+            logger.info(f"✅ Webhook already processed: {idempotency_key}")
+            return {"success": True, "message": "Already processed", "duplicate": True}
+        
+        # Process webhook
+        with transaction.atomic():
+            payment_service = PaymentService()
+            result = payment_service.process_webhook(
+                provider=provider,
+                webhook_data=webhook_data, 
+                request_headers=request_headers
+            )
+            
+            # Mark as processed
+            _mark_webhook_processed(idempotency_key, result.dict())
+            
+            processing_time = (timezone.now() - start_time).total_seconds()
+            
+            logger.info(
+                f"✅ Webhook processed successfully: {idempotency_key}, "
+                f"time: {processing_time:.2f}s"
+            )
+            
+            return {
+                "success": True,
+                "idempotency_key": idempotency_key,
+                "processing_time_seconds": processing_time,
+                "result": result.dict()
+            }
+            
+    except Exception as e:
+        processing_time = (timezone.now() - start_time).total_seconds()
+        
+        logger.error(
+            f"❌ Webhook processing failed: {idempotency_key}, "
+            f"error: {str(e)}, time: {processing_time:.2f}s"
+        )
+        
+        # Re-raise for Dramatiq retry mechanism
+        raise
+
+
+def process_webhook_with_fallback(
+    provider: str,
+    webhook_data: dict,
+    idempotency_key: str,
+    request_headers: Optional[dict] = None,
+    force_sync: bool = False
+):
+    """
+    Process webhook with automatic async/sync fallback.
+    
+    If Dramatiq is unavailable, processes synchronously.
+    If force_sync=True, skips async processing.
+    """
+    if force_sync:
+        logger.info(f"Processing webhook synchronously (forced): {provider}")
+        return _process_webhook_sync(provider, webhook_data, idempotency_key, request_headers)
+    
+    try:
+        # Try async processing
+        process_webhook_async.send(
+            provider=provider,
+            webhook_data=webhook_data,
+            idempotency_key=idempotency_key,
+            request_headers=request_headers
+        )
+        logger.info(f"Webhook queued for async processing: {idempotency_key}")
+        return {"success": True, "mode": "async", "queued": True}
+        
+    except Exception as e:
+        logger.warning(f"Async processing failed, falling back to sync: {e}")
+        return _process_webhook_sync(provider, webhook_data, idempotency_key, request_headers)
+
+
+def _process_webhook_sync(
+    provider: str,
+    webhook_data: dict,
+    idempotency_key: str,
+    request_headers: Optional[dict] = None
+):
+    """Fallback sync webhook processing."""
+    logger.info(f"Processing webhook synchronously: {provider}")
+    
+    try:
+        payment_service = PaymentService()
+        result = payment_service.process_webhook(
+            provider=provider,
+            webhook_data=webhook_data,
+            request_headers=request_headers
+        )
+        
+        _mark_webhook_processed(idempotency_key, result.dict())
+        
+        return {
+            "success": True,
+            "mode": "sync",
+            "result": result.dict()
+        }
+        
+    except Exception as e:
+        logger.error(f"Sync webhook processing failed: {e}")
+        raise
+
+
+def _is_webhook_already_processed(idempotency_key: str) -> bool:
+    """Check if webhook was already processed."""
+    return PaymentEvent.objects.filter(
+        idempotency_key=idempotency_key,
+        event_type=PaymentEvent.EventType.WEBHOOK_PROCESSED
+    ).exists()
+
+
+def _mark_webhook_processed(idempotency_key: str, result_data: dict):
+    """Mark webhook as processed."""
+    import os
+    
+    PaymentEvent.objects.create(
+        payment_id=result_data.get('payment_id', 'unknown'),
+        event_type=PaymentEvent.EventType.WEBHOOK_PROCESSED,
+        event_data=result_data,
+        idempotency_key=idempotency_key,
+        processed_by=f"worker-{os.getpid()}"
+    )

django_cfg/apps/payments/urls.py

@@ -66,13 +66,13 @@ generic_patterns = [
 
 urlpatterns = [
     # Include all router URLs
-    path('api/v1/', include(router.urls)),
+    path('', include(router.urls)),
     
     # Include nested router URLs
-    path('api/v1/', include(payments_router.urls)),
-    path('api/v1/', include(subscriptions_router.urls)),
-    path('api/v1/', include(apikeys_router.urls)),
+    path('', include(payments_router.urls)),
+    path('', include(subscriptions_router.urls)),
+    path('', include(apikeys_router.urls)),
     
     # Include generic API endpoints
-    path('api/v1/', include(generic_patterns)),
+    path('', include(generic_patterns)),
 ]

django_cfg/apps/payments/utils/__init__.py

@@ -0,0 +1,45 @@
+"""
+Utilities for universal payments.
+"""
+
+from .middleware_utils import get_client_ip, is_api_request, extract_api_key
+from .billing_utils import calculate_usage_cost, create_billing_transaction, calculate_subscription_refund, process_subscription_billing, get_billing_summary
+from .validation_utils import validate_api_key, check_subscription_access
+
+# Configuration utilities
+from .config_utils import (
+    PaymentsConfigUtil,
+    RedisConfigHelper,
+    CacheConfigHelper, 
+    ProviderConfigHelper,
+    get_payments_config,
+    is_payments_enabled,
+    is_debug_mode
+)
+
+__all__ = [
+    # Middleware utilities
+    'get_client_ip',
+    'is_api_request', 
+    'extract_api_key',
+    
+    # Billing utilities
+    'calculate_usage_cost',
+    'create_billing_transaction',
+    'calculate_subscription_refund',
+    'process_subscription_billing',
+    'get_billing_summary',
+    
+    # Validation utilities
+    'validate_api_key',
+    'check_subscription_access',
+    
+    # Configuration utilities
+    'PaymentsConfigUtil',
+    'RedisConfigHelper',
+    'CacheConfigHelper',
+    'ProviderConfigHelper', 
+    'get_payments_config',
+    'is_payments_enabled',
+    'is_debug_mode',
+]