django-cfg 1.2.23__py3-none-any.whl → 1.2.27__py3-none-any.whl

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/utils/__init__.py

@@ -3,7 +3,7 @@ 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  # TODO: Implement when needed
+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
@@ -23,9 +23,12 @@ __all__ = [
     'is_api_request', 
     'extract_api_key',
     
-    # Billing utilities (TODO: Implement when needed)
-    # 'calculate_usage_cost',
-    # 'create_billing_transaction',
+    # Billing utilities
+    'calculate_usage_cost',
+    'create_billing_transaction',
+    'calculate_subscription_refund',
+    'process_subscription_billing',
+    'get_billing_summary',
     
     # Validation utilities
     'validate_api_key',

django_cfg/apps/payments/utils/billing_utils.py

@@ -0,0 +1,342 @@
+"""
+Basic billing utilities for production use.
+
+Provides essential billing calculations and transaction management
+without over-engineering.
+"""
+
+import logging
+from typing import Dict, Any, Optional, Tuple
+from decimal import Decimal, ROUND_HALF_UP
+from datetime import datetime, timedelta
+from django.utils import timezone
+from django.db import transaction
+from django.contrib.auth import get_user_model
+
+from ..models import UserBalance, Transaction, Subscription
+
+User = get_user_model()
+logger = logging.getLogger(__name__)
+
+
+def calculate_usage_cost(
+    subscription: Subscription,
+    usage_count: int,
+    billing_period: str = 'monthly'
+) -> Decimal:
+    """
+    Calculate cost for API usage.
+    
+    Args:
+        subscription: User subscription
+        usage_count: Number of API calls
+        billing_period: Billing period (monthly/yearly)
+        
+    Returns:
+        Cost in USD
+    """
+    try:
+        endpoint_group = subscription.endpoint_group
+        
+        # Get base price
+        if billing_period == 'monthly':
+            base_price = endpoint_group.monthly_price_usd
+            limit = endpoint_group.monthly_request_limit
+        else:
+            base_price = endpoint_group.yearly_price_usd
+            limit = endpoint_group.yearly_request_limit or (endpoint_group.monthly_request_limit * 12)
+        
+        # If usage is within limit, cost is covered by subscription
+        if usage_count <= limit:
+            return Decimal('0.00')
+        
+        # Calculate overage cost
+        overage = usage_count - limit
+        overage_rate = getattr(endpoint_group, 'overage_rate_per_request', Decimal('0.01'))
+        
+        overage_cost = Decimal(overage) * overage_rate
+        
+        # Round to 2 decimal places
+        return overage_cost.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
+        
+    except Exception as e:
+        logger.error(f"Error calculating usage cost: {e}")
+        return Decimal('0.00')
+
+
+def create_billing_transaction(
+    user: User,
+    amount: Decimal,
+    transaction_type: str,
+    source: str = 'billing',
+    description: Optional[str] = None,
+    reference_id: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Tuple[bool, Optional[Transaction]]:
+    """
+    Create a billing transaction with balance update.
+    
+    Args:
+        user: User object
+        amount: Transaction amount (positive for credit, negative for debit)
+        transaction_type: Type of transaction
+        source: Source of transaction
+        description: Human-readable description
+        reference_id: External reference ID
+        metadata: Additional metadata
+        
+    Returns:
+        Tuple of (success, transaction)
+    """
+    try:
+        with transaction.atomic():
+            # Get or create user balance
+            balance, created = UserBalance.objects.get_or_create(
+                user=user,
+                currency_id=1,  # Assuming USD currency has ID 1
+                defaults={
+                    'available_amount': Decimal('0.00'),
+                    'held_amount': Decimal('0.00')
+                }
+            )
+            
+            # Check if debit is possible
+            if amount < 0 and not balance.can_debit(abs(amount)):
+                logger.warning(f"Insufficient balance for user {user.id}: {balance.available_amount} < {abs(amount)}")
+                return False, None
+            
+            # Calculate new balance
+            old_balance = balance.available_amount
+            new_balance = old_balance + amount
+            
+            # Update balance
+            balance.available_amount = new_balance
+            
+            # Update totals
+            if amount > 0:
+                balance.total_earned += amount
+            else:
+                balance.total_spent += abs(amount)
+            
+            balance.save()
+            
+            # Create transaction record
+            txn = Transaction.objects.create(
+                user=user,
+                balance=balance,
+                transaction_type=transaction_type,
+                amount=amount,
+                balance_before=old_balance,
+                balance_after=new_balance,
+                source=source,
+                description=description or f"{transaction_type} transaction",
+                reference_id=reference_id,
+                metadata=metadata or {}
+            )
+            
+            logger.info(f"Created billing transaction: {txn.id} for user {user.id}, amount: {amount}")
+            return True, txn
+            
+    except Exception as e:
+        logger.error(f"Error creating billing transaction for user {user.id}: {e}")
+        return False, None
+
+
+def calculate_subscription_refund(
+    subscription: Subscription,
+    refund_strategy: str = 'prorated',
+    cancellation_date: Optional[datetime] = None
+) -> Dict[str, Any]:
+    """
+    Calculate refund amount for cancelled subscription.
+    
+    Args:
+        subscription: Subscription to refund
+        refund_strategy: 'prorated', 'full', or 'none'
+        cancellation_date: Date of cancellation (defaults to now)
+        
+    Returns:
+        Dict with refund calculation details
+    """
+    try:
+        if not cancellation_date:
+            cancellation_date = timezone.now()
+        
+        # Get subscription details
+        start_date = subscription.starts_at
+        end_date = subscription.expires_at
+        
+        if subscription.billing_period == 'monthly':
+            original_amount = subscription.endpoint_group.monthly_price_usd
+        else:
+            original_amount = subscription.endpoint_group.yearly_price_usd
+        
+        # Calculate refund based on strategy
+        if refund_strategy == 'none':
+            refund_amount = Decimal('0.00')
+            refund_reason = "No refund policy"
+            
+        elif refund_strategy == 'full':
+            refund_amount = original_amount
+            refund_reason = "Full refund"
+            
+        elif refund_strategy == 'prorated':
+            # Calculate prorated refund
+            total_days = (end_date - start_date).days
+            used_days = (cancellation_date - start_date).days
+            remaining_days = max(0, total_days - used_days)
+            
+            if total_days > 0:
+                refund_percentage = Decimal(remaining_days) / Decimal(total_days)
+                refund_amount = (original_amount * refund_percentage).quantize(
+                    Decimal('0.01'), rounding=ROUND_HALF_UP
+                )
+            else:
+                refund_amount = Decimal('0.00')
+            
+            refund_reason = f"Prorated refund: {remaining_days}/{total_days} days remaining"
+        
+        else:
+            refund_amount = Decimal('0.00')
+            refund_reason = "Unknown refund strategy"
+        
+        return {
+            'refund_amount': refund_amount,
+            'original_amount': original_amount,
+            'refund_strategy': refund_strategy,
+            'refund_reason': refund_reason,
+            'calculation_date': cancellation_date.isoformat(),
+            'subscription_id': str(subscription.id),
+            'billing_period': subscription.billing_period
+        }
+        
+    except Exception as e:
+        logger.error(f"Error calculating refund for subscription {subscription.id}: {e}")
+        return {
+            'refund_amount': Decimal('0.00'),
+            'original_amount': Decimal('0.00'),
+            'refund_strategy': refund_strategy,
+            'refund_reason': f"Calculation error: {str(e)}",
+            'error': True
+        }
+
+
+def process_subscription_billing(subscription: Subscription) -> Dict[str, Any]:
+    """
+    Process billing for subscription renewal.
+    
+    Args:
+        subscription: Subscription to bill
+        
+    Returns:
+        Dict with billing results
+    """
+    try:
+        # Calculate billing amount
+        if subscription.billing_period == 'monthly':
+            amount = subscription.endpoint_group.monthly_price_usd
+            billing_period_days = 30
+        else:
+            amount = subscription.endpoint_group.yearly_price_usd
+            billing_period_days = 365
+        
+        # Create billing transaction
+        success, txn = create_billing_transaction(
+            user=subscription.user,
+            amount=-amount,  # Negative for debit
+            transaction_type='subscription_billing',
+            source='subscription_renewal',
+            description=f"Subscription renewal: {subscription.endpoint_group.display_name}",
+            reference_id=str(subscription.id),
+            metadata={
+                'subscription_id': str(subscription.id),
+                'billing_period': subscription.billing_period,
+                'endpoint_group': subscription.endpoint_group.name
+            }
+        )
+        
+        if success:
+            # Update subscription
+            subscription.next_billing_at = timezone.now() + timedelta(days=billing_period_days)
+            subscription.current_usage = 0  # Reset usage
+            subscription.save()
+            
+            logger.info(f"Successfully billed subscription {subscription.id} for ${amount}")
+            
+            return {
+                'success': True,
+                'amount_billed': amount,
+                'transaction_id': str(txn.id),
+                'next_billing_at': subscription.next_billing_at.isoformat()
+            }
+        else:
+            logger.warning(f"Failed to bill subscription {subscription.id}: insufficient balance")
+            
+            return {
+                'success': False,
+                'error': 'Insufficient balance',
+                'amount_required': amount,
+                'user_balance': UserBalance.objects.get(user=subscription.user).available_amount
+            }
+            
+    except Exception as e:
+        logger.error(f"Error processing subscription billing {subscription.id}: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def get_billing_summary(user: User, days: int = 30) -> Dict[str, Any]:
+    """
+    Get billing summary for user over specified period.
+    
+    Args:
+        user: User object
+        days: Number of days to include
+        
+    Returns:
+        Dict with billing summary
+    """
+    try:
+        cutoff_date = timezone.now() - timedelta(days=days)
+        
+        # Get transactions
+        transactions = Transaction.objects.filter(
+            user=user,
+            created_at__gte=cutoff_date
+        )
+        
+        # Calculate totals
+        from django.db import models
+        
+        total_credits = transactions.filter(amount__gt=0).aggregate(
+            total=models.Sum('amount')
+        )['total'] or Decimal('0.00')
+        
+        total_debits = transactions.filter(amount__lt=0).aggregate(
+            total=models.Sum('amount')
+        )['total'] or Decimal('0.00')
+        
+        # Get current balance
+        try:
+            balance = UserBalance.objects.get(user=user)
+            current_balance = balance.available_amount
+        except UserBalance.DoesNotExist:
+            current_balance = Decimal('0.00')
+        
+        return {
+            'period_days': days,
+            'total_credits': total_credits,
+            'total_debits': abs(total_debits),
+            'net_change': total_credits + total_debits,  # total_debits is negative
+            'current_balance': current_balance,
+            'transaction_count': transactions.count()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting billing summary for user {user.id}: {e}")
+        return {
+            'error': str(e),
+            'period_days': days
+        }

django_cfg/apps/payments/utils/config_utils.py

@@ -199,6 +199,8 @@ class ProviderConfigHelper(PaymentsConfigMixin):
             return True  # api_key is sufficient
         elif provider_name == 'cryptapi':
             return hasattr(provider_config, 'own_address') and provider_config.own_address
+        elif provider_name == 'cryptomus':
+            return hasattr(provider_config, 'merchant_uuid') and provider_config.merchant_uuid
         
         return True
 

django_cfg/apps/payments/views/payment_views.py

@@ -46,8 +46,46 @@ class UserPaymentViewSet(viewsets.ModelViewSet):
     def check_status(self, request, user_pk=None, pk=None):
         """Check payment status via provider API."""
         payment = self.get_object()
-        # TODO: Implement provider status check
-        return Response({'status': payment.status})
+        
+        # Import PaymentService to check status with provider
+        from ..services.core.payment_service import PaymentService
+        
+        try:
+            payment_service = PaymentService()
+            status_result = payment_service.get_payment_status(str(payment.id))
+            
+            if status_result.success:
+                # Update local payment status if it changed
+                if payment.status != status_result.status:
+                    payment.status = status_result.status
+                    payment.save(update_fields=['status', 'updated_at'])
+                
+                return Response({
+                    'payment_id': str(payment.id),
+                    'status': status_result.status,
+                    'provider_status': status_result.provider_status,
+                    'updated': payment.status != status_result.status
+                })
+            else:
+                return Response({
+                    'payment_id': str(payment.id),
+                    'status': payment.status,
+                    'error': status_result.error_message,
+                    'provider_check_failed': True
+                }, status=status.HTTP_400_BAD_REQUEST)
+                
+        except Exception as e:
+            # Log error but don't fail completely
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Payment status check failed for {payment.id}: {e}")
+            
+            return Response({
+                'payment_id': str(payment.id),
+                'status': payment.status,
+                'error': 'Status check temporarily unavailable',
+                'provider_check_failed': True
+            })
     
     @action(detail=False, methods=['get'])
     def summary(self, request, user_pk=None):