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

django_cfg/apps/payments/utils/billing_utils.py

@@ -1,342 +0,0 @@
-"""
-Basic billing utilities for production use.
-
-Provides essential billing calculations and transaction management
-without over-engineering.
-"""
-
-import logging
-from typing import Dict, Any, Optional, Tuple
-from decimal import Decimal, ROUND_HALF_UP
-from datetime import datetime, timedelta
-from django.utils import timezone
-from django.db import transaction
-from django.contrib.auth import get_user_model
-
-from ..models import UserBalance, Transaction, Subscription
-
-User = get_user_model()
-logger = logging.getLogger(__name__)
-
-
-def calculate_usage_cost(
-    subscription: Subscription,
-    usage_count: int,
-    billing_period: str = 'monthly'
-) -> Decimal:
-    """
-    Calculate cost for API usage.
-    
-    Args:
-        subscription: User subscription
-        usage_count: Number of API calls
-        billing_period: Billing period (monthly/yearly)
-        
-    Returns:
-        Cost in USD
-    """
-    try:
-        endpoint_group = subscription.endpoint_group
-        
-        # Get base price
-        if billing_period == 'monthly':
-            base_price = endpoint_group.monthly_price_usd
-            limit = endpoint_group.monthly_request_limit
-        else:
-            base_price = endpoint_group.yearly_price_usd
-            limit = endpoint_group.yearly_request_limit or (endpoint_group.monthly_request_limit * 12)
-        
-        # If usage is within limit, cost is covered by subscription
-        if usage_count <= limit:
-            return Decimal('0.00')
-        
-        # Calculate overage cost
-        overage = usage_count - limit
-        overage_rate = getattr(endpoint_group, 'overage_rate_per_request', Decimal('0.01'))
-        
-        overage_cost = Decimal(overage) * overage_rate
-        
-        # Round to 2 decimal places
-        return overage_cost.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
-        
-    except Exception as e:
-        logger.error(f"Error calculating usage cost: {e}")
-        return Decimal('0.00')
-
-
-def create_billing_transaction(
-    user: User,
-    amount: Decimal,
-    transaction_type: str,
-    source: str = 'billing',
-    description: Optional[str] = None,
-    reference_id: Optional[str] = None,
-    metadata: Optional[Dict[str, Any]] = None
-) -> Tuple[bool, Optional[Transaction]]:
-    """
-    Create a billing transaction with balance update.
-    
-    Args:
-        user: User object
-        amount: Transaction amount (positive for credit, negative for debit)
-        transaction_type: Type of transaction
-        source: Source of transaction
-        description: Human-readable description
-        reference_id: External reference ID
-        metadata: Additional metadata
-        
-    Returns:
-        Tuple of (success, transaction)
-    """
-    try:
-        with transaction.atomic():
-            # Get or create user balance
-            balance, created = UserBalance.objects.get_or_create(
-                user=user,
-                currency_id=1,  # Assuming USD currency has ID 1
-                defaults={
-                    'available_amount': Decimal('0.00'),
-                    'held_amount': Decimal('0.00')
-                }
-            )
-            
-            # Check if debit is possible
-            if amount < 0 and not balance.can_debit(abs(amount)):
-                logger.warning(f"Insufficient balance for user {user.id}: {balance.available_amount} < {abs(amount)}")
-                return False, None
-            
-            # Calculate new balance
-            old_balance = balance.available_amount
-            new_balance = old_balance + amount
-            
-            # Update balance
-            balance.available_amount = new_balance
-            
-            # Update totals
-            if amount > 0:
-                balance.total_earned += amount
-            else:
-                balance.total_spent += abs(amount)
-            
-            balance.save()
-            
-            # Create transaction record
-            txn = Transaction.objects.create(
-                user=user,
-                balance=balance,
-                transaction_type=transaction_type,
-                amount=amount,
-                balance_before=old_balance,
-                balance_after=new_balance,
-                source=source,
-                description=description or f"{transaction_type} transaction",
-                reference_id=reference_id,
-                metadata=metadata or {}
-            )
-            
-            logger.info(f"Created billing transaction: {txn.id} for user {user.id}, amount: {amount}")
-            return True, txn
-            
-    except Exception as e:
-        logger.error(f"Error creating billing transaction for user {user.id}: {e}")
-        return False, None
-
-
-def calculate_subscription_refund(
-    subscription: Subscription,
-    refund_strategy: str = 'prorated',
-    cancellation_date: Optional[datetime] = None
-) -> Dict[str, Any]:
-    """
-    Calculate refund amount for cancelled subscription.
-    
-    Args:
-        subscription: Subscription to refund
-        refund_strategy: 'prorated', 'full', or 'none'
-        cancellation_date: Date of cancellation (defaults to now)
-        
-    Returns:
-        Dict with refund calculation details
-    """
-    try:
-        if not cancellation_date:
-            cancellation_date = timezone.now()
-        
-        # Get subscription details
-        start_date = subscription.starts_at
-        end_date = subscription.expires_at
-        
-        if subscription.billing_period == 'monthly':
-            original_amount = subscription.endpoint_group.monthly_price_usd
-        else:
-            original_amount = subscription.endpoint_group.yearly_price_usd
-        
-        # Calculate refund based on strategy
-        if refund_strategy == 'none':
-            refund_amount = Decimal('0.00')
-            refund_reason = "No refund policy"
-            
-        elif refund_strategy == 'full':
-            refund_amount = original_amount
-            refund_reason = "Full refund"
-            
-        elif refund_strategy == 'prorated':
-            # Calculate prorated refund
-            total_days = (end_date - start_date).days
-            used_days = (cancellation_date - start_date).days
-            remaining_days = max(0, total_days - used_days)
-            
-            if total_days > 0:
-                refund_percentage = Decimal(remaining_days) / Decimal(total_days)
-                refund_amount = (original_amount * refund_percentage).quantize(
-                    Decimal('0.01'), rounding=ROUND_HALF_UP
-                )
-            else:
-                refund_amount = Decimal('0.00')
-            
-            refund_reason = f"Prorated refund: {remaining_days}/{total_days} days remaining"
-        
-        else:
-            refund_amount = Decimal('0.00')
-            refund_reason = "Unknown refund strategy"
-        
-        return {
-            'refund_amount': refund_amount,
-            'original_amount': original_amount,
-            'refund_strategy': refund_strategy,
-            'refund_reason': refund_reason,
-            'calculation_date': cancellation_date.isoformat(),
-            'subscription_id': str(subscription.id),
-            'billing_period': subscription.billing_period
-        }
-        
-    except Exception as e:
-        logger.error(f"Error calculating refund for subscription {subscription.id}: {e}")
-        return {
-            'refund_amount': Decimal('0.00'),
-            'original_amount': Decimal('0.00'),
-            'refund_strategy': refund_strategy,
-            'refund_reason': f"Calculation error: {str(e)}",
-            'error': True
-        }
-
-
-def process_subscription_billing(subscription: Subscription) -> Dict[str, Any]:
-    """
-    Process billing for subscription renewal.
-    
-    Args:
-        subscription: Subscription to bill
-        
-    Returns:
-        Dict with billing results
-    """
-    try:
-        # Calculate billing amount
-        if subscription.billing_period == 'monthly':
-            amount = subscription.endpoint_group.monthly_price_usd
-            billing_period_days = 30
-        else:
-            amount = subscription.endpoint_group.yearly_price_usd
-            billing_period_days = 365
-        
-        # Create billing transaction
-        success, txn = create_billing_transaction(
-            user=subscription.user,
-            amount=-amount,  # Negative for debit
-            transaction_type='subscription_billing',
-            source='subscription_renewal',
-            description=f"Subscription renewal: {subscription.endpoint_group.display_name}",
-            reference_id=str(subscription.id),
-            metadata={
-                'subscription_id': str(subscription.id),
-                'billing_period': subscription.billing_period,
-                'endpoint_group': subscription.endpoint_group.name
-            }
-        )
-        
-        if success:
-            # Update subscription
-            subscription.next_billing_at = timezone.now() + timedelta(days=billing_period_days)
-            subscription.current_usage = 0  # Reset usage
-            subscription.save()
-            
-            logger.info(f"Successfully billed subscription {subscription.id} for ${amount}")
-            
-            return {
-                'success': True,
-                'amount_billed': amount,
-                'transaction_id': str(txn.id),
-                'next_billing_at': subscription.next_billing_at.isoformat()
-            }
-        else:
-            logger.warning(f"Failed to bill subscription {subscription.id}: insufficient balance")
-            
-            return {
-                'success': False,
-                'error': 'Insufficient balance',
-                'amount_required': amount,
-                'user_balance': UserBalance.objects.get(user=subscription.user).available_amount
-            }
-            
-    except Exception as e:
-        logger.error(f"Error processing subscription billing {subscription.id}: {e}")
-        return {
-            'success': False,
-            'error': str(e)
-        }
-
-
-def get_billing_summary(user: User, days: int = 30) -> Dict[str, Any]:
-    """
-    Get billing summary for user over specified period.
-    
-    Args:
-        user: User object
-        days: Number of days to include
-        
-    Returns:
-        Dict with billing summary
-    """
-    try:
-        cutoff_date = timezone.now() - timedelta(days=days)
-        
-        # Get transactions
-        transactions = Transaction.objects.filter(
-            user=user,
-            created_at__gte=cutoff_date
-        )
-        
-        # Calculate totals
-        from django.db import models
-        
-        total_credits = transactions.filter(amount__gt=0).aggregate(
-            total=models.Sum('amount')
-        )['total'] or Decimal('0.00')
-        
-        total_debits = transactions.filter(amount__lt=0).aggregate(
-            total=models.Sum('amount')
-        )['total'] or Decimal('0.00')
-        
-        # Get current balance
-        try:
-            balance = UserBalance.objects.get(user=user)
-            current_balance = balance.available_amount
-        except UserBalance.DoesNotExist:
-            current_balance = Decimal('0.00')
-        
-        return {
-            'period_days': days,
-            'total_credits': total_credits,
-            'total_debits': abs(total_debits),
-            'net_change': total_credits + total_debits,  # total_debits is negative
-            'current_balance': current_balance,
-            'transaction_count': transactions.count()
-        }
-        
-    except Exception as e:
-        logger.error(f"Error getting billing summary for user {user.id}: {e}")
-        return {
-            'error': str(e),
-            'period_days': days
-        }

django_cfg/apps/payments/utils/config_utils.py

@@ -1,245 +0,0 @@
-"""
-Configuration utilities for payments module.
-
-Universal utilities for working with django-cfg settings and configuration.
-"""
-
-import logging
-from typing import Optional, Dict, Any, Type
-from django.conf import settings
-
-from django_cfg.modules.base import BaseCfgModule
-from ..config.settings import PaymentsSettings
-
-logger = logging.getLogger(__name__)
-
-
-class PaymentsConfigMixin:
-    """Mixin for accessing payments configuration through django-cfg."""
-    
-    _payments_config_cache: Optional[PaymentsSettings] = None
-    _config_module: Optional[BaseCfgModule] = None
-    
-    @classmethod
-    def get_payments_config(cls) -> PaymentsSettings:
-        """Get payments configuration from django-cfg."""
-        if cls._payments_config_cache is None:
-            cls._payments_config_cache = cls._load_payments_config()
-        return cls._payments_config_cache
-    
-    @classmethod
-    def _load_payments_config(cls) -> PaymentsSettings:
-        """Load payments configuration using BaseCfgModule."""
-        try:
-            if cls._config_module is None:
-                from ..config.module import PaymentsCfgModule
-                cls._config_module = PaymentsCfgModule()
-            
-            return cls._config_module.get_config()
-        except Exception as e:
-            logger.warning(f"Failed to load payments config: {e}")
-            return PaymentsSettings()
-    
-    @classmethod
-    def reset_config_cache(cls):
-        """Reset configuration cache."""
-        cls._payments_config_cache = None
-        if cls._config_module:
-            cls._config_module.reset_cache()
-
-
-class RedisConfigHelper(PaymentsConfigMixin):
-    """Helper for Redis configuration."""
-    
-    @classmethod
-    def get_redis_config(cls) -> Dict[str, Any]:
-        """Get Redis configuration for payments."""
-        config = cls.get_payments_config()
-        
-        # Default Redis settings
-        redis_config = {
-            'host': 'localhost',
-            'port': 6379,
-            'db': 0,
-            'decode_responses': True,
-            'socket_timeout': 5,
-            'socket_connect_timeout': 5,
-            'retry_on_timeout': True,
-            'health_check_interval': 30,
-        }
-        
-        # Try to get Redis settings from Django CACHES
-        django_cache = getattr(settings, 'CACHES', {}).get('default', {})
-        if 'redis' in django_cache.get('BACKEND', '').lower():
-            location = django_cache.get('LOCATION', '')
-            if location.startswith('redis://'):
-                # Parse redis://host:port/db format
-                try:
-                    # Simple parsing for redis://host:port/db
-                    parts = location.replace('redis://', '').split('/')
-                    host_port = parts[0].split(':')
-                    redis_config['host'] = host_port[0]
-                    if len(host_port) > 1:
-                        redis_config['port'] = int(host_port[1])
-                    if len(parts) > 1:
-                        redis_config['db'] = int(parts[1])
-                except (ValueError, IndexError) as e:
-                    logger.warning(f"Failed to parse Redis URL {location}: {e}")
-        
-        # Override with payments-specific Redis config if available
-        if hasattr(config, 'redis') and config.redis:
-            redis_config.update(config.redis.dict())
-        
-        return redis_config
-    
-    @classmethod
-    def is_redis_available(cls) -> bool:
-        """Check if Redis is available and configured."""
-        try:
-            import redis
-            config = cls.get_redis_config()
-            client = redis.Redis(**config)
-            client.ping()
-            return True
-        except Exception as e:
-            logger.debug(f"Redis not available: {e}")
-            return False
-
-
-class CacheConfigHelper(PaymentsConfigMixin):
-    """Helper for cache configuration."""
-    
-    @classmethod
-    def get_cache_backend_type(cls) -> str:
-        """Get Django cache backend type."""
-        django_cache = getattr(settings, 'CACHES', {}).get('default', {})
-        backend = django_cache.get('BACKEND', '').lower()
-        
-        if 'redis' in backend:
-            return 'redis'
-        elif 'memcached' in backend:
-            return 'memcached'
-        elif 'database' in backend:
-            return 'database'
-        elif 'dummy' in backend:
-            return 'dummy'
-        else:
-            return 'unknown'
-    
-    @classmethod
-    def is_cache_enabled(cls) -> bool:
-        """Check if cache is properly configured (not dummy)."""
-        return cls.get_cache_backend_type() != 'dummy'
-    
-    @classmethod
-    def get_cache_timeout(cls, operation: str) -> int:
-        """Get cache timeout for specific operation."""
-        config = cls.get_payments_config()
-        
-        timeouts = {
-            'api_key': 300,      # 5 minutes
-            'rate_limit': 3600,  # 1 hour
-            'session': 1800,     # 30 minutes
-            'default': 600       # 10 minutes
-        }
-        
-        # Override with config if available
-        if hasattr(config, 'cache_timeouts') and config.cache_timeouts:
-            timeouts.update(config.cache_timeouts)
-        
-        return timeouts.get(operation, timeouts['default'])
-
-
-class ProviderConfigHelper(PaymentsConfigMixin):
-    """Helper for payment provider configuration."""
-    
-    @classmethod
-    def get_enabled_providers(cls) -> list:
-        """Get list of enabled payment providers."""
-        config = cls.get_payments_config()
-        if not config.enabled:
-            return []
-        
-        enabled = []
-        if hasattr(config, 'providers') and config.providers:
-            for provider_name, provider_config in config.providers.items():
-                if provider_config and cls._is_provider_properly_configured(provider_name, provider_config):
-                    enabled.append(provider_name)
-        
-        return enabled
-    
-    @classmethod
-    def get_provider_config(cls, provider_name: str) -> Optional[Any]:
-        """Get configuration for specific provider."""
-        config = cls.get_payments_config()
-        if not config.enabled or not hasattr(config, 'providers'):
-            return None
-        
-        return config.providers.get(provider_name)
-    
-    @classmethod
-    def is_provider_enabled(cls, provider_name: str) -> bool:
-        """Check if specific provider is enabled and configured."""
-        return provider_name in cls.get_enabled_providers()
-    
-    @classmethod
-    def _is_provider_properly_configured(cls, provider_name: str, provider_config: Any) -> bool:
-        """Check if provider configuration is complete."""
-        if not provider_config:
-            return False
-        
-        # Basic validation - each provider should have api_key
-        if not hasattr(provider_config, 'api_key') or not provider_config.api_key:
-            return False
-        
-        # Provider-specific validations
-        if provider_name == 'nowpayments':
-            return True  # api_key is sufficient
-        elif provider_name == 'stripe':
-            return True  # api_key is sufficient
-        elif provider_name == 'cryptapi':
-            return hasattr(provider_config, 'own_address') and provider_config.own_address
-        elif provider_name == 'cryptomus':
-            return hasattr(provider_config, 'merchant_uuid') and provider_config.merchant_uuid
-        
-        return True
-
-
-class PaymentsConfigUtil:
-    """
-    Universal utility for payments configuration.
-    
-    Combines all config helpers into one convenient interface.
-    """
-    
-    redis = RedisConfigHelper
-    cache = CacheConfigHelper
-    providers = ProviderConfigHelper
-    
-    @staticmethod
-    def get_config() -> PaymentsSettings:
-        """Get payments configuration."""
-        return PaymentsConfigMixin.get_payments_config()
-    
-    @staticmethod
-    def is_payments_enabled() -> bool:
-        """Check if payments module is enabled."""
-        config = PaymentsConfigMixin.get_payments_config()
-        return config.enabled
-    
-    @staticmethod
-    def is_debug_mode() -> bool:
-        """Check if payments module is in debug mode."""
-        config = PaymentsConfigMixin.get_payments_config()
-        return getattr(config, 'debug_mode', False)
-    
-    @staticmethod
-    def reset_all_caches():
-        """Reset all configuration caches."""
-        PaymentsConfigMixin.reset_config_cache()
-
-
-# Convenience exports
-get_payments_config = PaymentsConfigUtil.get_config
-is_payments_enabled = PaymentsConfigUtil.is_payments_enabled
-is_debug_mode = PaymentsConfigUtil.is_debug_mode