django-cfg 1.2.22__py3-none-any.whl → 1.2.23__py3-none-any.whl

django_cfg/apps/payments/signals/subscription_signals.py

@@ -0,0 +1,196 @@
+"""
+🔄 Universal Subscription Signals
+
+Automatic subscription management and lifecycle handling via Django signals.
+"""
+
+from django.db.models.signals import post_save, pre_save, post_delete
+from django.dispatch import receiver
+from django.db import transaction
+from django.utils import timezone
+from datetime import timedelta
+import logging
+
+from ..models import Subscription, EndpointGroup, UserBalance, Transaction
+from ..services.cache import SimpleCache
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(pre_save, sender=Subscription)
+def store_original_subscription_status(sender, instance, **kwargs):
+    """Store original subscription status for change detection."""
+    if instance.pk:
+        try:
+            old_instance = Subscription.objects.get(pk=instance.pk)
+            instance._original_status = old_instance.status
+            instance._original_expires_at = old_instance.expires_at
+        except Subscription.DoesNotExist:
+            instance._original_status = None
+            instance._original_expires_at = None
+
+
+@receiver(post_save, sender=Subscription)
+def process_subscription_status_changes(sender, instance, created, **kwargs):
+    """Process subscription status changes and handle lifecycle events."""
+    if created:
+        logger.info(
+            f"New subscription created: {instance.endpoint_group.name} "
+            f"for user {instance.user.email} (expires: {instance.expires_at})"
+        )
+        _clear_user_cache(instance.user.id)
+        return
+    
+    # Check if status changed
+    if hasattr(instance, '_original_status'):
+        old_status = instance._original_status
+        new_status = instance.status
+        
+        if old_status != new_status:
+            logger.info(
+                f"Subscription status changed: {instance.endpoint_group.name} "
+                f"for user {instance.user.email} - {old_status} → {new_status}"
+            )
+            
+            # Handle specific status changes
+            if new_status == Subscription.SubscriptionStatus.ACTIVE:
+                _handle_subscription_activation(instance)
+            elif new_status == Subscription.SubscriptionStatus.CANCELLED:
+                _handle_subscription_cancellation(instance)
+            elif new_status == Subscription.SubscriptionStatus.EXPIRED:
+                _handle_subscription_expiration(instance)
+            
+            _clear_user_cache(instance.user.id)
+
+
+@receiver(post_save, sender=Subscription)
+def handle_subscription_renewal(sender, instance, created, **kwargs):
+    """Handle subscription renewal and billing."""
+    if created or not hasattr(instance, '_original_expires_at'):
+        return
+    
+    old_expires_at = instance._original_expires_at
+    new_expires_at = instance.expires_at
+    
+    # Check if subscription was renewed (expires_at extended)
+    if old_expires_at and new_expires_at and new_expires_at > old_expires_at:
+        logger.info(
+            f"Subscription renewed: {instance.endpoint_group.name} "
+            f"for user {instance.user.email} - extended to {new_expires_at}"
+        )
+        _clear_user_cache(instance.user.id)
+
+
+@receiver(post_delete, sender=Subscription)
+def log_subscription_deletion(sender, instance, **kwargs):
+    """Log subscription deletions for audit purposes."""
+    logger.warning(
+        f"Subscription deleted: {instance.endpoint_group.name} "
+        f"for user {instance.user.email} - Status was: {instance.status}"
+    )
+    _clear_user_cache(instance.user.id)
+
+
+@receiver(post_save, sender=EndpointGroup)
+def log_endpoint_group_changes(sender, instance, created, **kwargs):
+    """Log endpoint group changes that may affect subscriptions."""
+    if created:
+        logger.info(f"New endpoint group created: {instance.name}")
+    else:
+        # Check if important fields changed
+        if instance.tracker.has_changed('is_active'):
+            logger.warning(
+                f"Endpoint group activity changed: {instance.name} "
+                f"- active: {instance.is_active}"
+            )
+            # Clear cache for all users with subscriptions to this group
+            _clear_endpoint_group_cache(instance)
+
+
+def _handle_subscription_activation(subscription: Subscription):
+    """Handle subscription activation logic."""
+    try:
+        # Reset usage counters
+        subscription.usage_current = 0
+        
+        # Set next billing date
+        if not subscription.next_billing:
+            subscription.next_billing = timezone.now() + timedelta(days=30)  # Monthly by default
+        
+        subscription.save(update_fields=['usage_current', 'next_billing'])
+        
+        logger.info(f"Subscription activated: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription activation: {e}")
+
+
+def _handle_subscription_cancellation(subscription: Subscription):
+    """Handle subscription cancellation logic."""
+    try:
+        # Mark as cancelled
+        subscription.cancelled_at = timezone.now()
+        subscription.save(update_fields=['cancelled_at'])
+        
+        logger.info(f"Subscription cancelled: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription cancellation: {e}")
+
+
+def _handle_subscription_expiration(subscription: Subscription):
+    """Handle subscription expiration logic."""
+    try:
+        # Mark as expired
+        subscription.expired_at = timezone.now()
+        subscription.save(update_fields=['expired_at'])
+        
+        logger.info(f"Subscription expired: {subscription.endpoint_group.name} for {subscription.user.email}")
+        
+    except Exception as e:
+        logger.error(f"Error handling subscription expiration: {e}")
+
+
+def _clear_user_cache(user_id: int):
+    """Clear cache for specific user."""
+    try:
+        cache = SimpleCache("subscriptions")
+        cache_keys = [
+            f"access:{user_id}",
+            f"subscriptions:{user_id}",
+            f"user_summary:{user_id}",
+        ]
+        
+        for key in cache_keys:
+            cache.delete(key)
+            
+    except Exception as e:
+        logger.warning(f"Failed to clear cache for user {user_id}: {e}")
+
+
+def _clear_endpoint_group_cache(endpoint_group: EndpointGroup):
+    """Clear cache for all users with subscriptions to this endpoint group."""
+    try:
+        # Get all users with active subscriptions to this group
+        user_ids = Subscription.objects.filter(
+            endpoint_group=endpoint_group,
+            status=Subscription.SubscriptionStatus.ACTIVE
+        ).values_list('user_id', flat=True)
+        
+        for user_id in user_ids:
+            _clear_user_cache(user_id)
+            
+    except Exception as e:
+        logger.warning(f"Failed to clear cache for endpoint group {endpoint_group.name}: {e}")
+
+
+@receiver(post_save, sender=Subscription)
+def update_usage_statistics(sender, instance, created, **kwargs):
+    """Update usage statistics when subscription is modified."""
+    if not created and hasattr(instance, '_original_status'):
+        # Only update stats if usage-related fields might have changed
+        if instance.usage_current != getattr(instance, '_original_usage_current', instance.usage_current):
+            logger.debug(
+                f"Usage updated for subscription {instance.endpoint_group.name}: "
+                f"{instance.usage_current} requests"
+            )

django_cfg/apps/payments/urls.py

@@ -66,13 +66,13 @@ generic_patterns = [
 
 urlpatterns = [
     # Include all router URLs
-    path('api/v1/', include(router.urls)),
+    path('', include(router.urls)),
     
     # Include nested router URLs
-    path('api/v1/', include(payments_router.urls)),
-    path('api/v1/', include(subscriptions_router.urls)),
-    path('api/v1/', include(apikeys_router.urls)),
+    path('', include(payments_router.urls)),
+    path('', include(subscriptions_router.urls)),
+    path('', include(apikeys_router.urls)),
     
     # Include generic API endpoints
-    path('api/v1/', include(generic_patterns)),
+    path('', include(generic_patterns)),
 ]

django_cfg/apps/payments/utils/__init__.py

@@ -0,0 +1,42 @@
+"""
+Utilities for universal payments.
+"""
+
+from .middleware_utils import get_client_ip, is_api_request, extract_api_key
+# from .billing_utils import calculate_usage_cost, create_billing_transaction  # TODO: Implement when needed
+from .validation_utils import validate_api_key, check_subscription_access
+
+# Configuration utilities
+from .config_utils import (
+    PaymentsConfigUtil,
+    RedisConfigHelper,
+    CacheConfigHelper, 
+    ProviderConfigHelper,
+    get_payments_config,
+    is_payments_enabled,
+    is_debug_mode
+)
+
+__all__ = [
+    # Middleware utilities
+    'get_client_ip',
+    'is_api_request', 
+    'extract_api_key',
+    
+    # Billing utilities (TODO: Implement when needed)
+    # 'calculate_usage_cost',
+    # 'create_billing_transaction',
+    
+    # Validation utilities
+    'validate_api_key',
+    'check_subscription_access',
+    
+    # Configuration utilities
+    'PaymentsConfigUtil',
+    'RedisConfigHelper',
+    'CacheConfigHelper',
+    'ProviderConfigHelper', 
+    'get_payments_config',
+    'is_payments_enabled',
+    'is_debug_mode',
+]

django_cfg/apps/payments/utils/config_utils.py

@@ -0,0 +1,243 @@
+"""
+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
+        
+        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