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

django_cfg/apps/payments/signals/balance_signals.py

@@ -0,0 +1,174 @@
+"""
+Balance Signals for the Universal Payment System v2.0.
+
+Minimal signals focused on cache invalidation and notifications.
+Business logic stays in UserBalanceManager and TransactionManager.
+"""
+
+from django.db.models.signals import post_save, post_delete, pre_save
+from django.dispatch import receiver
+from django.core.cache import cache
+from django.utils import timezone
+
+from ..models import UserBalance, Transaction
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("balance_signals")
+
+
+@receiver(pre_save, sender=UserBalance)
+def store_original_balance(sender, instance: UserBalance, **kwargs):
+    """Store original balance for change detection."""
+    if instance.pk:
+        try:
+            original = UserBalance.objects.get(pk=instance.pk)
+            instance._original_balance = original.balance_usd
+        except UserBalance.DoesNotExist:
+            instance._original_balance = None
+    else:
+        instance._original_balance = None
+
+
+@receiver(post_save, sender=UserBalance)
+def handle_balance_change(sender, instance: UserBalance, created: bool, **kwargs):
+    """
+    Handle balance changes - only cache clearing and notifications.
+    
+    Business logic (analytics, calculations) stays in managers.
+    """
+    if created:
+        logger.info(f"New balance created", extra={
+            'user_id': instance.user.id,
+            'initial_balance': instance.balance_usd
+        })
+    else:
+        # Check if balance changed
+        if hasattr(instance, '_original_balance'):
+            old_balance = instance._original_balance or 0.0
+            new_balance = instance.balance_usd
+            
+            if old_balance != new_balance:
+                balance_change = new_balance - old_balance
+                
+                logger.info(f"Balance changed", extra={
+                    'user_id': instance.user.id,
+                    'old_balance': old_balance,
+                    'new_balance': new_balance,
+                    'change_amount': balance_change
+                })
+                
+                # Check for low balance warning (notification only)
+                if new_balance < 10.0 and old_balance >= 10.0:
+                    _trigger_low_balance_warning(instance)
+                
+                # Check for zero balance (notification only)
+                if new_balance <= 0.0 and old_balance > 0.0:
+                    _handle_zero_balance(instance)
+    
+    # Clear balance-related caches
+    _clear_balance_caches(instance.user.id)
+
+
+@receiver(post_save, sender=Transaction)
+def handle_transaction_creation(sender, instance: Transaction, created: bool, **kwargs):
+    """
+    Handle transaction creation - only logging and cache clearing.
+    
+    Business logic (analytics, balance updates) stays in managers.
+    """
+    if created:
+        logger.info(f"New transaction created", extra={
+            'transaction_id': str(instance.id),
+            'user_id': instance.user.id,
+            'transaction_type': instance.transaction_type,
+            'amount': instance.amount_usd,
+            'payment_id': str(instance.payment_id) if instance.payment_id else None
+        })
+        
+        # Clear related caches
+        _clear_balance_caches(instance.user.id)
+
+
+@receiver(post_delete, sender=Transaction)
+def handle_transaction_deletion(sender, instance: Transaction, **kwargs):
+    """Handle transaction deletion (should be rare)."""
+    logger.warning(f"Transaction deleted", extra={
+        'transaction_id': str(instance.id),
+        'user_id': instance.user.id,
+        'transaction_type': instance.transaction_type,
+        'amount': instance.amount,
+        'deletion_timestamp': timezone.now().isoformat()
+    })
+    
+    # Clear caches
+    _clear_balance_caches(instance.user.id)
+
+
+# Helper functions (notifications and caching only)
+
+def _trigger_low_balance_warning(balance: UserBalance):
+    """Trigger low balance warning for user (notification only)."""
+    try:
+        logger.warning(f"Low balance warning", extra={
+            'user_id': balance.user.id,
+            'current_balance': balance.balance_usd,
+            'threshold': 10.0
+        })
+        
+        # Set warning flag in cache for frontend
+        cache.set(
+            f"low_balance_warning:{balance.user.id}",
+            {
+                'balance': balance.balance_usd,
+                'timestamp': timezone.now().isoformat(),
+                'threshold': 10.0
+            },
+            timeout=86400  # 24 hours
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to trigger low balance warning: {e}")
+
+
+def _handle_zero_balance(balance: UserBalance):
+    """Handle zero balance situation (notification only)."""
+    try:
+        logger.warning(f"Zero balance reached", extra={
+            'user_id': balance.user.id,
+            'previous_balance': getattr(balance, '_original_balance', 'unknown')
+        })
+        
+        # Set zero balance flag in cache
+        cache.set(
+            f"zero_balance:{balance.user.id}",
+            {
+                'timestamp': timezone.now().isoformat(),
+                'previous_balance': getattr(balance, '_original_balance', 0.0)
+            },
+            timeout=86400 * 7  # 7 days
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to handle zero balance: {e}")
+
+
+def _clear_balance_caches(user_id: int):
+    """Clear all balance-related cache entries for user."""
+    try:
+        cache_keys = [
+            f"user_balance:{user_id}",
+            f"user_transactions:{user_id}",
+            f"balance_summary:{user_id}",
+            f"balance_history:{user_id}",
+            f"transaction_stats:{user_id}",
+        ]
+        
+        cache.delete_many(cache_keys)
+        
+        logger.debug(f"Cleared balance caches", extra={
+            'user_id': user_id,
+            'cache_keys_cleared': len(cache_keys)
+        })
+        
+    except Exception as e:
+        logger.warning(f"Failed to clear balance caches: {e}")

django_cfg/apps/payments/signals/payment_signals.py

@@ -1,134 +1,159 @@
 """
-🔄 Universal Payment Signals
+Payment Signals for the Universal Payment System v2.0.
 
-Automatic payment processing and balance management via Django signals.
+Minimal signals focused on cache invalidation and notifications.
+Business logic stays in PaymentManager.
 """
 
 from django.db.models.signals import post_save, pre_save
 from django.dispatch import receiver
-from django.db import transaction
+from django.core.cache import cache
 from django.utils import timezone
-from django_cfg.modules.django_logger import get_logger
 
-from ..models import UniversalPayment, UserBalance, Transaction
-from ..services.cache import SimpleCache
-from django.core.cache import cache
+from ..models import UniversalPayment
+from django_cfg.modules.django_logger import get_logger
 
 logger = get_logger("payment_signals")
 
 
 @receiver(pre_save, sender=UniversalPayment)
-def store_original_payment_status(sender, instance, **kwargs):
-    """Store original payment status for change detection."""
+def store_original_status(sender, instance: UniversalPayment, **kwargs):
+    """Store original status for change detection."""
     if instance.pk:
         try:
-            old_instance = UniversalPayment.objects.get(pk=instance.pk)
-            instance._original_status = old_instance.status
+            original = UniversalPayment.objects.get(pk=instance.pk)
+            instance._original_status = original.status
         except UniversalPayment.DoesNotExist:
             instance._original_status = None
+    else:
+        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
+def handle_payment_changes(sender, instance: UniversalPayment, created: bool, **kwargs):
+    """
+    Handle payment changes - only cache clearing and notifications.
     
-    # 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}"
-            )
+    Business logic (balance updates, etc.) handled by managers.
+    """
+    if created:
+        logger.info(f"New payment created", extra={
+            'payment_id': str(instance.id),
+            'user_id': instance.user.id,
+            'amount_usd': instance.amount_usd,
+            'provider': instance.provider,
+            'status': instance.status
+        })
+    else:
+        # Check for status changes
+        if hasattr(instance, '_original_status'):
+            old_status = instance._original_status
+            new_status = instance.status
             
-            # Process completed payment
-            if new_status == UniversalPayment.PaymentStatus.COMPLETED and old_status != new_status:
-                _process_completed_payment(instance)
+            if old_status != new_status:
+                logger.info(f"Payment status changed", extra={
+                    'payment_id': str(instance.id),
+                    'user_id': instance.user.id,
+                    'old_status': old_status,
+                    'new_status': new_status
+                })
+                
+                # Handle completed payment
+                if new_status == 'completed' and old_status != 'completed':
+                    _handle_payment_completed(instance)
+                
+                # Handle failed payment
+                elif new_status in ['failed', 'expired', 'cancelled'] and old_status not in ['failed', 'expired', 'cancelled']:
+                    _handle_payment_failed(instance)
+    
+    # Clear payment-related caches
+    _clear_payment_caches(instance)
 
 
-def _process_completed_payment(payment: UniversalPayment):
-    """Process completed payment and add funds to user balance."""
+def _handle_payment_completed(payment: UniversalPayment):
+    """
+    Handle completed payment - delegate to manager for business logic.
+    """
     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:
-                # Invalidate user cache using Django cache
-                user_cache_pattern = f"payments:user:{payment.user.id}:*"
-                # Note: Django cache doesn't support pattern deletion, so we clear specific keys
-                cache.delete_many([
-                    f"payments:user:{payment.user.id}:balance",
-                    f"payments:user:{payment.user.id}:api_keys",
-                    f"payments:user:{payment.user.id}:subscriptions"
-                ])
-            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}"
-            )
-            
+        # Use manager method which has all the business logic
+        from ..models import UserBalance
+        
+        transaction_record = UserBalance.objects.add_funds_to_user(
+            user=payment.user,
+            amount=payment.amount_usd,
+            transaction_type='payment',
+            description=f"Payment completed: {payment.id}",
+            payment_id=payment.id
+        )
+        
+        # Mark payment as processed
+        payment.completed_at = timezone.now()
+        payment.save(update_fields=['completed_at', 'updated_at'])
+        
+        logger.info(f"Payment completed and processed", extra={
+            'payment_id': str(payment.id),
+            'user_id': payment.user.id,
+            'amount_usd': payment.amount_usd,
+            'transaction_id': str(transaction_record.id)
+        })
+        
     except Exception as e:
-        logger.error(f"Error processing completed payment {payment.internal_payment_id}: {e}")
-        raise
+        logger.error(f"Failed to process completed payment", extra={
+            'payment_id': str(payment.id),
+            'user_id': payment.user.id,
+            'error': str(e)
+        })
 
 
-@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}"
+def _handle_payment_failed(payment: UniversalPayment):
+    """
+    Handle failed payment - just logging and notifications.
+    """
+    try:
+        logger.warning(f"Payment failed", extra={
+            'payment_id': str(payment.id),
+            'user_id': payment.user.id,
+            'amount_usd': payment.amount_usd,
+            'status': payment.status,
+            'provider': payment.provider
+        })
+        
+        # Set failure notification in cache
+        cache.set(
+            f"payment_failed:{payment.user.id}:{payment.id}",
+            {
+                'payment_id': str(payment.id),
+                'amount_usd': payment.amount_usd,
+                'status': payment.status,
+                'timestamp': timezone.now().isoformat()
+            },
+            timeout=86400 * 7  # 7 days
         )
+        
+    except Exception as e:
+        logger.error(f"Failed to handle payment failure", extra={
+            'payment_id': str(payment.id),
+            'error': str(e)
+        })
 
 
-@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})"
-        )
+def _clear_payment_caches(payment: UniversalPayment):
+    """Clear payment-related cache entries."""
+    try:
+        cache_keys = [
+            f"user_payments:{payment.user.id}",
+            f"payment_stats:{payment.user.id}",
+            f"payment_summary:{payment.user.id}",
+            f"provider_stats:{payment.provider}",
+        ]
+        
+        cache.delete_many(cache_keys)
+        
+        logger.debug(f"Cleared payment caches", extra={
+            'payment_id': str(payment.id),
+            'user_id': payment.user.id,
+            'cache_keys_cleared': len(cache_keys)
+        })
+        
+    except Exception as e:
+        logger.warning(f"Failed to clear payment caches: {e}")