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

django_cfg/apps/payments/services/core/balance_service.py

@@ -4,19 +4,23 @@ Balance service for the Universal Payment System v2.0.
 Handles user balance operations and transaction management.
 """
 
-from typing import Optional, Dict, Any, List
+from typing import Optional
+
 from django.contrib.auth import get_user_model
 from django.db import models
 from django.utils import timezone
 
 User = get_user_model()
 
-from .base import BaseService
+from ...models import Transaction, UserBalance
 from ..types import (
-    BalanceUpdateRequest, BalanceResult, TransactionData,
-    ServiceOperationResult, BalanceData
+    BalanceData,
+    BalanceResult,
+    BalanceUpdateRequest,
+    ServiceOperationResult,
+    TransactionData,
 )
-from ...models import UserBalance, Transaction
+from .base import BaseService
 
 
 class BalanceService(BaseService):
@@ -25,7 +29,7 @@ class BalanceService(BaseService):
     
     Handles balance operations using Pydantic validation and Django ORM managers.
     """
-    
+
     def get_user_balance(self, user_id: int) -> BalanceResult:
         """
         Get user balance, creating if doesn't exist.
@@ -38,7 +42,7 @@ class BalanceService(BaseService):
         """
         try:
             self.logger.debug("Getting user balance", extra={'user_id': user_id})
-            
+
             # Get or create user
             try:
                 user = User.objects.get(id=user_id)
@@ -48,18 +52,18 @@ class BalanceService(BaseService):
                     message=f"User {user_id} not found",
                     error_code="user_not_found"
                 )
-            
+
             # Get or create balance using manager
             balance = UserBalance.objects.get_or_create_for_user(user)
             balance_data = BalanceData.model_validate(balance)
-            
+
             self._log_operation(
                 "get_user_balance",
                 True,
                 user_id=user_id,
                 balance_usd=balance.balance_usd
             )
-            
+
             return BalanceResult(
                 success=True,
                 message="Balance retrieved successfully",
@@ -67,13 +71,13 @@ class BalanceService(BaseService):
                 balance_usd=balance.balance_usd,
                 data={'balance': balance_data.model_dump()}
             )
-            
+
         except Exception as e:
             return BalanceResult(**self._handle_exception(
                 "get_user_balance", e,
                 user_id=user_id
             ).model_dump())
-    
+
     def update_balance(self, request: BalanceUpdateRequest) -> BalanceResult:
         """
         Update user balance with transaction record.
@@ -88,13 +92,13 @@ class BalanceService(BaseService):
             # Validate request
             if isinstance(request, dict):
                 request = BalanceUpdateRequest(**request)
-            
+
             self.logger.info("Updating user balance", extra={
                 'user_id': request.user_id,
                 'amount': request.amount,
                 'transaction_type': request.transaction_type
             })
-            
+
             # Get user
             try:
                 user = User.objects.get(id=request.user_id)
@@ -104,10 +108,10 @@ class BalanceService(BaseService):
                     message=f"User {request.user_id} not found",
                     error_code="user_not_found"
                 )
-            
+
             # Get or create balance
             balance = UserBalance.objects.get_or_create_for_user(user)
-            
+
             # Check for sufficient funds if subtracting
             if request.amount < 0 and balance.balance_usd + request.amount < 0:
                 return BalanceResult(
@@ -117,7 +121,7 @@ class BalanceService(BaseService):
                     user_id=request.user_id,
                     balance_usd=balance.balance_usd
                 )
-            
+
             # Update balance using manager
             def update_balance_transaction():
                 if request.amount > 0:
@@ -135,12 +139,12 @@ class BalanceService(BaseService):
                         payment_id=request.payment_id
                     )
                 return transaction
-            
+
             transaction = self._execute_with_transaction(update_balance_transaction)
-            
+
             # Refresh balance
             balance.refresh_from_db()
-            
+
             # Convert to response data
             balance_data = BalanceData.model_validate(balance)
             transaction_data = TransactionData(
@@ -153,7 +157,7 @@ class BalanceService(BaseService):
                 metadata=transaction.metadata or {},
                 created_at=transaction.created_at
             )
-            
+
             self._log_operation(
                 "update_balance",
                 True,
@@ -162,7 +166,7 @@ class BalanceService(BaseService):
                 new_balance=balance.balance_usd,
                 transaction_id=str(transaction.id)
             )
-            
+
             return BalanceResult(
                 success=True,
                 message="Balance updated successfully",
@@ -176,17 +180,17 @@ class BalanceService(BaseService):
                     'transaction': transaction_data.model_dump()
                 }
             )
-            
+
         except Exception as e:
             return BalanceResult(**self._handle_exception(
                 "update_balance", e,
                 user_id=request.user_id if hasattr(request, 'user_id') else None
             ).model_dump())
-    
+
     def add_funds(
-        self, 
-        user_id: int, 
-        amount: float, 
+        self,
+        user_id: int,
+        amount: float,
         description: str = None,
         payment_id: str = None
     ) -> BalanceResult:
@@ -210,7 +214,7 @@ class BalanceService(BaseService):
             payment_id=payment_id
         )
         return self.update_balance(request)
-    
+
     def subtract_funds(
         self,
         user_id: int,
@@ -238,7 +242,7 @@ class BalanceService(BaseService):
             payment_id=payment_id
         )
         return self.update_balance(request)
-    
+
     def get_user_transactions(
         self,
         user_id: int,
@@ -265,32 +269,32 @@ class BalanceService(BaseService):
                 'limit': limit,
                 'offset': offset
             })
-            
+
             # Check user exists
             if not User.objects.filter(id=user_id).exists():
                 return self._create_error_result(
                     f"User {user_id} not found",
                     "user_not_found"
                 )
-            
+
             # Build query
             queryset = Transaction.objects.filter(user_id=user_id)
-            
+
             if transaction_type:
                 queryset = queryset.filter(transaction_type=transaction_type)
-            
+
             # Get total count
             total_count = queryset.count()
-            
+
             # Get transactions with pagination
             transactions = queryset.order_by('-created_at')[offset:offset + limit]
-            
+
             # Convert to data
             transaction_data = [
                 TransactionData.model_validate(transaction).model_dump()
                 for transaction in transactions
             ]
-            
+
             return self._create_success_result(
                 f"Retrieved {len(transaction_data)} transactions",
                 {
@@ -301,13 +305,13 @@ class BalanceService(BaseService):
                     'has_more': offset + limit < total_count
                 }
             )
-            
+
         except Exception as e:
             return self._handle_exception(
                 "get_user_transactions", e,
                 user_id=user_id
             )
-    
+
     def get_balance_stats(self, days: int = 30) -> ServiceOperationResult:
         """
         Get balance and transaction statistics.
@@ -320,9 +324,9 @@ class BalanceService(BaseService):
         """
         try:
             from datetime import timedelta
-            
+
             since = timezone.now() - timedelta(days=days)
-            
+
             # Balance stats
             balance_stats = UserBalance.objects.aggregate(
                 total_users=models.Count('user_id'),
@@ -334,7 +338,7 @@ class BalanceService(BaseService):
                     filter=models.Q(balance_usd__gt=0)
                 )
             )
-            
+
             # Transaction stats
             transaction_stats = Transaction.objects.filter(
                 created_at__gte=since
@@ -351,7 +355,7 @@ class BalanceService(BaseService):
                 ),
                 avg_transaction=models.Avg('amount_usd')
             )
-            
+
             # Transaction type breakdown
             type_breakdown = Transaction.objects.filter(
                 created_at__gte=since
@@ -359,7 +363,7 @@ class BalanceService(BaseService):
                 count=models.Count('id'),
                 volume=models.Sum('amount_usd')
             ).order_by('-count')
-            
+
             stats = {
                 'period_days': days,
                 'balance_stats': balance_stats,
@@ -367,15 +371,15 @@ class BalanceService(BaseService):
                 'transaction_types': list(type_breakdown),
                 'generated_at': timezone.now().isoformat()
             }
-            
+
             return self._create_success_result(
                 f"Balance statistics for {days} days",
                 stats
             )
-            
+
         except Exception as e:
             return self._handle_exception("get_balance_stats", e)
-    
+
     def transfer_funds(
         self,
         from_user_id: int,
@@ -401,32 +405,32 @@ class BalanceService(BaseService):
                     "Transfer amount must be positive",
                     "invalid_amount"
                 )
-            
+
             if from_user_id == to_user_id:
                 return self._create_error_result(
                     "Cannot transfer to same user",
                     "same_user_transfer"
                 )
-            
+
             self.logger.info("Transferring funds", extra={
                 'from_user_id': from_user_id,
                 'to_user_id': to_user_id,
                 'amount': amount
             })
-            
+
             # Check both users exist
             if not User.objects.filter(id=from_user_id).exists():
                 return self._create_error_result(
                     f"Source user {from_user_id} not found",
                     "source_user_not_found"
                 )
-            
+
             if not User.objects.filter(id=to_user_id).exists():
                 return self._create_error_result(
                     f"Destination user {to_user_id} not found",
                     "destination_user_not_found"
                 )
-            
+
             # Execute transfer in transaction
             def transfer_transaction():
                 # Subtract from source
@@ -435,29 +439,29 @@ class BalanceService(BaseService):
                     amount,
                     f"Transfer to user {to_user_id}: {description}" if description else f"Transfer to user {to_user_id}"
                 )
-                
+
                 if not subtract_result.success:
                     raise ValueError(subtract_result.message)
-                
+
                 # Add to destination
                 add_result = self.add_funds(
                     to_user_id,
                     amount,
                     f"Transfer from user {from_user_id}: {description}" if description else f"Transfer from user {from_user_id}"
                 )
-                
+
                 if not add_result.success:
                     raise ValueError(add_result.message)
-                
+
                 return {
                     'from_transaction': subtract_result.transaction_id,
                     'to_transaction': add_result.transaction_id,
                     'from_balance': subtract_result.balance_usd,
                     'to_balance': add_result.balance_usd
                 }
-            
+
             result = self._execute_with_transaction(transfer_transaction)
-            
+
             self._log_operation(
                 "transfer_funds",
                 True,
@@ -465,7 +469,7 @@ class BalanceService(BaseService):
                 to_user_id=to_user_id,
                 amount=amount
             )
-            
+
             return self._create_success_result(
                 "Funds transferred successfully",
                 {
@@ -478,7 +482,7 @@ class BalanceService(BaseService):
                     'to_balance': result['to_balance']
                 }
             )
-            
+
         except Exception as e:
             return self._handle_exception(
                 "transfer_funds", e,
@@ -486,7 +490,7 @@ class BalanceService(BaseService):
                 to_user_id=to_user_id,
                 amount=amount
             )
-    
+
     def freeze_balance(self, user_id: int, amount: float, reason: str) -> ServiceOperationResult:
         """
         Freeze part of user balance (for future implementation).
@@ -504,30 +508,30 @@ class BalanceService(BaseService):
             "Balance freezing not yet implemented",
             "not_implemented"
         )
-    
+
     def health_check(self) -> ServiceOperationResult:
         """Perform balance service health check."""
         try:
             # Check database connectivity
             balance_count = UserBalance.objects.count()
             transaction_count = Transaction.objects.count()
-            
+
             # Check for recent activity
             recent_transactions = Transaction.objects.filter(
                 created_at__gte=timezone.now() - timezone.timedelta(hours=1)
             ).count()
-            
+
             stats = {
                 'total_balances': balance_count,
                 'total_transactions': transaction_count,
                 'recent_transactions': recent_transactions,
                 'service_name': 'BalanceService'
             }
-            
+
             return self._create_success_result(
                 "BalanceService is healthy",
                 stats
             )
-            
+
         except Exception as e:
             return self._handle_exception("health_check", e)

django_cfg/apps/payments/services/core/base.py

@@ -5,12 +5,15 @@ Provides common functionality for all services.
 """
 
 from abc import ABC
-from typing import Optional, Dict, Any, Type
+from typing import Any, Dict, Optional, Type
+
 from django.db import transaction
+
 from django_cfg.modules.django_logging import get_logger
 
-from ..types import ServiceOperationResult
 from ...config.django_cfg_integration import PaymentsConfigManager
+from ..types import ServiceOperationResult
+
 
 class BaseService(ABC):
     """
@@ -18,17 +21,17 @@ class BaseService(ABC):
     
     Provides logging, error handling, and transaction management.
     """
-    
+
     def __init__(self):
         """Initialize base service."""
         self.logger = get_logger(f"services.{self.__class__.__name__.lower()}")
         self._cache = {}
-        
+
         # Initialize config manager
         self.config_manager = PaymentsConfigManager
-    
+
     def _create_success_result(
-        self, 
+        self,
         message: str = "Operation completed successfully",
         data: Optional[Dict[str, Any]] = None
     ) -> ServiceOperationResult:
@@ -38,7 +41,7 @@ class BaseService(ABC):
             message=message,
             data=data or {}
         )
-    
+
     def _create_error_result(
         self,
         message: str,
@@ -52,7 +55,7 @@ class BaseService(ABC):
             error_code=error_code,
             data=data or {}
         )
-    
+
     def _log_operation(
         self,
         operation: str,
@@ -66,12 +69,12 @@ class BaseService(ABC):
             'success': success,
             **kwargs
         }
-        
+
         if success:
             self.logger.info(f"Operation {operation} completed successfully", extra=log_data)
         else:
             self.logger.error(f"Operation {operation} failed", extra=log_data)
-    
+
     def _handle_exception(
         self,
         operation: str,
@@ -80,7 +83,7 @@ class BaseService(ABC):
     ) -> ServiceOperationResult:
         """Handle service exception."""
         error_message = f"Service error in {operation}: {str(exception)}"
-        
+
         self.logger.error(error_message, extra={
             'service': self.__class__.__name__,
             'operation': operation,
@@ -88,13 +91,13 @@ class BaseService(ABC):
             'exception_message': str(exception),
             **context
         }, exc_info=True)
-        
+
         return self._create_error_result(
             message=error_message,
             error_code=type(exception).__name__.lower(),
             data={'context': context}
         )
-    
+
     @transaction.atomic
     def _execute_with_transaction(self, operation_func, *args, **kwargs):
         """Execute operation within database transaction."""
@@ -103,7 +106,7 @@ class BaseService(ABC):
         except Exception as e:
             self.logger.error(f"Transaction rolled back due to error: {e}")
             raise
-    
+
     def _validate_input(self, data: Any, model_class: Type) -> Any:
         """Validate input data using Pydantic model."""
         try:
@@ -115,26 +118,26 @@ class BaseService(ABC):
                 return model_class.model_validate(data)
         except Exception as e:
             raise ValueError(f"Invalid input data: {e}")
-    
+
     def _get_cache_key(self, prefix: str, *args) -> str:
         """Generate cache key."""
         key_parts = [prefix] + [str(arg) for arg in args]
         return ":".join(key_parts)
-    
+
     def _cache_get(self, key: str) -> Optional[Any]:
         """Get value from cache."""
         return self._cache.get(key)
-    
+
     def _cache_set(self, key: str, value: Any, ttl: int = 300) -> None:
         """Set value in cache."""
         # Simple in-memory cache for now
         # In production, this would use Redis
         self._cache[key] = value
-    
+
     def _cache_delete(self, key: str) -> None:
         """Delete value from cache."""
         self._cache.pop(key, None)
-    
+
     def _cache_clear(self, prefix: Optional[str] = None) -> None:
         """Clear cache entries."""
         if prefix:
@@ -143,7 +146,7 @@ class BaseService(ABC):
                 del self._cache[key]
         else:
             self._cache.clear()
-    
+
     def get_service_stats(self) -> Dict[str, Any]:
         """Get service statistics."""
         return {
@@ -151,13 +154,13 @@ class BaseService(ABC):
             'cache_size': len(self._cache),
             'cache_keys': list(self._cache.keys())
         }
-    
+
     def health_check(self) -> ServiceOperationResult:
         """Perform service health check."""
         try:
             # Basic health check - can be overridden by subclasses
             stats = self.get_service_stats()
-            
+
             return self._create_success_result(
                 message=f"{self.__class__.__name__} is healthy",
                 data=stats

django_cfg/apps/payments/services/core/currency/__init__.py

@@ -4,8 +4,8 @@ Currency operations for payment service.
 Provides currency validation and conversion functionality.
 """
 
-from .currency_validator import CurrencyValidator
 from .currency_converter import CurrencyConverter
+from .currency_validator import CurrencyValidator
 
 __all__ = [
     'CurrencyValidator',

django_cfg/apps/payments/services/core/currency/currency_converter.py

@@ -5,7 +5,9 @@ Converts between USD and cryptocurrencies using exchange rates.
 """
 
 from decimal import Decimal
+
 from django_cfg.modules.django_currency import convert_currency, get_exchange_rate
+
 from ...types import ServiceOperationResult