django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/payments/models/managers/balance_managers.py

@@ -6,6 +6,7 @@ Optimized querysets and managers for balance and transaction operations.
 
 from django.db import models, transaction
 from django.utils import timezone
+
 from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger("balance_managers")
@@ -17,7 +18,7 @@ class UserBalanceManager(models.Manager):
     
     Provides methods for balance management and atomic operations.
     """
-    
+
     def get_or_create_for_user(self, user):
         """
         Get or create balance for user.
@@ -32,16 +33,16 @@ class UserBalanceManager(models.Manager):
             user=user,
             defaults={'balance_usd': 0.0}
         )
-        
+
         if created:
-            logger.info(f"Created new balance for user", extra={
+            logger.info("Created new balance for user", extra={
                 'user_id': user.id,
                 'initial_balance': 0.0
             })
-        
+
         return balance
-    
-    def add_funds_to_user(self, user, amount, transaction_type='deposit', 
+
+    def add_funds_to_user(self, user, amount, transaction_type='deposit',
                          description=None, payment_id=None):
         """
         Add funds to user balance atomically (business logic in manager).
@@ -58,10 +59,10 @@ class UserBalanceManager(models.Manager):
         """
         if amount <= 0:
             raise ValueError("Amount must be positive")
-        
+
         # Get or create balance
         balance = self.get_or_create_for_user(user)
-        
+
         with transaction.atomic():
             # Update balance
             balance.balance_usd += amount
@@ -70,7 +71,7 @@ class UserBalanceManager(models.Manager):
             balance.save(update_fields=[
                 'balance_usd', 'total_deposited', 'last_transaction_at', 'updated_at'
             ])
-            
+
             # Create transaction record
             from ..balance import Transaction
             transaction_record = Transaction.objects.create(
@@ -81,20 +82,20 @@ class UserBalanceManager(models.Manager):
                 description=description or f"Added ${amount:.2f} to balance",
                 payment_id=payment_id
             )
-            
-            logger.info(f"Added funds to user balance", extra={
+
+            logger.info("Added funds to user balance", extra={
                 'user_id': user.id,
                 'amount': amount,
                 'new_balance': balance.balance_usd,
                 'transaction_id': str(transaction_record.id),
                 'payment_id': payment_id
             })
-            
+
             # Update analytics
             self.update_balance_analytics(user, amount)
-            
+
             return transaction_record
-    
+
     def subtract_funds_from_user(self, user, amount, transaction_type='withdrawal',
                                 description=None, payment_id=None):
         """
@@ -112,16 +113,16 @@ class UserBalanceManager(models.Manager):
         """
         if amount <= 0:
             raise ValueError("Amount must be positive")
-        
+
         # Get balance
         try:
             balance = self.get(user=user)
         except self.model.DoesNotExist:
             raise ValueError("User has no balance record")
-        
+
         if amount > balance.balance_usd:
             raise ValueError(f"Insufficient balance: ${balance.balance_usd:.2f} < ${amount:.2f}")
-        
+
         with transaction.atomic():
             # Update balance
             balance.balance_usd -= amount
@@ -130,7 +131,7 @@ class UserBalanceManager(models.Manager):
             balance.save(update_fields=[
                 'balance_usd', 'total_spent', 'last_transaction_at', 'updated_at'
             ])
-            
+
             # Create transaction record
             from ..balance import Transaction
             transaction_record = Transaction.objects.create(
@@ -141,20 +142,20 @@ class UserBalanceManager(models.Manager):
                 description=description or f"Subtracted ${amount:.2f} from balance",
                 payment_id=payment_id
             )
-            
-        logger.info(f"Subtracted funds from user balance", extra={
+
+        logger.info("Subtracted funds from user balance", extra={
             'user_id': user.id,
             'amount': amount,
             'new_balance': balance.balance_usd,
             'transaction_id': str(transaction_record.id),
             'payment_id': payment_id
         })
-        
+
         # Update analytics
         self.update_balance_analytics(user, -amount)
-        
+
         return transaction_record
-    
+
     def update_balance_analytics(self, user, balance_change):
         """
         Update balance analytics in cache (moved from signals).
@@ -165,43 +166,43 @@ class UserBalanceManager(models.Manager):
         """
         try:
             from django.core.cache import cache
-            
+
             user_id = user.id
-            
+
             # Update balance history
             history_key = f"balance_history:{user_id}"
             history = cache.get(history_key, [])
-            
+
             history.append({
                 'timestamp': timezone.now().isoformat(),
                 'balance': self.get_or_create_for_user(user).balance_usd,
                 'change': balance_change
             })
-            
+
             # Keep only last 100 entries
             if len(history) > 100:
                 history = history[-100:]
-            
+
             cache.set(history_key, history, timeout=86400 * 7)  # 7 days
-            
+
             # Update daily totals
             today = timezone.now().date().isoformat()
             daily_key = f"balance_changes:{user_id}:{today}"
-            
+
             daily_data = cache.get(daily_key, {'total_change': 0.0, 'transaction_count': 0})
             daily_data['total_change'] += balance_change
             daily_data['transaction_count'] += 1
-            
+
             cache.set(daily_key, daily_data, timeout=86400 * 2)  # 2 days
-            
-            logger.debug(f"Updated balance analytics", extra={
+
+            logger.debug("Updated balance analytics", extra={
                 'user_id': user_id,
                 'balance_change': balance_change,
                 'total_change_today': daily_data['total_change']
             })
-            
+
         except Exception as e:
-            logger.warning(f"Failed to update balance analytics", extra={
+            logger.warning("Failed to update balance analytics", extra={
                 'user_id': user.id,
                 'error': str(e)
             })
@@ -213,61 +214,61 @@ class TransactionQuerySet(models.QuerySet):
     
     Provides efficient queries for transaction history and analysis.
     """
-    
+
     def optimized(self):
         """Prevent N+1 queries with select_related."""
         return self.select_related('user')
-    
+
     def by_user(self, user):
         """Filter transactions by user."""
         return self.filter(user=user)
-    
+
     def by_type(self, transaction_type):
         """Filter by transaction type."""
         return self.filter(transaction_type=transaction_type)
-    
+
     def by_payment(self, payment_id):
         """Filter by related payment ID."""
         return self.filter(payment_id=payment_id)
-    
+
     # Transaction type filters
     def deposits(self):
         """Get deposit transactions (positive amounts)."""
         return self.filter(transaction_type='deposit', amount_usd__gt=0)
-    
+
     def withdrawals(self):
         """Get withdrawal transactions (negative amounts)."""
         return self.filter(transaction_type='withdrawal', amount_usd__lt=0)
-    
+
     def payments(self):
         """Get payment-related transactions."""
         return self.filter(transaction_type='payment')
-    
+
     def refunds(self):
         """Get refund transactions."""
         return self.filter(transaction_type='refund')
-    
+
     def fees(self):
         """Get fee transactions."""
         return self.filter(transaction_type='fee')
-    
+
     def bonuses(self):
         """Get bonus transactions."""
         return self.filter(transaction_type='bonus')
-    
+
     def adjustments(self):
         """Get adjustment transactions."""
         return self.filter(transaction_type='adjustment')
-    
+
     # Amount-based filters
     def credits(self):
         """Get credit transactions (positive amounts)."""
         return self.filter(amount_usd__gt=0)
-    
+
     def debits(self):
         """Get debit transactions (negative amounts)."""
         return self.filter(amount_usd__lt=0)
-    
+
     def large_amounts(self, threshold=100.0):
         """
         Get transactions above threshold amount.
@@ -276,7 +277,7 @@ class TransactionQuerySet(models.QuerySet):
             threshold: USD amount threshold (default: $100)
         """
         return self.filter(amount_usd__gte=threshold)
-    
+
     def small_amounts(self, threshold=10.0):
         """
         Get transactions below threshold amount.
@@ -285,7 +286,7 @@ class TransactionQuerySet(models.QuerySet):
             threshold: USD amount threshold (default: $10)
         """
         return self.filter(amount_usd__lte=threshold)
-    
+
     # Time-based filters
     def recent(self, hours=24):
         """
@@ -296,22 +297,22 @@ class TransactionQuerySet(models.QuerySet):
         """
         since = timezone.now() - timezone.timedelta(hours=hours)
         return self.filter(created_at__gte=since)
-    
+
     def today(self):
         """Get transactions created today."""
         today = timezone.now().date()
         return self.filter(created_at__date=today)
-    
+
     def this_week(self):
         """Get transactions from this week."""
         week_start = timezone.now().date() - timezone.timedelta(days=timezone.now().weekday())
         return self.filter(created_at__date__gte=week_start)
-    
+
     def this_month(self):
         """Get transactions from this month."""
         month_start = timezone.now().replace(day=1).date()
         return self.filter(created_at__date__gte=month_start)
-    
+
     def date_range(self, start_date, end_date):
         """
         Get transactions within date range.
@@ -321,35 +322,35 @@ class TransactionQuerySet(models.QuerySet):
             end_date: End date (inclusive)
         """
         return self.filter(created_at__date__range=[start_date, end_date])
-    
+
     # Aggregation methods
     def total_amount(self):
         """Get total amount for queryset."""
         result = self.aggregate(total=models.Sum('amount_usd'))
         return result['total'] or 0.0
-    
+
     def total_credits(self):
         """Get total credit amount."""
         result = self.credits().aggregate(total=models.Sum('amount_usd'))
         return result['total'] or 0.0
-    
+
     def total_debits(self):
         """Get total debit amount (absolute value)."""
         result = self.debits().aggregate(total=models.Sum('amount_usd'))
         return abs(result['total'] or 0.0)
-    
+
     def average_amount(self):
         """Get average transaction amount."""
         result = self.aggregate(avg=models.Avg('amount_usd'))
         return result['avg'] or 0.0
-    
+
     def count_by_type(self):
         """Get count of transactions grouped by type."""
         return self.values('transaction_type').annotate(
             count=models.Count('id'),
             total_amount=models.Sum('amount_usd')
         ).order_by('transaction_type')
-    
+
     def daily_summary(self, days=30):
         """
         Get daily transaction summary for the last N days.
@@ -374,58 +375,58 @@ class TransactionManager(models.Manager):
     
     Provides high-level methods for transaction analysis and reporting.
     """
-    
+
     def get_queryset(self):
         """Return optimized queryset by default."""
         return TransactionQuerySet(self.model, using=self._db)
-    
+
     def optimized(self):
         """Get optimized queryset."""
         return self.get_queryset().optimized()
-    
+
     # User-based methods
     def by_user(self, user):
         """Get transactions by user."""
         return self.get_queryset().by_user(user)
-    
+
     def by_type(self, transaction_type):
         """Get transactions by type."""
         return self.get_queryset().by_type(transaction_type)
-    
+
     # Transaction type methods
     def deposits(self):
         """Get deposit transactions."""
         return self.get_queryset().deposits()
-    
+
     def withdrawals(self):
         """Get withdrawal transactions."""
         return self.get_queryset().withdrawals()
-    
+
     def payments(self):
         """Get payment transactions."""
         return self.get_queryset().payments()
-    
+
     def refunds(self):
         """Get refund transactions."""
         return self.get_queryset().refunds()
-    
+
     # Time-based methods
     def recent(self, hours=24):
         """Get recent transactions."""
         return self.get_queryset().recent(hours)
-    
+
     def today(self):
         """Get today's transactions."""
         return self.get_queryset().today()
-    
+
     def this_week(self):
         """Get this week's transactions."""
         return self.get_queryset().this_week()
-    
+
     def this_month(self):
         """Get this month's transactions."""
         return self.get_queryset().this_month()
-    
+
     # Analysis methods
     def get_user_balance_history(self, user, days=30):
         """
@@ -441,10 +442,10 @@ class TransactionManager(models.Manager):
         transactions = self.by_user(user).filter(
             created_at__gte=timezone.now() - timezone.timedelta(days=days)
         ).order_by('created_at')
-        
+
         history = []
         current_balance = 0.0
-        
+
         for transaction in transactions:
             current_balance = transaction.balance_after
             history.append({
@@ -454,9 +455,9 @@ class TransactionManager(models.Manager):
                 'transaction_type': transaction.transaction_type,
                 'amount': transaction.amount_usd
             })
-        
+
         return history
-    
+
     def get_transaction_stats(self, user=None, days=30):
         """
         Get transaction statistics.
@@ -471,10 +472,10 @@ class TransactionManager(models.Manager):
         queryset = self.get_queryset()
         if user:
             queryset = queryset.by_user(user)
-        
+
         since = timezone.now() - timezone.timedelta(days=days)
         queryset = queryset.filter(created_at__gte=since)
-        
+
         stats = {
             'total_transactions': queryset.count(),
             'total_amount': queryset.total_amount(),
@@ -487,16 +488,16 @@ class TransactionManager(models.Manager):
             'payments_count': queryset.payments().count(),
             'refunds_count': queryset.refunds().count(),
         }
-        
+
         logger.info(f"Generated transaction stats for {days} days", extra={
             'user_id': user.id if user else None,
             'days': days,
             'total_transactions': stats['total_transactions'],
             'total_amount': stats['total_amount']
         })
-        
+
         return stats
-    
+
     def get_daily_summary(self, days=30):
         """
         Get daily transaction summary.
@@ -508,7 +509,7 @@ class TransactionManager(models.Manager):
             QuerySet: Daily summary data
         """
         return self.get_queryset().daily_summary(days)
-    
+
     def create_deposit(self, user, amount, description=None, payment_id=None, metadata=None):
         """
         Create a deposit transaction.
@@ -525,11 +526,11 @@ class TransactionManager(models.Manager):
         """
         if amount <= 0:
             raise ValueError("Deposit amount must be positive")
-        
+
         # Get or create user balance
         from ..balance import UserBalance
         balance = UserBalance.get_or_create_for_user(user)
-        
+
         # Create transaction via balance method (ensures atomicity)
         transaction = balance.add_funds(
             amount=amount,
@@ -537,21 +538,21 @@ class TransactionManager(models.Manager):
             description=description or f"Deposit of ${amount:.2f}",
             payment_id=payment_id
         )
-        
+
         # Add metadata if provided
         if metadata:
             transaction.metadata = metadata
             transaction.save(update_fields=['metadata'])
-        
-        logger.info(f"Created deposit transaction", extra={
+
+        logger.info("Created deposit transaction", extra={
             'user_id': user.id,
             'amount': amount,
             'transaction_id': str(transaction.id),
             'payment_id': payment_id
         })
-        
+
         return transaction
-    
+
     def create_withdrawal(self, user, amount, description=None, payment_id=None, metadata=None):
         """
         Create a withdrawal transaction.
@@ -568,14 +569,14 @@ class TransactionManager(models.Manager):
         """
         if amount <= 0:
             raise ValueError("Withdrawal amount must be positive")
-        
+
         # Get user balance
         from ..balance import UserBalance
         try:
             balance = UserBalance.objects.get(user=user)
         except UserBalance.DoesNotExist:
             raise ValueError("User has no balance record")
-        
+
         # Create transaction via balance method (ensures atomicity)
         transaction = balance.subtract_funds(
             amount=amount,
@@ -583,17 +584,17 @@ class TransactionManager(models.Manager):
             description=description or f"Withdrawal of ${amount:.2f}",
             payment_id=payment_id
         )
-        
+
         # Add metadata if provided
         if metadata:
             transaction.metadata = metadata
             transaction.save(update_fields=['metadata'])
-        
-        logger.info(f"Created withdrawal transaction", extra={
+
+        logger.info("Created withdrawal transaction", extra={
             'user_id': user.id,
             'amount': amount,
             'transaction_id': str(transaction.id),
             'payment_id': payment_id
         })
-        
+
         return transaction