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

django_cfg/apps/payments/config/constance/settings.py

@@ -0,0 +1,160 @@
+"""
+Constance settings integration for Payments app.
+
+Simplified settings management using Pydantic models and Constance.
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class PaymentConstanceSettings(BaseModel):
+    """
+    Pydantic model for payments Constance settings.
+    
+    Provides type-safe access to dynamic settings with validation.
+    """
+    
+    # Core settings
+    enabled: bool = Field(default=True, description="Enable payments system")
+    middleware_enabled: bool = Field(default=True, description="Enable payments middleware")
+    
+    # Rate limiting
+    rate_limiting_enabled: bool = Field(default=True, description="Enable rate limiting")
+    anonymous_rate_limit: int = Field(default=60, description="Anonymous user rate limit")
+    authenticated_rate_limit: int = Field(default=300, description="Authenticated user rate limit")
+    
+    # Usage tracking
+    usage_tracking_enabled: bool = Field(default=True, description="Enable usage tracking")
+    track_anonymous_usage: bool = Field(default=False, description="Track anonymous usage")
+    
+    # Cache timeouts
+    api_key_cache_timeout: int = Field(default=300, description="API key cache timeout")
+    rate_limit_cache_timeout: int = Field(default=3600, description="Rate limit cache timeout")
+    session_cache_timeout: int = Field(default=1800, description="Session cache timeout")
+    default_cache_timeout: int = Field(default=600, description="Default cache timeout")
+    
+    # Provider settings
+    nowpayments_api_key: str = Field(default="", description="NowPayments API key")
+    nowpayments_ipn_secret: str = Field(default="", description="NowPayments IPN secret")
+    nowpayments_sandbox_mode: bool = Field(default=True, description="NowPayments sandbox mode")
+    
+    # Currency settings
+    auto_update_rates: bool = Field(default=True, description="Auto update currency rates")
+    rate_update_interval_hours: int = Field(default=1, description="Rate update interval")
+    
+    @classmethod
+    def from_constance(cls) -> 'PaymentConstanceSettings':
+        """
+        Create instance from Constance settings.
+        
+        Returns:
+            PaymentConstanceSettings instance with current Constance values
+        """
+        try:
+            from constance import config
+            from ..django_cfg_integration import PaymentsConfigManager
+            
+            # Get defaults from initialized Pydantic config using PaymentsConfigManager
+            pydantic_config = PaymentsConfigManager.get_payments_config()
+            
+            return cls(
+                # Static settings from Pydantic (not in Constance anymore)
+                enabled=pydantic_config.enabled,
+                middleware_enabled=pydantic_config.middleware_enabled,
+                rate_limiting_enabled=pydantic_config.rate_limiting_enabled,
+                anonymous_rate_limit=pydantic_config.default_rate_limits['anonymous'],
+                authenticated_rate_limit=pydantic_config.default_rate_limits['authenticated'],
+                usage_tracking_enabled=pydantic_config.usage_tracking_enabled,
+                
+                # Dynamic settings from Constance (only what's actually in Constance)
+                track_anonymous_usage=getattr(config, 'PAYMENTS_TRACK_ANONYMOUS_USAGE', pydantic_config.track_anonymous_usage),
+                
+                # Cache timeouts from Pydantic (not in Constance anymore)
+                api_key_cache_timeout=pydantic_config.cache_timeouts['api_key'],
+                rate_limit_cache_timeout=pydantic_config.cache_timeouts['rate_limit'],
+                session_cache_timeout=pydantic_config.cache_timeouts['session'],
+                default_cache_timeout=pydantic_config.cache_timeouts['default'],
+                
+                # Provider settings from Constance (sensitive data)
+                nowpayments_api_key=getattr(config, 'PAYMENTS_NOWPAYMENTS_API_KEY', ''),
+                nowpayments_ipn_secret=getattr(config, 'PAYMENTS_NOWPAYMENTS_IPN_SECRET', ''),
+                nowpayments_sandbox_mode=getattr(config, 'PAYMENTS_NOWPAYMENTS_SANDBOX_MODE', True),
+                
+                # Currency settings from Pydantic (automatic now)
+                auto_update_rates=True,  # Always automatic
+                rate_update_interval_hours=1,  # Fixed interval
+            )
+        except ImportError:
+            logger.warning("Constance not available, using default settings")
+            return cls()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for easy access."""
+        return self.model_dump()
+    
+    def get_rate_limits(self) -> Dict[str, int]:
+        """Get rate limits as dictionary."""
+        return {
+            'anonymous': self.anonymous_rate_limit,
+            'authenticated': self.authenticated_rate_limit,
+        }
+    
+    def get_cache_timeouts(self) -> Dict[str, int]:
+        """Get cache timeouts as dictionary."""
+        return {
+            'api_key': self.api_key_cache_timeout,
+            'rate_limit': self.rate_limit_cache_timeout,
+            'session': self.session_cache_timeout,
+            'default': self.default_cache_timeout,
+        }
+    
+    def get_provider_config(self, provider: str) -> Dict[str, Any]:
+        """Get provider-specific configuration."""
+        if provider.lower() == 'nowpayments':
+            # Provider is enabled if it has API key configured
+            is_enabled = bool(self.nowpayments_api_key and self.nowpayments_api_key.strip())
+            return {
+                'enabled': is_enabled,
+                'api_key': self.nowpayments_api_key,
+                'ipn_secret': self.nowpayments_ipn_secret,
+                'sandbox_mode': self.nowpayments_sandbox_mode,
+            }
+        return {}
+
+
+def get_payment_settings() -> PaymentConstanceSettings:
+    """
+    Get current payment settings from Constance.
+    
+    Returns:
+        PaymentConstanceSettings instance with current values
+    """
+    return PaymentConstanceSettings.from_constance()
+
+
+def is_feature_enabled(feature: str) -> bool:
+    """
+    Check if a specific feature is enabled.
+    
+    Args:
+        feature: Feature name (e.g., 'rate_limiting', 'usage_tracking')
+        
+    Returns:
+        True if feature is enabled, False otherwise
+    """
+    settings = get_payment_settings()
+    
+    feature_map = {
+        'payments': settings.enabled,
+        'middleware': settings.middleware_enabled,
+        'rate_limiting': settings.rate_limiting_enabled,
+        'usage_tracking': settings.usage_tracking_enabled,
+        'anonymous_tracking': settings.track_anonymous_usage,
+        'auto_rates': settings.auto_update_rates,
+    }
+    
+    return feature_map.get(feature, False)

django_cfg/apps/payments/config/django_cfg_integration.py

@@ -0,0 +1,202 @@
+"""
+Django-CFG integration for payments configuration.
+
+Central place for accessing django-cfg PaymentsConfig with proper error handling
+and caching. All payments modules should use this for configuration access.
+"""
+
+from typing import Optional
+from django_cfg.core.config import get_current_config
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("payments_django_cfg_integration")
+
+
+class PaymentsConfigManager:
+    """
+    Central manager for payments configuration access.
+    
+    Provides cached, type-safe access to PaymentsConfig from django-cfg
+    with proper error handling and fallbacks.
+    """
+    
+    _payments_config_cache: Optional[any] = None
+    _cache_timestamp: float = 0
+    _cache_ttl: float = 60.0  # Cache for 60 seconds
+    
+    @classmethod
+    def get_payments_config(cls, force_refresh: bool = False):
+        """
+        Get payments configuration from django-cfg.
+        
+        Args:
+            force_refresh: Force refresh from django-cfg (ignore cache)
+            
+        Returns:
+            PaymentsConfig instance from current django-cfg config
+            
+        Raises:
+            ValueError: If PaymentsConfig not found in current config
+        """
+        import time
+        
+        current_time = time.time()
+        
+        # Check if cache is valid
+        if (not force_refresh and 
+            cls._payments_config_cache is not None and 
+            (current_time - cls._cache_timestamp) < cls._cache_ttl):
+            return cls._payments_config_cache
+        
+        # Load fresh config
+        try:
+            current_config = get_current_config()
+            if current_config and hasattr(current_config, 'payments') and current_config.payments:
+                cls._payments_config_cache = current_config.payments
+                cls._cache_timestamp = current_time
+                logger.debug("Loaded PaymentsConfig from django-cfg")
+                return cls._payments_config_cache
+            else:
+                error_msg = "PaymentsConfig not found in current django-cfg config"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+                
+        except Exception as e:
+            logger.error(f"Failed to load payments config: {e}")
+            raise
+    
+    @classmethod
+    def get_payments_config_safe(cls, force_refresh: bool = False):
+        """
+        Get payments configuration with fallback to defaults.
+        
+        Args:
+            force_refresh: Force refresh from django-cfg (ignore cache)
+            
+        Returns:
+            PaymentsConfig instance (from django-cfg or defaults)
+        """
+        try:
+            return cls.get_payments_config(force_refresh=force_refresh)
+        except Exception as e:
+            logger.warning(f"Using default PaymentsConfig due to error: {e}")
+            from django_cfg.models.payments import PaymentsConfig
+            return PaymentsConfig()
+    
+    @classmethod
+    def is_payments_enabled(cls) -> bool:
+        """
+        Check if payments module is enabled.
+        
+        Returns:
+            True if payments is enabled in django-cfg config
+        """
+        try:
+            config = cls.get_payments_config()
+            return config.enabled
+        except Exception:
+            logger.warning("Failed to check payments enabled status, defaulting to False")
+            return False
+    
+    @classmethod
+    def is_payments_configured(cls) -> bool:
+        """
+        Check if payments is properly configured in django-cfg.
+        
+        Returns:
+            True if PaymentsConfig exists in current config
+        """
+        try:
+            cls.get_payments_config()
+            return True
+        except Exception:
+            return False
+    
+    @classmethod
+    def reset_cache(cls):
+        """Reset configuration cache."""
+        cls._payments_config_cache = None
+        cls._cache_timestamp = 0
+        logger.debug("PaymentsConfig cache reset")
+    
+    @classmethod
+    def get_config_summary(cls) -> dict:
+        """
+        Get summary of current payments configuration.
+        
+        Returns:
+            Dictionary with configuration summary
+        """
+        try:
+            config = cls.get_payments_config()
+            return {
+                'configured': True,
+                'enabled': config.enabled,
+                'middleware_enabled': config.middleware_enabled,
+                'rate_limiting_enabled': config.rate_limiting_enabled,
+                'usage_tracking_enabled': config.usage_tracking_enabled,
+                'cache_timeouts': config.cache_timeouts,
+                'api_prefixes': config.api_prefixes,
+            }
+        except Exception as e:
+            return {
+                'configured': False,
+                'error': str(e),
+                'enabled': False,
+            }
+
+
+# Legacy compatibility - keep old interface
+class PaymentsConfigMixin:
+    """Legacy mixin for backward compatibility."""
+    
+    @classmethod
+    def get_payments_config(cls):
+        """Get payments configuration from django-cfg."""
+        return PaymentsConfigManager.get_payments_config_safe()
+    
+    @classmethod
+    def reset_config_cache(cls):
+        """Reset configuration cache."""
+        PaymentsConfigManager.reset_cache()
+
+
+# Public API functions
+def get_payments_config(safe: bool = True, force_refresh: bool = False):
+    """
+    Get payments configuration from django-cfg.
+    
+    Args:
+        safe: If True, return defaults on error. If False, raise exception.
+        force_refresh: Force refresh from django-cfg (ignore cache)
+        
+    Returns:
+        PaymentsConfig instance
+        
+    Raises:
+        ValueError: If safe=False and PaymentsConfig not found
+    """
+    if safe:
+        return PaymentsConfigManager.get_payments_config_safe(force_refresh=force_refresh)
+    else:
+        return PaymentsConfigManager.get_payments_config(force_refresh=force_refresh)
+
+
+def is_payments_enabled() -> bool:
+    """Check if payments module is enabled."""
+    return PaymentsConfigManager.is_payments_enabled()
+
+
+def is_payments_configured() -> bool:
+    """Check if payments is properly configured in django-cfg."""
+    return PaymentsConfigManager.is_payments_configured()
+
+
+def get_config_summary() -> dict:
+    """Get summary of current payments configuration."""
+    return PaymentsConfigManager.get_config_summary()
+
+
+def reset_payments_config_cache():
+    """Reset payments configuration cache."""
+    PaymentsConfigManager.reset_cache()

django_cfg/apps/payments/config/helpers.py

@@ -0,0 +1,130 @@
+"""
+Configuration helpers for the Universal Payment System v2.0.
+
+Provides specialized helpers for different configuration aspects.
+"""
+
+from typing import Dict, Any
+from django.conf import settings
+
+from .django_cfg_integration import PaymentsConfigMixin
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("payments_config_helpers")
+
+
+class MiddlewareConfigHelper(PaymentsConfigMixin):
+    """Helper for middleware configuration."""
+    
+    @classmethod
+    def get_middleware_config(cls) -> Dict[str, Any]:
+        """Get middleware configuration combining django-cfg and Constance."""
+        config = cls.get_payments_config()
+        
+        # Get Constance settings for dynamic config
+        try:
+            from .constance import get_payment_config_service
+            config_service = get_payment_config_service()
+            constance_settings = config_service.get_constance_settings()
+        except Exception as e:
+            logger.warning(f"Failed to load Constance settings: {e}")
+            constance_settings = None
+        
+        return {
+            # Static settings from django-cfg
+            'enabled': config.enabled and config.middleware_enabled,
+            'api_prefixes': config.api_prefixes,
+            'exempt_paths': config.exempt_paths,
+            'rate_limiting_enabled': config.rate_limiting_enabled,
+            'default_rate_limits': config.default_rate_limits,
+            'usage_tracking_enabled': config.usage_tracking_enabled,
+            'track_anonymous_usage': config.track_anonymous_usage,
+            'cache_timeouts': config.cache_timeouts,
+            
+            # Dynamic settings from Constance (if available)
+            'constance_settings': constance_settings,
+        }
+
+
+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()
+        return config.cache_timeouts.get(operation, config.cache_timeouts['default'])
+
+
+class RedisConfigHelper(PaymentsConfigMixin):
+    """Helper for Redis configuration."""
+    
+    @classmethod
+    def get_redis_config(cls) -> Dict[str, Any]:
+        """Get Redis configuration for payments."""
+        # 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}")
+        
+        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

django_cfg/apps/payments/management/__init__.py

@@ -1,3 +1 @@
-"""
-Management commands for the payments app.
-"""
+# Management commands package

django_cfg/apps/payments/management/commands/__init__.py

@@ -1,3 +1 @@
-"""
-Management commands directory.
-"""
+# Management commands