django-cfg 1.3.9__py3-none-any.whl → 1.3.11__py3-none-any.whl

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

@@ -1,22 +0,0 @@
-"""
-Constance configuration for Universal Payment System v2.0.
-
-Centralized configuration for dynamic settings that can be changed at runtime
-through Django admin interface.
-
-This module provides:
-- Field definitions for Constance
-- Settings validation and defaults
-- Integration with django-cfg PaymentsConfig
-"""
-
-from .fields import get_django_cfg_payments_constance_fields
-from .settings import PaymentConstanceSettings
-from .config_service import PaymentConfigService, get_payment_config_service
-
-__all__ = [
-    'get_django_cfg_payments_constance_fields',
-    'PaymentConstanceSettings',
-    'PaymentConfigService',
-    'get_payment_config_service',
-]

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

@@ -1,123 +0,0 @@
-"""
-Configuration service for payments using Constance.
-
-Provides easy access to Constance settings with type safety and caching.
-"""
-
-from typing import Dict, Any, Optional
-from django_cfg.modules.django_logger import get_logger
-from .settings import PaymentConstanceSettings, get_payment_settings
-
-logger = get_logger(__name__)
-
-
-class PaymentConfigService:
-    """
-    Service for accessing payment configuration from Constance.
-    
-    Provides type-safe access to dynamic settings with caching and validation.
-    """
-    
-    def __init__(self):
-        """Initialize config service."""
-        self._cached_settings: Optional[PaymentConstanceSettings] = None
-        self._cache_timeout = 60  # Cache for 1 minute
-        self._last_refresh = 0
-    
-    def get_settings(self, force_refresh: bool = False) -> PaymentConstanceSettings:
-        """
-        Get current payment settings from Constance.
-        
-        Args:
-            force_refresh: Force refresh from Constance (ignore cache)
-            
-        Returns:
-            PaymentConstanceSettings instance
-        """
-        import time
-        
-        current_time = time.time()
-        
-        if (force_refresh or 
-            self._cached_settings is None or 
-            (current_time - self._last_refresh) > self._cache_timeout):
-            
-            try:
-                self._cached_settings = get_payment_settings()
-                self._last_refresh = current_time
-                logger.debug("Refreshed payment settings from Constance")
-            except Exception as e:
-                logger.error(f"Failed to refresh payment settings: {e}")
-                if self._cached_settings is None:
-                    # Fallback to defaults if no cache
-                    self._cached_settings = PaymentConstanceSettings()
-        
-        return self._cached_settings
-    
-    def is_enabled(self) -> bool:
-        """Check if payments system is enabled."""
-        return self.get_settings().enabled
-    
-    def is_middleware_enabled(self) -> bool:
-        """Check if payments middleware is enabled."""
-        return self.get_settings().middleware_enabled
-    
-    def is_rate_limiting_enabled(self) -> bool:
-        """Check if rate limiting is enabled."""
-        return self.get_settings().rate_limiting_enabled
-    
-    def is_usage_tracking_enabled(self) -> bool:
-        """Check if usage tracking is enabled."""
-        return self.get_settings().usage_tracking_enabled
-    
-    def get_rate_limits(self) -> Dict[str, int]:
-        """Get rate limits configuration."""
-        return self.get_settings().get_rate_limits()
-    
-    def get_cache_timeouts(self) -> Dict[str, int]:
-        """Get cache timeouts configuration."""
-        return self.get_settings().get_cache_timeouts()
-    
-    def get_provider_config(self, provider: str) -> Dict[str, Any]:
-        """Get provider-specific configuration."""
-        return self.get_settings().get_provider_config(provider)
-    
-    def get_nowpayments_config(self) -> Dict[str, Any]:
-        """Get NowPayments configuration."""
-        return self.get_provider_config('nowpayments')
-    
-    def refresh_configuration(self):
-        """Force refresh configuration from Constance."""
-        self.get_settings(force_refresh=True)
-    
-    def get_all_provider_configs(self) -> Dict[str, Dict[str, Any]]:
-        """Get all provider configurations."""
-        return {
-            'nowpayments': self.get_nowpayments_config(),
-        }
-    
-    def get_constance_settings(self) -> PaymentConstanceSettings:
-        """
-        Alias for get_settings() for backward compatibility.
-        
-        Returns:
-            PaymentConstanceSettings instance
-        """
-        return self.get_settings()
-
-
-# Global instance
-_config_service: Optional[PaymentConfigService] = None
-
-
-def get_payment_config_service() -> PaymentConfigService:
-    """
-    Get global payment config service instance.
-    
-    Returns:
-        PaymentConfigService instance
-    """
-    global _config_service
-    if _config_service is None:
-        _config_service = PaymentConfigService()
-    return _config_service

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

@@ -1,69 +0,0 @@
-"""
-Constance fields configuration for Payments app.
-
-This module defines ONLY dynamic settings that need to be changed at runtime.
-Static configuration is handled by PaymentsConfig Pydantic model.
-
-Note: This file MUST NOT import Django models or anything that requires
-Django apps to be loaded, as it's imported during settings generation.
-"""
-
-from typing import List
-from django_cfg.models.constance import ConstanceField
-
-
-def get_django_cfg_payments_constance_fields() -> List[ConstanceField]:
-    """
-    Get Constance field definitions for Payments app.
-    
-    Only includes settings that need runtime configuration:
-    - API keys and secrets (change per environment)
-    - Rate limits (admins need to adjust)
-    - Usage tracking preferences
-    - Currency update intervals
-    
-    Static settings (enabled flags, middleware, cache timeouts) are handled
-    by PaymentsConfig Pydantic model and auto-detection.
-    
-    Returns:
-        List of ConstanceField objects for runtime-configurable settings
-    """
-    # Import PaymentsConfigManager for consistent config access
-    from ..django_cfg_integration import PaymentsConfigManager
-    
-    # Get default values from initialized Pydantic config using PaymentsConfigManager
-    default_config = PaymentsConfigManager.get_payments_config()
-    
-    return [
-        # === 📊 Usage Tracking ===
-        ConstanceField(
-            name='PAYMENTS_TRACK_ANONYMOUS_USAGE',
-            default=default_config.track_anonymous_usage,
-            help_text="📊 Usage Tracking: Track usage for anonymous users (privacy setting)",
-            field_type='bool',
-            group='Payments'
-        ),
-        
-        # === 🔌 NowPayments Provider ===
-        ConstanceField(
-            name='PAYMENTS_NOWPAYMENTS_API_KEY',
-            default='',
-            help_text="🔌 NowPayments: API key for production (sensitive)",
-            field_type='str',
-            group='Payments'
-        ),
-        ConstanceField(
-            name='PAYMENTS_NOWPAYMENTS_IPN_SECRET',
-            default='',
-            help_text="🔌 NowPayments: IPN secret for webhook verification (sensitive)",
-            field_type='str',
-            group='Payments'
-        ),
-        ConstanceField(
-            name='PAYMENTS_NOWPAYMENTS_SANDBOX_MODE',
-            default=True,
-            help_text="🔌 NowPayments: Use sandbox mode for testing",
-            field_type='bool',
-            group='Payments'
-        ),
-    ]

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

@@ -1,160 +0,0 @@
-"""
-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/migrations/0002_currency_usd_rate_currency_usd_rate_updated_at.py

@@ -1,26 +0,0 @@
-# Generated by Django 5.2.6 on 2025-09-27 12:59
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("payments", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="currency",
-            name="usd_rate",
-            field=models.FloatField(
-                default=1.0, help_text="Current USD exchange rate (1 unit = X USD)"
-            ),
-        ),
-        migrations.AddField(
-            model_name="currency",
-            name="usd_rate_updated_at",
-            field=models.DateTimeField(
-                blank=True, help_text="When USD rate was last updated", null=True
-            ),
-        ),
-    ]

django_cfg/apps/payments/migrations/0003_remove_provider_currency_fields.py

@@ -1,28 +0,0 @@
-# Generated by Django 5.2.6 on 2025-09-27 16:46
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("payments", "0002_currency_usd_rate_currency_usd_rate_updated_at"),
-    ]
-
-    operations = [
-        migrations.RemoveField(
-            model_name="providercurrency",
-            name="fee_percentage",
-        ),
-        migrations.RemoveField(
-            model_name="providercurrency",
-            name="fixed_fee",
-        ),
-        migrations.RemoveField(
-            model_name="providercurrency",
-            name="max_amount",
-        ),
-        migrations.RemoveField(
-            model_name="providercurrency",
-            name="min_amount",
-        ),
-    ]

django_cfg/apps/payments/migrations/0004_add_reserved_usd_field.py

@@ -1,30 +0,0 @@
-# Generated by Django 5.2.6 on 2025-09-27 18:16
-
-import django.core.validators
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("payments", "0003_remove_provider_currency_fields"),
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="userbalance",
-            name="reserved_usd",
-            field=models.FloatField(
-                default=0.0,
-                help_text="Reserved amount in USD (pending transactions)",
-                validators=[django.core.validators.MinValueValidator(0.0)],
-            ),
-        ),
-        migrations.AddConstraint(
-            model_name="userbalance",
-            constraint=models.CheckConstraint(
-                condition=models.Q(("reserved_usd__gte", 0.0)), name="reserved_non_negative_check"
-            ),
-        ),
-    ]