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

django_cfg/apps/payments/admin/tariffs_admin.py

@@ -0,0 +1,199 @@
+"""
+Admin interface for tariffs.
+"""
+
+from django.contrib import admin
+from django.utils.html import format_html
+from django.contrib.humanize.templatetags.humanize import naturaltime
+from unfold.admin import ModelAdmin
+from unfold.decorators import display
+
+from ..models import Tariff, TariffEndpointGroup
+
+
+@admin.register(Tariff)
+class TariffAdmin(ModelAdmin):
+    """Admin interface for tariffs."""
+    
+    list_display = [
+        'tariff_display',
+        'price_display',
+        'limit_display',
+        'status_display',
+        'endpoint_groups_count',
+        'created_at_display'
+    ]
+    
+    list_display_links = ['tariff_display']
+    
+    search_fields = ['name', 'display_name', 'description']
+    
+    list_filter = ['is_active', 'created_at']
+    
+    readonly_fields = ['created_at', 'updated_at']
+    
+    fieldsets = [
+        ('Tariff Information', {
+            'fields': ['name', 'display_name', 'description']
+        }),
+        ('Pricing & Limits', {
+            'fields': ['monthly_price', 'request_limit']
+        }),
+        ('Settings', {
+            'fields': ['is_active']
+        }),
+        ('Timestamps', {
+            'fields': ['created_at', 'updated_at'],
+            'classes': ['collapse']
+        })
+    ]
+    
+    @display(description="Tariff")
+    def tariff_display(self, obj):
+        """Display tariff name and description."""
+        return format_html(
+            '<strong>{}</strong><br><small>{}</small>',
+            obj.display_name,
+            obj.description[:50] + '...' if len(obj.description) > 50 else obj.description
+        )
+    
+    @display(description="Price")
+    def price_display(self, obj):
+        """Display price with free indicator."""
+        if obj.monthly_price == 0:
+            return format_html(
+                '<span style="background: #28a745; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">FREE</span>'
+            )
+        else:
+            return format_html(
+                '<strong>${:.2f}</strong>/month',
+                obj.monthly_price
+            )
+    
+    @display(description="Request Limit")
+    def limit_display(self, obj):
+        """Display request limit."""
+        if obj.request_limit == 0:
+            return format_html(
+                '<span style="color: #28a745; font-weight: bold;">Unlimited</span>'
+            )
+        else:
+            return format_html(
+                '<strong>{:,}</strong>/month',
+                obj.request_limit
+            )
+    
+    @display(description="Status")
+    def status_display(self, obj):
+        """Display status badge."""
+        if obj.is_active:
+            return format_html(
+                '<span style="background: #28a745; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">Active</span>'
+            )
+        else:
+            return format_html(
+                '<span style="background: #dc3545; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">Inactive</span>'
+            )
+    
+    @display(description="Endpoint Groups")
+    def endpoint_groups_count(self, obj):
+        """Display count of endpoint groups."""
+        count = obj.endpoint_groups.filter(is_enabled=True).count()
+        total = obj.endpoint_groups.count()
+        
+        if total == 0:
+            return format_html('<span style="color: #6c757d;">No groups</span>')
+        
+        return format_html(
+            '<strong>{}</strong> active<br><small>{} total</small>',
+            count,
+            total
+        )
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Display creation date."""
+        return naturaltime(obj.created_at)
+
+
+@admin.register(TariffEndpointGroup)
+class TariffEndpointGroupAdmin(ModelAdmin):
+    """Admin interface for tariff endpoint group associations."""
+    
+    list_display = [
+        'association_display',
+        'tariff_display',
+        'endpoint_group_display',
+        'status_display',
+        'created_at_display'
+    ]
+    
+    list_display_links = ['association_display']
+    
+    search_fields = [
+        'tariff__name',
+        'tariff__display_name',
+        'endpoint_group__name',
+        'endpoint_group__display_name'
+    ]
+    
+    list_filter = ['is_enabled', 'tariff', 'endpoint_group', 'created_at']
+    
+    readonly_fields = ['created_at', 'updated_at']
+    
+    fieldsets = [
+        ('Association', {
+            'fields': ['tariff', 'endpoint_group', 'is_enabled']
+        }),
+        ('Timestamps', {
+            'fields': ['created_at', 'updated_at'],
+            'classes': ['collapse']
+        })
+    ]
+    
+    @display(description="Association")
+    def association_display(self, obj):
+        """Display association ID."""
+        return format_html(
+            '<strong>#{}</strong><br><small>{} → {}</small>',
+            str(obj.id)[:8],
+            obj.tariff.name,
+            obj.endpoint_group.name
+        )
+    
+    @display(description="Tariff")
+    def tariff_display(self, obj):
+        """Display tariff information."""
+        price_text = 'FREE' if obj.tariff.monthly_price == 0 else f'${obj.tariff.monthly_price:.2f}/mo'
+        
+        return format_html(
+            '<strong>{}</strong><br><small>{}</small>',
+            obj.tariff.display_name,
+            price_text
+        )
+    
+    @display(description="Endpoint Group")
+    def endpoint_group_display(self, obj):
+        """Display endpoint group information."""
+        return format_html(
+            '<strong>{}</strong><br><small>{}</small>',
+            obj.endpoint_group.display_name,
+            obj.endpoint_group.description[:30] + '...' if len(obj.endpoint_group.description) > 30 else obj.endpoint_group.description
+        )
+    
+    @display(description="Status")
+    def status_display(self, obj):
+        """Display status badge."""
+        if obj.is_enabled:
+            return format_html(
+                '<span style="background: #28a745; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">Enabled</span>'
+            )
+        else:
+            return format_html(
+                '<span style="background: #dc3545; color: white; padding: 2px 6px; border-radius: 3px; font-size: 11px;">Disabled</span>'
+            )
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Display creation date."""
+        return naturaltime(obj.created_at)

django_cfg/apps/payments/config/__init__.py

@@ -0,0 +1,87 @@
+"""
+Universal Payment Configuration.
+
+Modular configuration system for the payments module.
+"""
+
+# Core configuration classes
+from .settings import (
+    PaymentsSettings,
+    SecuritySettings,
+    RateLimitSettings,
+    BillingSettings,
+    CacheSettings,
+    NotificationSettings
+)
+
+# Provider configurations
+from .providers import (
+    PaymentProviderConfig,
+    NowPaymentsConfig,
+    StripeConfig,
+    CryptAPIConfig,
+    get_provider_config_class,
+    PROVIDER_CONFIGS
+)
+
+# Configuration module
+from .module import PaymentsCfgModule
+
+# Utility functions
+from .utils import (
+    get_payments_config,
+    get_provider_config,
+    get_nowpayments_config,
+    get_stripe_config,
+    is_payments_enabled,
+    is_feature_enabled,
+    get_enabled_providers,
+    get_provider_settings,
+    validate_provider_config,
+    get_rate_limit_settings,
+    get_cache_settings,
+    get_billing_settings,
+    reset_config_cache,
+    reload_config
+)
+
+# Backwards compatibility exports
+payments_config = PaymentsCfgModule()
+
+__all__ = [
+    # Core settings
+    'PaymentsSettings',
+    'SecuritySettings',
+    'RateLimitSettings',
+    'BillingSettings',
+    'CacheSettings',
+    'NotificationSettings',
+    
+    # Provider configurations
+    'PaymentProviderConfig',
+    'NowPaymentsConfig',
+    'StripeConfig',
+    'CryptAPIConfig',
+    'get_provider_config_class',
+    'PROVIDER_CONFIGS',
+    
+    # Configuration module
+    'PaymentsCfgModule',
+    'payments_config',
+    
+    # Utility functions
+    'get_payments_config',
+    'get_provider_config',
+    'get_nowpayments_config',
+    'get_stripe_config',
+    'is_payments_enabled',
+    'is_feature_enabled',
+    'get_enabled_providers',
+    'get_provider_settings',
+    'validate_provider_config',
+    'get_rate_limit_settings',
+    'get_cache_settings',
+    'get_billing_settings',
+    'reset_config_cache',
+    'reload_config',
+]

django_cfg/apps/payments/config/module.py

@@ -0,0 +1,162 @@
+"""
+Payment configuration module.
+
+Handles loading and managing payment configurations from project settings.
+"""
+
+from typing import Optional
+from pydantic import SecretStr
+import logging
+
+from django_cfg.modules.base import BaseCfgModule
+from .settings import PaymentsSettings
+from .providers import NowPaymentsConfig, StripeConfig, CryptAPIConfig, get_provider_config_class
+
+logger = logging.getLogger(__name__)
+
+
+class PaymentsCfgModule(BaseCfgModule):
+    """Payment configuration module for django-cfg."""
+    
+    def __init__(self):
+        super().__init__()
+        self.settings_class = PaymentsSettings
+        self._settings_cache = None
+    
+    def get_config(self) -> PaymentsSettings:
+        """Get payments configuration."""
+        if self._settings_cache is None:
+            project_config = super().get_config()
+            if project_config:
+                self._settings_cache = self.load_from_project_config(project_config)
+            else:
+                self._settings_cache = PaymentsSettings()
+        return self._settings_cache
+    
+    def reset_cache(self):
+        """Reset configuration cache."""
+        self._settings_cache = None
+    
+    def load_from_project_config(self, config) -> PaymentsSettings:
+        """Load payments configuration from main project config."""
+        # Get base settings
+        settings_dict = {}
+        
+        # Load from django-cfg config if available
+        if hasattr(config, 'enable_payments'):
+            settings_dict['enabled'] = config.enable_payments
+        
+        if hasattr(config, 'debug'):
+            settings_dict['debug_mode'] = config.debug
+        
+        # Load provider configurations from environment/config
+        providers = {}
+        
+        # Load NowPayments configuration
+        if self._has_provider_config(config, 'nowpayments'):
+            nowpayments_config = self._get_provider_config(config, 'nowpayments')
+            if nowpayments_config:
+                providers['nowpayments'] = nowpayments_config
+        
+        # Load Stripe configuration
+        if self._has_provider_config(config, 'stripe'):
+            stripe_config = self._get_provider_config(config, 'stripe')
+            if stripe_config:
+                providers['stripe'] = stripe_config
+        
+        # Load CryptAPI configuration
+        if self._has_provider_config(config, 'cryptapi'):
+            cryptapi_config = self._get_provider_config(config, 'cryptapi')
+            if cryptapi_config:
+                providers['cryptapi'] = cryptapi_config
+        
+        
+        settings_dict['providers'] = providers
+        
+        return PaymentsSettings(**settings_dict)
+    
+    def _has_provider_config(self, config, provider_name: str) -> bool:
+        """Check if provider configuration exists."""
+        return (
+            hasattr(config, 'api_keys') and 
+            hasattr(config.api_keys, provider_name)
+        )
+    
+    def _get_provider_config(self, config, provider_name: str) -> Optional[object]:
+        """Get provider configuration."""
+        try:
+            if provider_name == 'nowpayments':
+                return self._load_nowpayments_config(config)
+            elif provider_name == 'stripe':
+                return self._load_stripe_config(config)
+            elif provider_name == 'cryptapi':
+                return self._load_cryptapi_config(config)
+            else:
+                logger.warning(f"Unknown provider: {provider_name}")
+                return None
+        except Exception as e:
+            logger.error(f"Error loading {provider_name} config: {e}")
+            return None
+    
+    def _load_nowpayments_config(self, config) -> Optional[NowPaymentsConfig]:
+        """Load NowPayments configuration."""
+        nowpayments_config = config.api_keys.nowpayments
+        if not hasattr(nowpayments_config, 'api_key'):
+            return None
+        
+        return NowPaymentsConfig(
+            api_key=SecretStr(nowpayments_config.api_key),
+            public_key=SecretStr(nowpayments_config.public_key) if hasattr(nowpayments_config, 'public_key') else None,
+            sandbox=getattr(config, 'debug', True),
+            callback_url=self._build_callback_url(config, 'nowpayments'),
+            success_url=self._build_success_url(config),
+            cancel_url=self._build_cancel_url(config)
+        )
+    
+    def _load_stripe_config(self, config) -> Optional[StripeConfig]:
+        """Load Stripe configuration."""
+        stripe_config = config.api_keys.stripe
+        if not hasattr(stripe_config, 'secret_key'):
+            return None
+        
+        return StripeConfig(
+            api_key=SecretStr(stripe_config.secret_key),
+            publishable_key=SecretStr(stripe_config.publishable_key) if hasattr(stripe_config, 'publishable_key') else None,
+            webhook_secret=SecretStr(stripe_config.webhook_secret) if hasattr(stripe_config, 'webhook_secret') else None,
+            sandbox=getattr(config, 'debug', True)
+        )
+    
+    def _load_cryptapi_config(self, config) -> Optional[CryptAPIConfig]:
+        """Load CryptAPI configuration."""
+        cryptapi_config = config.api_keys.cryptapi
+        if not hasattr(cryptapi_config, 'own_address'):
+            return None
+        
+        return CryptAPIConfig(
+            api_key=SecretStr('dummy'),  # CryptAPI doesn't require API key
+            own_address=cryptapi_config.own_address,
+            callback_url=self._build_callback_url(config, 'cryptapi'),
+            convert_payments=getattr(cryptapi_config, 'convert_payments', True),
+            multi_token=getattr(cryptapi_config, 'multi_token', True),
+            priority=getattr(cryptapi_config, 'priority', 'default'),
+            sandbox=getattr(config, 'debug', True)
+        )
+    
+    
+    def _build_callback_url(self, config, provider: str) -> Optional[str]:
+        """Build webhook callback URL for provider."""
+        if hasattr(config, 'api_url') and config.api_url:
+            return f"{config.api_url}/api/payments/webhook/{provider}/"
+        return None
+    
+    def _build_success_url(self, config) -> Optional[str]:
+        """Build payment success URL."""
+        if hasattr(config, 'site_url') and config.site_url:
+            return f"{config.site_url}/payments/success/"
+        return None
+    
+    def _build_cancel_url(self, config) -> Optional[str]:
+        """Build payment cancel URL."""
+        if hasattr(config, 'site_url') and config.site_url:
+            return f"{config.site_url}/payments/cancel/"
+        return None

django_cfg/apps/payments/config/providers.py

@@ -0,0 +1,93 @@
+"""
+Payment provider configurations.
+
+Defines configuration classes for different payment providers.
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field, SecretStr
+
+
+class PaymentProviderConfig(BaseModel):
+    """Base configuration for payment providers."""
+    enabled: bool = True
+    sandbox: bool = Field(default=True, description="Use sandbox mode")
+    api_key: SecretStr = Field(description="Provider API key")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    max_retries: int = Field(default=3, description="Maximum retry attempts")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        return {
+            'api_key': self.api_key.get_secret_value(),
+            'sandbox': self.sandbox,
+            'timeout': self.timeout,
+            'max_retries': self.max_retries
+        }
+
+
+class NowPaymentsConfig(PaymentProviderConfig):
+    """NowPayments provider configuration."""
+    public_key: Optional[SecretStr] = Field(default=None, description="NowPayments public key")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    success_url: Optional[str] = Field(default=None, description="Payment success URL")
+    cancel_url: Optional[str] = Field(default=None, description="Payment cancel URL")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        config = super().get_config_dict()
+        config.update({
+            'callback_url': self.callback_url,
+            'success_url': self.success_url,
+            'cancel_url': self.cancel_url,
+        })
+        return config
+
+
+class StripeConfig(PaymentProviderConfig):
+    """Stripe provider configuration."""
+    publishable_key: Optional[SecretStr] = Field(default=None, description="Stripe publishable key")
+    webhook_secret: Optional[SecretStr] = Field(default=None, description="Stripe webhook secret")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        config = super().get_config_dict()
+        config.update({
+            'publishable_key': self.publishable_key.get_secret_value() if self.publishable_key else None,
+            'webhook_secret': self.webhook_secret.get_secret_value() if self.webhook_secret else None,
+        })
+        return config
+
+
+class CryptAPIConfig(PaymentProviderConfig):
+    """CryptAPI provider configuration."""
+    own_address: str = Field(description="Your crypto address where funds will be sent")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    convert_payments: bool = Field(default=True, description="Auto-convert payments to your address currency")
+    multi_token: bool = Field(default=True, description="Enable multi-token support")
+    priority: str = Field(default='default', description="Transaction priority (default, economic, priority)")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        config = super().get_config_dict()
+        config.update({
+            'own_address': self.own_address,
+            'callback_url': self.callback_url,
+            'convert_payments': self.convert_payments,
+            'multi_token': self.multi_token,
+            'priority': self.priority,
+        })
+        return config
+
+
+# Provider registry for easy access
+PROVIDER_CONFIGS = {
+    'nowpayments': NowPaymentsConfig,
+    'stripe': StripeConfig,
+    'cryptapi': CryptAPIConfig,
+}
+
+
+def get_provider_config_class(provider_name: str) -> Optional[type]:
+    """Get provider configuration class by name."""
+    return PROVIDER_CONFIGS.get(provider_name)

django_cfg/apps/payments/config/settings.py

@@ -0,0 +1,136 @@
+"""
+Universal payments module settings.
+
+Core settings for the payments system including security, rate limiting, billing, etc.
+"""
+
+from typing import Dict
+from pydantic import BaseModel, Field
+
+from .providers import PaymentProviderConfig
+
+
+class SecuritySettings(BaseModel):
+    """Security-related payment settings."""
+    api_key_length: int = Field(default=32, description="API key length in characters")
+    api_key_prefix: str = Field(default="ak_", description="API key prefix")
+    min_balance_threshold: float = Field(default=0.0, description="Minimum balance threshold")
+    auto_create_api_keys: bool = Field(default=True, description="Auto-create API keys for new users")
+
+
+class RateLimitSettings(BaseModel):
+    """Rate limiting settings."""
+    default_rate_limit_per_hour: int = Field(default=1000, description="Default API rate limit per hour")
+    default_rate_limit_per_day: int = Field(default=10000, description="Default API rate limit per day")
+    burst_limit_multiplier: float = Field(default=2.0, description="Burst limit multiplier")
+    sliding_window_size: int = Field(default=3600, description="Sliding window size in seconds")
+
+
+class BillingSettings(BaseModel):
+    """Billing and subscription settings."""
+    auto_bill_subscriptions: bool = Field(default=True, description="Automatically bill subscriptions")
+    billing_grace_period_hours: int = Field(default=24, description="Grace period for failed billing")
+    retry_failed_payments: bool = Field(default=True, description="Retry failed payments")
+    max_payment_retries: int = Field(default=3, description="Maximum payment retry attempts")
+    min_payment_amount_usd: float = Field(default=1.0, description="Minimum payment amount in USD")
+    max_payment_amount_usd: float = Field(default=50000.0, description="Maximum payment amount in USD")
+
+
+class CacheSettings(BaseModel):
+    """Cache timeout settings."""
+    cache_timeout_access_check: int = Field(default=60, description="Cache timeout for access checks (seconds)")
+    cache_timeout_user_balance: int = Field(default=300, description="Cache timeout for user balance (seconds)")
+    cache_timeout_subscriptions: int = Field(default=600, description="Cache timeout for subscriptions (seconds)")
+    cache_timeout_provider_status: int = Field(default=1800, description="Cache timeout for provider status (seconds)")
+    cache_timeout_currency_rates: int = Field(default=3600, description="Cache timeout for currency rates (seconds)")
+
+
+class NotificationSettings(BaseModel):
+    """Notification settings."""
+    send_payment_confirmations: bool = Field(default=True, description="Send payment confirmation emails")
+    send_subscription_renewals: bool = Field(default=True, description="Send subscription renewal notifications")
+    send_balance_alerts: bool = Field(default=True, description="Send low balance alerts")
+    send_api_key_alerts: bool = Field(default=True, description="Send API key security alerts")
+    webhook_timeout: int = Field(default=30, description="Webhook timeout in seconds")
+
+
+class PaymentsSettings(BaseModel):
+    """Universal payments module settings."""
+    
+    # General settings
+    enabled: bool = Field(default=True, description="Enable payments module")
+    debug_mode: bool = Field(default=False, description="Enable debug mode for payments")
+    
+    # Component settings
+    security: SecuritySettings = Field(default_factory=SecuritySettings)
+    rate_limits: RateLimitSettings = Field(default_factory=RateLimitSettings)
+    billing: BillingSettings = Field(default_factory=BillingSettings)
+    cache: CacheSettings = Field(default_factory=CacheSettings)
+    notifications: NotificationSettings = Field(default_factory=NotificationSettings)
+    
+    # Provider configurations
+    providers: Dict[str, PaymentProviderConfig] = Field(default_factory=dict, description="Payment provider configurations")
+    
+    # Feature flags
+    enable_crypto_payments: bool = Field(default=True, description="Enable cryptocurrency payments")
+    enable_fiat_payments: bool = Field(default=True, description="Enable fiat currency payments")
+    enable_subscription_system: bool = Field(default=True, description="Enable subscription system")
+    enable_balance_system: bool = Field(default=True, description="Enable user balance system")
+    enable_api_key_system: bool = Field(default=True, description="Enable API key system")
+    enable_webhook_processing: bool = Field(default=True, description="Enable webhook processing")
+    
+    # Backwards compatibility properties
+    @property
+    def auto_create_api_keys(self) -> bool:
+        """Backwards compatibility for auto_create_api_keys."""
+        return self.security.auto_create_api_keys
+    
+    @property
+    def min_balance_threshold(self) -> float:
+        """Backwards compatibility for min_balance_threshold."""
+        return self.security.min_balance_threshold
+    
+    @property
+    def default_rate_limit_per_hour(self) -> int:
+        """Backwards compatibility for default_rate_limit_per_hour."""
+        return self.rate_limits.default_rate_limit_per_hour
+    
+    @property
+    def default_rate_limit_per_day(self) -> int:
+        """Backwards compatibility for default_rate_limit_per_day."""
+        return self.rate_limits.default_rate_limit_per_day
+    
+    @property
+    def api_key_length(self) -> int:
+        """Backwards compatibility for api_key_length."""
+        return self.security.api_key_length
+    
+    @property
+    def api_key_prefix(self) -> str:
+        """Backwards compatibility for api_key_prefix."""
+        return self.security.api_key_prefix
+    
+    @property
+    def auto_bill_subscriptions(self) -> bool:
+        """Backwards compatibility for auto_bill_subscriptions."""
+        return self.billing.auto_bill_subscriptions
+    
+    @property
+    def billing_grace_period_hours(self) -> int:
+        """Backwards compatibility for billing_grace_period_hours."""
+        return self.billing.billing_grace_period_hours
+    
+    @property
+    def cache_timeout_access_check(self) -> int:
+        """Backwards compatibility for cache_timeout_access_check."""
+        return self.cache.cache_timeout_access_check
+    
+    @property
+    def cache_timeout_user_balance(self) -> int:
+        """Backwards compatibility for cache_timeout_user_balance."""
+        return self.cache.cache_timeout_user_balance
+    
+    @property
+    def cache_timeout_subscriptions(self) -> int:
+        """Backwards compatibility for cache_timeout_subscriptions."""
+        return self.cache.cache_timeout_subscriptions