django-cfg 1.2.29__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
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-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,83 +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
-
-
-class CurrencyManager(models.Manager):
-    """Manager for Currency model with convenient query methods."""
-    
-    def active(self):
-        """Get only active currencies."""
-        return self.filter(is_active=True)
-    
-    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 active_fiat(self):
-        """Get active fiat currencies."""
-        return self.filter(currency_type='fiat', is_active=True)
-    
-    def active_crypto(self):
-        """Get active cryptocurrencies.""" 
-        return self.filter(currency_type='crypto', is_active=True)
-    
-    def by_code(self, code: str):
-        """Get currency by code (case insensitive)."""
-        return self.filter(code__iexact=code).first()
-    
-    def supported_for_payments(self, min_amount: float = None):
-        """Get currencies supported for payments."""
-        queryset = self.active()
-        if min_amount:
-            queryset = queryset.filter(min_payment_amount__lte=min_amount)
-        return queryset
-    
-    def recently_updated(self, hours: int = 24):
-        """Get currencies updated within the last N hours."""
-        threshold = timezone.now() - timedelta(hours=hours)
-        return self.filter(rate_updated_at__gte=threshold)
-    
-    def outdated(self, days: int = 7):
-        """Get currencies with outdated rates."""
-        threshold = timezone.now() - timedelta(days=days)
-        return self.filter(
-            models.Q(rate_updated_at__lt=threshold) | 
-            models.Q(rate_updated_at__isnull=True)
-        )
-    
-    def top_crypto_by_value(self, limit: int = 10):
-        """Get top cryptocurrencies by USD value."""
-        return self.active_crypto().order_by('-usd_rate')[:limit]
-    
-    def search(self, query: str):
-        """Search currencies by code or name."""
-        return self.filter(
-            models.Q(code__icontains=query) |
-            models.Q(name__icontains=query)
-        )
-
-
-class CurrencyNetworkManager(models.Manager):
-    """Manager for CurrencyNetwork model."""
-    
-    def active(self):
-        """Get only active networks."""
-        return self.filter(is_active=True)
-    
-    def for_currency(self, currency_code: str):
-        """Get networks for a specific currency."""
-        return self.filter(currency__code__iexact=currency_code)
-    
-    def active_for_currency(self, currency_code: str):
-        """Get active networks for a specific currency."""
-        return self.active().filter(currency__code__iexact=currency_code)

django_cfg/apps/payments/managers/payment_manager.py

@@ -1,44 +0,0 @@
-"""
-Payment manager for UniversalPayment model.
-"""
-
-from django.db import models
-
-
-class UniversalPaymentManager(models.Manager):
-    """Manager for UniversalPayment model."""
-    
-    def create_payment(self, user, amount_usd: float, currency_code: str, provider: str):
-        """Create a new payment."""
-        payment = self.create(
-            user=user,
-            amount_usd=amount_usd,
-            currency_code=currency_code.upper(),
-            provider=provider,
-            status=self.model.PaymentStatus.PENDING
-        )
-        return payment
-    
-    def get_pending_payments(self, user=None):
-        """Get pending payments for user or all users."""
-        queryset = self.filter(status=self.model.PaymentStatus.PENDING)
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-    
-    def get_completed_payments(self, user=None):
-        """Get completed payments for user or all users."""
-        queryset = self.filter(status=self.model.PaymentStatus.COMPLETED)
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-    
-    def get_failed_payments(self, user=None):
-        """Get failed/expired payments for user or all users."""
-        queryset = self.filter(status__in=[
-            self.model.PaymentStatus.FAILED, 
-            self.model.PaymentStatus.EXPIRED
-        ])
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset

django_cfg/apps/payments/managers/subscription_manager.py

@@ -1,37 +0,0 @@
-"""
-Subscription managers.
-"""
-
-from django.db import models
-from django.utils import timezone
-
-
-class SubscriptionManager(models.Manager):
-    """Manager for Subscription model."""
-    
-    def get_active_subscriptions(self, user=None):
-        """Get active subscriptions."""
-        queryset = self.filter(
-            status='active',
-            expires_at__gt=timezone.now()
-        )
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-    
-    def get_expired_subscriptions(self, user=None):
-        """Get expired subscriptions."""
-        queryset = self.filter(
-            expires_at__lte=timezone.now()
-        )
-        if user:
-            queryset = queryset.filter(user=user)
-        return queryset
-
-
-class EndpointGroupManager(models.Manager):
-    """Manager for EndpointGroup model."""
-    
-    def get_active_groups(self):
-        """Get active endpoint groups."""
-        return self.filter(is_active=True)

django_cfg/apps/payments/managers/tariff_manager.py

@@ -1,29 +0,0 @@
-"""
-Tariff managers.
-"""
-
-from django.db import models
-
-
-class TariffManager(models.Manager):
-    """Manager for Tariff model."""
-    
-    def get_active_tariffs(self):
-        """Get active tariffs."""
-        return self.filter(is_active=True).order_by('monthly_price')
-    
-    def get_free_tariffs(self):
-        """Get free tariffs."""
-        return self.filter(monthly_price=0, is_active=True)
-    
-    def get_paid_tariffs(self):
-        """Get paid tariffs."""
-        return self.filter(monthly_price__gt=0, is_active=True)
-
-
-class TariffEndpointGroupManager(models.Manager):
-    """Manager for TariffEndpointGroup model."""
-    
-    def get_enabled_for_tariff(self, tariff):
-        """Get enabled endpoint groups for tariff."""
-        return self.filter(tariff=tariff, is_enabled=True)

django_cfg/apps/payments/models/events.py

@@ -1,73 +0,0 @@
-"""
-Event sourcing models for the universal payments system.
-"""
-
-from django.db import models
-from .base import UUIDTimestampedModel
-
-
-class PaymentEvent(UUIDTimestampedModel):
-    """Event sourcing for payment operations - immutable audit trail."""
-    
-    class EventType(models.TextChoices):
-        PAYMENT_CREATED = 'payment_created', 'Payment Created'
-        WEBHOOK_RECEIVED = 'webhook_received', 'Webhook Received'
-        WEBHOOK_PROCESSED = 'webhook_processed', 'Webhook Processed'
-        BALANCE_UPDATED = 'balance_updated', 'Balance Updated'
-        REFUND_PROCESSED = 'refund_processed', 'Refund Processed'
-        STATUS_CHANGED = 'status_changed', 'Status Changed'
-        ERROR_OCCURRED = 'error_occurred', 'Error Occurred'
-    
-    # Event identification
-    payment_id = models.CharField(
-        max_length=255,
-        db_index=True,
-        help_text="Payment identifier"
-    )
-    event_type = models.CharField(
-        max_length=50,
-        choices=EventType.choices,
-        db_index=True,
-        help_text="Type of event"
-    )
-    sequence_number = models.PositiveBigIntegerField(
-        help_text="Sequential number per payment"
-    )
-    
-    # Event data (JSON for flexibility)
-    event_data = models.JSONField(
-        help_text="Event data payload"
-    )
-    
-    # Operational metadata
-    processed_by = models.CharField(
-        max_length=100,
-        help_text="Worker/server that processed this event"
-    )
-    correlation_id = models.CharField(
-        max_length=255,
-        null=True,
-        blank=True,
-        help_text="Correlation ID for tracing"
-    )
-    idempotency_key = models.CharField(
-        max_length=255,
-        unique=True,
-        help_text="Idempotency key to prevent duplicates"
-    )
-    
-    class Meta:
-        db_table = 'payment_events'
-        verbose_name = "Payment Event"
-        verbose_name_plural = "Payment Events"
-        indexes = [
-            models.Index(fields=['payment_id', 'sequence_number']),
-            models.Index(fields=['event_type', 'created_at']),
-            models.Index(fields=['idempotency_key']),
-            models.Index(fields=['correlation_id']),
-            models.Index(fields=['created_at']),
-        ]
-        ordering = ['sequence_number']
-    
-    def __str__(self):
-        return f"Event {self.sequence_number}: {self.event_type} for {self.payment_id}"

django_cfg/apps/payments/serializers/__init__.py

@@ -1,56 +0,0 @@
-"""
-DRF serializers for the universal payments system.
-"""
-
-from .balance import (
-    UserBalanceSerializer, TransactionSerializer, TransactionListSerializer
-)
-from .payments import (
-    UniversalPaymentSerializer, PaymentCreateSerializer, PaymentListSerializer
-)
-from .subscriptions import (
-    SubscriptionSerializer, SubscriptionCreateSerializer, SubscriptionListSerializer,
-    EndpointGroupSerializer
-)
-from .api_keys import (
-    APIKeySerializer, APIKeyCreateSerializer, APIKeyListSerializer
-)
-from .currencies import (
-    CurrencySerializer, CurrencyNetworkSerializer, CurrencyListSerializer
-)
-from .tariffs import (
-    TariffSerializer, TariffEndpointGroupSerializer, TariffListSerializer
-)
-
-__all__ = [
-    # Balance
-    'UserBalanceSerializer',
-    'TransactionSerializer',
-    'TransactionListSerializer',
-    
-    # Payments
-    'UniversalPaymentSerializer',
-    'PaymentCreateSerializer',
-    'PaymentListSerializer',
-    
-    # Subscriptions
-    'SubscriptionSerializer',
-    'SubscriptionCreateSerializer',
-    'SubscriptionListSerializer',
-    'EndpointGroupSerializer',
-    
-    # API Keys
-    'APIKeySerializer',
-    'APIKeyCreateSerializer',
-    'APIKeyListSerializer',
-    
-    # Currencies
-    'CurrencySerializer',
-    'CurrencyNetworkSerializer',
-    'CurrencyListSerializer',
-    
-    # Tariffs
-    'TariffSerializer',
-    'TariffEndpointGroupSerializer',
-    'TariffListSerializer',
-]