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

django_cfg/apps/payments/managers/balance_manager.py

@@ -1,361 +0,0 @@
-"""
-User balance manager with atomic operations.
-
-Following CRITICAL_REQUIREMENTS.md:
-- Atomic balance updates
-- Type safety 
-- Event sourcing
-- Proper error handling
-"""
-
-from django.db import models, transaction
-from django.utils import timezone
-from decimal import Decimal
-from typing import Optional, Dict, Any
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger("balance_manager")
-
-
-class UserBalanceManager(models.Manager):
-    """Manager for UserBalance with atomic operations."""
-    
-    def get_or_create_balance(self, user) -> 'UserBalance':
-        """Get or create user balance atomically."""
-        balance, created = self.get_or_create(
-            user=user,
-            defaults={
-                'amount_usd': Decimal('0'),
-                'reserved_usd': Decimal('0'),
-                'total_earned': Decimal('0'),
-                'total_spent': Decimal('0'),
-            }
-        )
-        
-        if created:
-            logger.info(f"Created new balance for user {user.id}")
-        
-        return balance
-    
-    def add_funds(
-        self, 
-        user,
-        amount_usd: Decimal,
-        description: str,
-        reference_id: Optional[str] = None,
-        payment=None
-    ) -> Dict[str, Any]:
-        """
-        Add funds to user balance atomically.
-        
-        Returns:
-            Dict with operation result and transaction details
-        """
-        if amount_usd <= 0:
-            raise ValueError("Amount must be positive")
-        
-        with transaction.atomic():
-            # Get or create balance with row lock
-            balance = self.select_for_update().get_or_create_balance(user)
-            
-            # Store old values for transaction record
-            old_balance = balance.amount_usd
-            old_earned = balance.total_earned
-            
-            # Update balance
-            balance.amount_usd += amount_usd
-            balance.total_earned += amount_usd
-            balance.last_transaction_at = timezone.now()
-            balance.save()
-            
-            # Create transaction record
-            from ..models.balance import Transaction
-            transaction_record = Transaction.objects.create(
-                user=user,
-                amount_usd=amount_usd,
-                transaction_type=Transaction.TypeChoices.CREDIT,
-                description=description,
-                payment=payment,
-                reference_id=reference_id,
-                balance_before=old_balance,
-                balance_after=balance.amount_usd,
-                metadata={
-                    'total_earned_before': str(old_earned),
-                    'total_earned_after': str(balance.total_earned),
-                }
-            )
-            
-            logger.info(
-                f"Added ${amount_usd} to user {user.id} balance. "
-                f"New balance: ${balance.amount_usd}"
-            )
-            
-            return {
-                'success': True,
-                'old_balance': old_balance,
-                'new_balance': balance.amount_usd,
-                'amount_added': amount_usd,
-                'transaction_id': str(transaction_record.id),
-                'balance_obj': balance
-            }
-    
-    def debit_funds(
-        self,
-        user,
-        amount_usd: Decimal,
-        description: str,
-        reference_id: Optional[str] = None,
-        allow_overdraft: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Debit funds from user balance atomically.
-        
-        Args:
-            user: User object
-            amount_usd: Amount to debit (positive value)
-            description: Transaction description
-            reference_id: Optional reference ID
-            allow_overdraft: Allow negative balance
-            
-        Returns:
-            Dict with operation result
-        """
-        if amount_usd <= 0:
-            raise ValueError("Amount must be positive")
-        
-        with transaction.atomic():
-            # Get balance with row lock
-            balance = self.select_for_update().get_or_create_balance(user)
-            
-            # Check sufficient funds
-            if not allow_overdraft and balance.amount_usd < amount_usd:
-                from ..models.exceptions import InsufficientFundsError
-                from ..models.pydantic_models import MoneyAmount
-                from ..models import CurrencyChoices
-                
-                raise InsufficientFundsError(
-                    message=f"Insufficient funds: ${balance.amount_usd} < ${amount_usd}",
-                    required_amount=MoneyAmount(amount=amount_usd, currency=CurrencyChoices.USD),
-                    available_amount=MoneyAmount(amount=balance.amount_usd, currency=CurrencyChoices.USD),
-                    user_id=user.id
-                )
-            
-            # Store old values
-            old_balance = balance.amount_usd
-            old_spent = balance.total_spent
-            
-            # Update balance
-            balance.amount_usd -= amount_usd
-            balance.total_spent += amount_usd
-            balance.last_transaction_at = timezone.now()
-            balance.save()
-            
-            # Create transaction record
-            from ..models.balance import Transaction
-            transaction_record = Transaction.objects.create(
-                user=user,
-                amount_usd=-amount_usd,  # Negative for debit
-                transaction_type=Transaction.TypeChoices.DEBIT,
-                description=description,
-                reference_id=reference_id,
-                balance_before=old_balance,
-                balance_after=balance.amount_usd,
-                metadata={
-                    'total_spent_before': str(old_spent),
-                    'total_spent_after': str(balance.total_spent),
-                    'allow_overdraft': allow_overdraft,
-                }
-            )
-            
-            logger.info(
-                f"Debited ${amount_usd} from user {user.id} balance. "
-                f"New balance: ${balance.amount_usd}"
-            )
-            
-            return {
-                'success': True,
-                'old_balance': old_balance,
-                'new_balance': balance.amount_usd,
-                'amount_debited': amount_usd,
-                'transaction_id': str(transaction_record.id),
-                'balance_obj': balance
-            }
-    
-    def hold_funds(
-        self,
-        user,
-        amount_usd: Decimal,
-        description: str,
-        reference_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Hold funds (move from available to reserved).
-        
-        Args:
-            user: User object
-            amount_usd: Amount to hold
-            description: Hold description
-            reference_id: Optional reference ID
-            
-        Returns:
-            Dict with operation result
-        """
-        if amount_usd <= 0:
-            raise ValueError("Amount must be positive")
-        
-        with transaction.atomic():
-            # Get balance with row lock
-            balance = self.select_for_update().get_or_create_balance(user)
-            
-            # Check sufficient available funds
-            if balance.amount_usd < amount_usd:
-                from ..models.exceptions import InsufficientFundsError
-                from ..models.pydantic_models import MoneyAmount
-                from ..models import CurrencyChoices
-                
-                raise InsufficientFundsError(
-                    message=f"Insufficient available funds for hold: ${balance.amount_usd} < ${amount_usd}",
-                    required_amount=MoneyAmount(amount=amount_usd, currency=CurrencyChoices.USD),
-                    available_amount=MoneyAmount(amount=balance.amount_usd, currency=CurrencyChoices.USD),
-                    user_id=user.id
-                )
-            
-            # Store old values
-            old_available = balance.amount_usd
-            old_reserved = balance.reserved_usd
-            
-            # Move funds from available to reserved
-            balance.amount_usd -= amount_usd
-            balance.reserved_usd += amount_usd
-            balance.last_transaction_at = timezone.now()
-            balance.save()
-            
-            # Create transaction record
-            from ..models.balance import Transaction
-            transaction_record = Transaction.objects.create(
-                user=user,
-                amount_usd=amount_usd,
-                transaction_type=Transaction.TypeChoices.HOLD,
-                description=description,
-                reference_id=reference_id,
-                balance_before=old_available,
-                balance_after=balance.amount_usd,
-                metadata={
-                    'reserved_before': str(old_reserved),
-                    'reserved_after': str(balance.reserved_usd),
-                    'operation': 'hold_funds',
-                }
-            )
-            
-            logger.info(
-                f"Held ${amount_usd} for user {user.id}. "
-                f"Available: ${balance.amount_usd}, Reserved: ${balance.reserved_usd}"
-            )
-            
-            return {
-                'success': True,
-                'amount_held': amount_usd,
-                'available_balance': balance.amount_usd,
-                'reserved_balance': balance.reserved_usd,
-                'transaction_id': str(transaction_record.id),
-                'balance_obj': balance
-            }
-    
-    def release_funds(
-        self,
-        user,
-        amount_usd: Decimal,
-        description: str,
-        reference_id: Optional[str] = None,
-        refund_to_available: bool = True
-    ) -> Dict[str, Any]:
-        """
-        Release held funds.
-        
-        Args:
-            user: User object
-            amount_usd: Amount to release
-            description: Release description
-            reference_id: Optional reference ID
-            refund_to_available: If True, move to available; if False, remove entirely
-            
-        Returns:
-            Dict with operation result
-        """
-        if amount_usd <= 0:
-            raise ValueError("Amount must be positive")
-        
-        with transaction.atomic():
-            # Get balance with row lock
-            balance = self.select_for_update().get_or_create_balance(user)
-            
-            # Check sufficient reserved funds
-            if balance.reserved_usd < amount_usd:
-                raise ValueError(
-                    f"Insufficient reserved funds: ${balance.reserved_usd} < ${amount_usd}"
-                )
-            
-            # Store old values
-            old_available = balance.amount_usd
-            old_reserved = balance.reserved_usd
-            
-            # Release funds
-            balance.reserved_usd -= amount_usd
-            if refund_to_available:
-                balance.amount_usd += amount_usd
-            else:
-                # Funds are consumed (e.g., for payment)
-                balance.total_spent += amount_usd
-            
-            balance.last_transaction_at = timezone.now()
-            balance.save()
-            
-            # Create transaction record
-            from ..models.balance import Transaction
-            transaction_record = Transaction.objects.create(
-                user=user,
-                amount_usd=amount_usd if refund_to_available else -amount_usd,
-                transaction_type=Transaction.TypeChoices.RELEASE,
-                description=description,
-                reference_id=reference_id,
-                balance_before=old_available,
-                balance_after=balance.amount_usd,
-                metadata={
-                    'reserved_before': str(old_reserved),
-                    'reserved_after': str(balance.reserved_usd),
-                    'refund_to_available': refund_to_available,
-                    'operation': 'release_funds',
-                }
-            )
-            
-            action = "refunded to available" if refund_to_available else "consumed"
-            logger.info(
-                f"Released ${amount_usd} for user {user.id} ({action}). "
-                f"Available: ${balance.amount_usd}, Reserved: ${balance.reserved_usd}"
-            )
-            
-            return {
-                'success': True,
-                'amount_released': amount_usd,
-                'refund_to_available': refund_to_available,
-                'available_balance': balance.amount_usd,
-                'reserved_balance': balance.reserved_usd,
-                'transaction_id': str(transaction_record.id),
-                'balance_obj': balance
-            }
-    
-    def get_balance_summary(self, user) -> Dict[str, Any]:
-        """Get comprehensive balance summary for user."""
-        balance = self.get_or_create_balance(user)
-        
-        return {
-            'user_id': user.id,
-            'available_balance': balance.amount_usd,
-            'reserved_balance': balance.reserved_usd,
-            'total_balance': balance.total_balance,
-            'total_earned': balance.total_earned,
-            'total_spent': balance.total_spent,
-            'last_transaction_at': balance.last_transaction_at,
-            'created_at': balance.created_at,
-            'updated_at': balance.updated_at,
-        }

django_cfg/apps/payments/managers/currency_manager.py

@@ -1,306 +0,0 @@
-"""
-Manager for Currency model.
-"""
-
-from django.db import models
-from django.utils import timezone
-from datetime import timedelta
-from typing import List, Optional, TYPE_CHECKING
-from decimal import Decimal
-
-from django_cfg.modules.django_logger import get_logger
-from django_cfg.modules.django_currency import convert_currency, get_exchange_rate, CurrencyError
-
-if TYPE_CHECKING:
-    from ..services.internal_types import CurrencyOptionModel
-
-logger = get_logger("currency_manager")
-
-
-class CurrencyManager(models.Manager):
-    """Manager for clean Currency model."""
-    
-    def fiat(self):
-        """Get only fiat currencies."""
-        return self.filter(currency_type='fiat')
-    
-    def crypto(self):
-        """Get only cryptocurrencies."""
-        return self.filter(currency_type='crypto')
-    
-    def by_code(self, code: str):
-        """Get currency by code (case insensitive)."""
-        return self.filter(code__iexact=code).first()
-    
-    def search(self, query: str):
-        """Search currencies by code or name."""
-        return self.filter(
-            models.Q(code__icontains=query) |
-            models.Q(name__icontains=query)
-        )
-    
-    def get_usd_rate(self, currency_code_or_instance, force_refresh: bool = False) -> float:
-        """
-        Get USD exchange rate for currency (with 24h cache).
-        
-        Args:
-            currency_code_or_instance: Currency code (e.g., 'BTC') or Currency instance
-            force_refresh: If True, skip cache and fetch fresh rate
-            
-        Returns:
-            float: 1 CURRENCY = X USD
-        """
-        try:
-            # Handle both Currency instance and string code
-            if hasattr(currency_code_or_instance, 'code'):
-                # Currency instance passed
-                currency = currency_code_or_instance
-                currency_code = currency.code
-            else:
-                # String code passed
-                currency_code = str(currency_code_or_instance).upper()
-                currency = self.filter(code=currency_code).first()
-            
-            # Return cached rate if fresh and not forcing refresh
-            if not force_refresh and currency and currency.usd_rate is not None and currency.rate_updated_at:
-                # Check if cache is still fresh (24 hours)
-                if timezone.now() - currency.rate_updated_at < timedelta(hours=24):
-                    logger.debug(f"Using cached USD rate for {currency_code}: ${float(currency.usd_rate):.8f}")
-                    return float(currency.usd_rate)
-            
-            # Cache miss, expired, or forced refresh - fetch fresh rate
-            logger.info(f"Fetching fresh USD rate for {currency_code} (force_refresh={force_refresh})")
-            rate = get_exchange_rate(currency_code, 'USD')
-            rate_decimal = Decimal(str(rate)).quantize(Decimal('0.00000001'))
-            
-            # Update cache
-            if currency:
-                currency.usd_rate = rate_decimal
-                currency.rate_updated_at = timezone.now()
-                currency.save(update_fields=['usd_rate', 'rate_updated_at'])
-                logger.info(f"Updated USD rate for {currency_code}: ${rate:.8f}")
-            else:
-                logger.warning(f"Currency {currency_code} not found in database for rate caching")
-            
-            return round(rate, 8)
-            
-        except CurrencyError as e:
-            logger.warning(f"Failed to get USD rate for {currency_code}: {e}")
-            # Return cached rate if available, even if stale
-            if currency and currency.usd_rate is not None:
-                logger.info(f"Using stale cached rate for {currency_code} due to API error")
-                return float(currency.usd_rate)
-            return 0.0
-    
-    def get_tokens_per_usd(self, currency_code: str) -> float:
-        """Get how many tokens you can buy for 1 USD."""
-        usd_rate = self.get_usd_rate(currency_code)
-        if usd_rate > 0:
-            return round(1.0 / usd_rate, 8)
-        return 0.0
-    
-    def convert_to_usd(self, amount: float, currency_code: str) -> float:
-        """Convert currency amount to USD."""
-        usd_rate = self.get_usd_rate(currency_code)
-        return round(amount * usd_rate, 2)
-    
-    def convert_from_usd(self, usd_amount: float, currency_code: str) -> float:
-        """Convert USD amount to target currency."""
-        tokens_per_usd = self.get_tokens_per_usd(currency_code)
-        return round(usd_amount * tokens_per_usd, 8)
-    
-    def get_or_create_normalized(self, code: str, defaults: dict = None):
-        """Simple get_or_create with uppercase code normalization."""
-        normalized_code = code.upper().strip() if code else ''
-        if not normalized_code:
-            raise ValueError(f"Empty currency code: '{code}'")
-        
-        creation_defaults = defaults or {}
-        creation_defaults['code'] = normalized_code
-        
-        return self.get_or_create(code__iexact=normalized_code, defaults=creation_defaults)
-
-
-class NetworkManager(models.Manager):
-    """Manager for Network model."""
-    
-    def by_code(self, code: str):
-        """Get network by code (case insensitive)."""
-        return self.filter(code__iexact=code).first()
-    
-    def get_or_create_normalized(self, code: str, defaults: dict = None):
-        """Get or create network with normalized code."""
-        normalized_code = code.lower().strip() if code else ''
-        if not normalized_code:
-            raise ValueError(f"Empty network code: '{code}'")
-        
-        creation_defaults = defaults or {}
-        creation_defaults['code'] = normalized_code
-        
-        return self.get_or_create(code__iexact=normalized_code, defaults=creation_defaults)
-
-
-class ProviderCurrencyManager(models.Manager):
-    """Manager for ProviderCurrency model."""
-    
-    def enabled(self):
-        """Get only enabled provider currencies."""
-        return self.filter(is_enabled=True)
-    
-    def for_provider(self, provider_name: str):
-        """Get currencies for specific provider."""
-        return self.filter(provider_name__iexact=provider_name)
-    
-    def for_base_currency(self, currency_code: str):
-        """Get provider currencies for base currency."""
-        return self.filter(base_currency__code__iexact=currency_code)
-    
-    def for_network(self, network_code: str):
-        """Get provider currencies for network."""
-        return self.filter(network__code__iexact=network_code)
-    
-    def enabled_for_provider(self, provider_name: str):
-        """Get enabled currencies for provider."""
-        return self.enabled().filter(provider_name__iexact=provider_name)
-    
-    def popular(self):
-        """Get popular currencies."""
-        return self.filter(is_popular=True)
-    
-    def stable(self):
-        """Get stable currencies."""
-        return self.filter(is_stable=True)
-    
-    def get_currency_options_for_provider(self, provider_name: str):
-        """
-        Get flat list of currency options for single select dropdown.
-        
-        Returns:
-            List[dict]: List of currency option dictionaries
-        """
-        provider_currencies = self.enabled_for_provider(provider_name).select_related(
-            'base_currency', 'network'
-        ).order_by('is_popular', 'is_stable', 'base_currency__code', 'network__code')
-        
-        options = []
-        for pc in provider_currencies:
-            # Create display name: "USDT (Ethereum)" or "BTC" for native currencies
-            if pc.network:
-                display_name = f"{pc.base_currency.code} ({pc.network.name})"
-            else:
-                display_name = pc.base_currency.code
-            
-            # Get exchange rates using Currency manager
-            from ..models import Currency
-            usd_rate = Currency.objects.get_usd_rate(pc.base_currency.code)
-            tokens_per_usd = Currency.objects.get_tokens_per_usd(pc.base_currency.code)
-            
-            option = {
-                'provider_currency_code': pc.provider_currency_code,
-                'display_name': display_name,
-                'base_currency_code': pc.base_currency.code,
-                'base_currency_name': pc.base_currency.name,
-                'network_code': pc.network.code if pc.network else None,
-                'network_name': pc.network.name if pc.network else None,
-                'currency_type': pc.base_currency.currency_type,
-                'is_popular': pc.is_popular,
-                'is_stable': pc.is_stable,
-                'available_for_payment': pc.available_for_payment,
-                'available_for_payout': pc.available_for_payout,
-                'min_amount': str(pc.min_amount) if pc.min_amount else None,
-                'max_amount': str(pc.max_amount) if pc.max_amount else None,
-                'logo_url': pc.logo_url,
-                # Exchange rates
-                'usd_rate': usd_rate,
-                'tokens_per_usd': tokens_per_usd
-            }
-            options.append(option)
-        
-        # Sort: popular first, then stable, then alphabetically
-        def sort_key(option):
-            return (
-                0 if option['is_popular'] else 1,     # Popular first
-                0 if option['is_stable'] else 1,      # Then stable  
-                option['base_currency_code'],         # Then by base currency
-                option['network_name'] or ''          # Then by network
-            )
-        
-        options.sort(key=sort_key)
-        return options
-    
-    def get_usd_rates_for_provider(self, provider_name: str):
-        """
-        Get USD exchange rates for all provider currencies.
-        
-        Returns:
-            dict: {provider_currency_code: {'rate': 0.0001, 'tokens_per_usd': 10000}}
-        """
-        provider_currencies = self.enabled_for_provider(provider_name).select_related('base_currency')
-        rates = {}
-        
-        for pc in provider_currencies:
-            try:
-                # Get rate: 1 BASE_CURRENCY = X USD
-                usd_rate = get_exchange_rate(pc.base_currency.code, 'USD')
-                
-                # Calculate tokens per 1 USD
-                if usd_rate > 0:
-                    tokens_per_usd = 1.0 / usd_rate
-                else:
-                    tokens_per_usd = 0.0
-                
-                rates[pc.provider_currency_code] = {
-                    'usd_rate': round(usd_rate, 8),
-                    'tokens_per_usd': round(tokens_per_usd, 2),
-                    'base_currency': pc.base_currency.code,
-                    'updated_at': timezone.now().isoformat()
-                }
-                
-            except CurrencyError as e:
-                logger.warning(f"Failed to get rate for {pc.base_currency.code}: {e}")
-                rates[pc.provider_currency_code] = {
-                    'usd_rate': 0.0,
-                    'tokens_per_usd': 0.0,
-                    'base_currency': pc.base_currency.code,
-                    'error': str(e)
-                }
-        
-        return rates
-    
-    def convert_amount(self, amount: float, from_currency_code: str, to_currency: str = 'USD'):
-        """
-        Convert amount from provider currency to target currency.
-        
-        Args:
-            amount: Amount to convert
-            from_currency_code: Provider currency code (e.g., 'USDTERC20')
-            to_currency: Target currency (default: 'USD')
-            
-        Returns:
-            dict: {'amount': converted_amount, 'rate': exchange_rate, 'from': base_currency}
-        """
-        try:
-            # Find provider currency and get base currency
-            pc = self.get(provider_currency_code=from_currency_code)
-            base_currency = pc.base_currency.code
-            
-            # Convert via base currency
-            converted_amount = convert_currency(amount, base_currency, to_currency)
-            rate = get_exchange_rate(base_currency, to_currency)
-            
-            return {
-                'amount': round(converted_amount, 2),
-                'rate': round(rate, 8),
-                'from': base_currency,
-                'to': to_currency,
-                'original_amount': amount,
-                'provider_code': from_currency_code
-            }
-            
-        except (CurrencyError, self.model.DoesNotExist) as e:
-            logger.error(f"Conversion failed for {from_currency_code}: {e}")
-            return {
-                'amount': 0.0,
-                'rate': 0.0,
-                'error': str(e)
-            }