django-cfg 1.2.22__py3-none-any.whl → 1.2.25__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,65 @@
+"""
+Universal Payment Configuration.
+
+Modular configuration system for the payments module.
+"""
+
+# Core configuration classes
+from .settings import PaymentsSettings
+
+# Import unified settings from models.payments
+from django_cfg.models.payments import (
+    SecuritySettings,
+    RateLimitSettings,
+    NotificationSettings,
+    SubscriptionSettings
+)
+
+# Provider configurations - import from models.payments
+from django_cfg.models.payments import (
+    PaymentProviderConfig,
+    NowPaymentsConfig,
+    StripeConfig,
+    CryptAPIConfig
+)
+
+# Local provider configs (additional to models.payments)
+from .providers import CryptomusConfig
+
+# Configuration module
+from .module import PaymentsCfgModule
+
+# Utility functions
+from .utils import (
+    get_payments_config,
+    get_provider_config,
+    is_payments_enabled
+)
+
+# Backwards compatibility exports
+payments_config = PaymentsCfgModule()
+
+__all__ = [
+    # Core settings
+    'PaymentsSettings',
+    'SecuritySettings',
+    'RateLimitSettings',
+    'NotificationSettings',
+    'SubscriptionSettings',
+    
+    # Provider configurations
+    'PaymentProviderConfig',
+    'NowPaymentsConfig',
+    'StripeConfig',
+    'CryptAPIConfig',
+    'CryptomusConfig',
+    
+    # Configuration module
+    'PaymentsCfgModule',
+    'payments_config',
+    
+    # Utility functions
+    'get_payments_config',
+    'get_provider_config',
+    'is_payments_enabled',
+]

django_cfg/apps/payments/config/module.py

@@ -0,0 +1,70 @@
+"""
+Payment configuration module.
+
+Handles loading and managing payment configurations from project settings.
+"""
+
+from typing import Optional
+import logging
+
+from django_cfg.modules.base import BaseCfgModule
+from .settings import PaymentsSettings
+
+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."""
+        
+        # Load from new PaymentsConfig if available
+        if hasattr(config, 'payments') and config.payments:
+            # Convert List[PaymentProviderConfig] to Dict[str, PaymentProviderConfig]
+            providers = {}
+            for provider in config.payments.providers:
+                providers[provider.name] = provider
+            
+            return PaymentsSettings(
+                enabled=config.payments.enabled,
+                debug_mode=getattr(config, 'debug', False),
+                providers=providers,
+                security=config.payments.security,
+                rate_limits=config.payments.rate_limits,
+                notifications=config.payments.notifications,
+                subscriptions=config.payments.subscriptions,
+                enable_crypto_payments=config.payments.enable_crypto_payments,
+                enable_fiat_payments=config.payments.enable_fiat_payments,
+                enable_subscription_system=config.payments.enable_subscription_system,
+                enable_balance_system=config.payments.enable_balance_system,
+                enable_api_key_system=config.payments.enable_api_key_system,
+                enable_webhook_processing=config.payments.enable_webhook_processing,
+                enable_billing_utils=config.payments.enable_billing_utils
+            )
+        else:
+            # Fallback: Return default settings if no PaymentsConfig found
+            logger.warning("No PaymentsConfig found, using default settings")
+            return PaymentsSettings(
+                enabled=False,
+                debug_mode=getattr(config, 'debug', False)
+            )

django_cfg/apps/payments/config/providers.py

@@ -0,0 +1,115 @@
+"""
+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
+
+
+class CryptomusConfig(PaymentProviderConfig):
+    """Cryptomus provider configuration."""
+    merchant_uuid: str = Field(description="Cryptomus merchant UUID")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    success_url: Optional[str] = Field(default=None, description="Payment success URL")
+    fail_url: Optional[str] = Field(default=None, description="Payment fail URL")
+    network: Optional[str] = Field(default=None, description="Default network for payments")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        config = super().get_config_dict()
+        config.update({
+            'merchant_uuid': self.merchant_uuid,
+            'callback_url': self.callback_url,
+            'success_url': self.success_url,
+            'fail_url': self.fail_url,
+            'network': self.network,
+        })
+        return config
+
+
+# Provider registry for easy access
+PROVIDER_CONFIGS = {
+    'nowpayments': NowPaymentsConfig,
+    'stripe': StripeConfig,
+    'cryptapi': CryptAPIConfig,
+    'cryptomus': CryptomusConfig,
+}
+
+
+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,96 @@
+"""
+Universal payments module settings.
+
+Core settings for the payments system - now using unified models from django_cfg.models.payments.
+"""
+
+from typing import Dict, List
+from pydantic import BaseModel, Field
+
+# Import unified types from models/payments.py
+from django_cfg.models.payments import (
+    PaymentProviderConfig, 
+    SecuritySettings, 
+    RateLimitSettings, 
+    NotificationSettings,
+    SubscriptionSettings
+)
+
+
+class PaymentsSettings(BaseModel):
+    """Universal payments module settings - unified with PaymentsConfig."""
+    
+    # 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 - using unified models
+    security: SecuritySettings = Field(default_factory=SecuritySettings)
+    rate_limits: RateLimitSettings = Field(default_factory=RateLimitSettings)
+    notifications: NotificationSettings = Field(default_factory=NotificationSettings)
+    subscriptions: SubscriptionSettings = Field(default_factory=SubscriptionSettings)
+    
+    # Provider configurations - now accepts List instead of Dict
+    providers: Dict[str, PaymentProviderConfig] = Field(
+        default_factory=dict, 
+        description="Payment provider configurations (Dict for backwards compatibility)"
+    )
+    
+    # Feature flags - copied from PaymentsConfig for consistency
+    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")
+    enable_billing_utils: bool = Field(default=True, description="Enable billing utility functions")
+    
+    # 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 require_api_key(self) -> bool:
+        """Backwards compatibility for require_api_key."""
+        return self.security.require_api_key
+    
+    @property
+    def min_balance_threshold(self) -> float:
+        """Backwards compatibility for min_balance_threshold."""
+        return float(self.security.min_balance_threshold)
+    
+    @property
+    def requests_per_hour(self) -> int:
+        """Backwards compatibility for requests_per_hour."""
+        return self.rate_limits.requests_per_hour
+    
+    @property
+    def webhook_timeout(self) -> int:
+        """Backwards compatibility for webhook_timeout."""
+        return self.notifications.webhook_timeout
+    
+    # Utility methods
+    def is_provider_enabled(self, provider_name: str) -> bool:
+        """Check if a specific provider is enabled."""
+        provider = self.providers.get(provider_name)
+        return provider and provider.enabled if provider else False
+    
+    def get_enabled_providers(self) -> List[str]:
+        """Get list of enabled provider names."""
+        return [name for name, config in self.providers.items() if config.enabled]
+    
+    def get_provider_config(self, provider_name: str) -> PaymentProviderConfig:
+        """Get configuration for a specific provider."""
+        return self.providers.get(provider_name)
+
+
+__all__ = [
+    'PaymentsSettings',
+    'SecuritySettings',
+    'RateLimitSettings', 
+    'NotificationSettings',
+    'SubscriptionSettings',
+    'PaymentProviderConfig'
+]

django_cfg/apps/payments/config/utils.py

@@ -0,0 +1,52 @@
+"""
+Configuration utility functions.
+
+Helper functions for working with payment configurations.
+"""
+
+from typing import Optional
+import logging
+
+from .module import PaymentsCfgModule
+from .settings import PaymentsSettings
+from django_cfg.models.payments import PaymentProviderConfig
+
+logger = logging.getLogger(__name__)
+
+# Global payments configuration instance
+_payments_config = PaymentsCfgModule()
+
+
+def get_payments_config() -> PaymentsSettings:
+    """Get current payments configuration."""
+    return _payments_config.get_config()
+
+
+def get_provider_config(provider_name: str) -> Optional[PaymentProviderConfig]:
+    """Get configuration for specific payment provider."""
+    config = get_payments_config()
+    return config.providers.get(provider_name)
+
+
+def is_payments_enabled() -> bool:
+    """Check if payments module is enabled."""
+    try:
+        config = get_payments_config()
+        return config.enabled
+    except Exception as e:
+        logger.warning(f"Failed to check payments status: {e}")
+        return False
+
+
+def reset_config_cache():
+    """Reset configuration cache."""
+    global _payments_config
+    _payments_config.reset_cache()
+
+
+__all__ = [
+    'get_payments_config',
+    'get_provider_config', 
+    'is_payments_enabled',
+    'reset_config_cache'
+]