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

django_cfg/apps/payments/admin_interface/views/payment_views.py

@@ -0,0 +1,259 @@
+"""
+Payment Template Views for Universal Payment System v2.0.
+
+Django template views for payment forms and status pages.
+"""
+
+from django.views.generic import TemplateView, DetailView
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.shortcuts import get_object_or_404
+from django.http import JsonResponse
+from django.utils import timezone
+
+from ...models import UniversalPayment
+from ...services.core.payment_service import PaymentService
+from ...services.core.currency_service import CurrencyService
+from ...services.integrations.providers_config import get_all_providers_info
+
+
+class PaymentFormView(LoginRequiredMixin, TemplateView):
+    """
+    Payment creation form view.
+    
+    Displays a form for creating new payments with provider selection
+    and real-time currency conversion.
+    """
+    template_name = 'payments/payment_form.html'
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Add form data
+        context.update({
+            'page_title': 'Create Payment',
+            'page_subtitle': 'Process a payment through our universal payment system',
+        })
+        
+        return context
+    
+    def post(self, request, *args, **kwargs):
+        """Handle AJAX payment creation."""
+        if not request.headers.get('Content-Type', '').startswith('application/json'):
+            return super().get(request, *args, **kwargs)
+        
+        try:
+            import json
+            data = json.loads(request.body)
+            
+            # Create payment using service
+            payment_service = PaymentService()
+            result = payment_service.create_payment(
+                user_id=request.user.id,
+                amount_usd=float(data.get('amount', 0)),
+                currency_code=data.get('currency', 'USD'),
+                provider=data.get('provider'),
+                callback_url=data.get('callback_url')
+            )
+            
+            if result.success:
+                return JsonResponse({
+                    'success': True,
+                    'payment': {
+                        'id': str(result.data.id),
+                        'external_id': result.data.external_id,
+                        'status': result.data.status,
+                        'amount_usd': result.data.amount_usd,
+                        'currency_code': result.data.currency_code,
+                        'provider': result.data.provider,
+                        'payment_url': result.data.payment_url,
+                        'qr_code_url': result.data.qr_code_url,
+                    }
+                })
+            else:
+                return JsonResponse({
+                    'success': False,
+                    'error': result.error_message
+                }, status=400)
+                
+        except Exception as e:
+            return JsonResponse({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
+
+class PaymentStatusView(DetailView):
+    """
+    Payment status tracking view.
+    
+    Displays payment status with real-time updates and timeline.
+    """
+    model = UniversalPayment
+    template_name = 'payments/payment_status.html'
+    context_object_name = 'payment'
+    
+    def get_object(self, queryset=None):
+        """Get payment by ID with optimized query."""
+        if queryset is None:
+            queryset = self.get_queryset()
+        
+        # Get payment ID from URL
+        payment_id = self.kwargs.get('pk')
+        
+        return get_object_or_404(
+            queryset.select_related('currency', 'user')
+                   .prefetch_related('transactions'),
+            id=payment_id
+        )
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        payment = self.object
+        
+        # Add page metadata
+        context.update({
+            'page_title': f'Payment #{payment.external_id or str(payment.id)[:8]}',
+            'page_subtitle': 'Track your payment progress in real-time',
+        })
+        
+        return context
+    
+    def get(self, request, *args, **kwargs):
+        """Handle both template and AJAX requests."""
+        self.object = self.get_object()
+        
+        # Handle AJAX requests for status updates
+        if request.headers.get('Accept') == 'application/json':
+            payment = self.object
+            
+            return JsonResponse({
+                'id': str(payment.id),
+                'external_id': payment.external_id,
+                'status': payment.status,
+                'status_display': payment.get_status_display(),
+                'amount_usd': payment.amount_usd,
+                'amount_crypto': str(payment.amount_crypto) if payment.amount_crypto else None,
+                'currency_code': payment.currency.code,
+                'provider': payment.provider,
+                'network': payment.network,
+                'created_at': payment.created_at.isoformat(),
+                'updated_at': payment.updated_at.isoformat(),
+                'confirmed_at': payment.confirmed_at.isoformat() if payment.confirmed_at else None,
+                'payment_url': payment.payment_url,
+                'qr_code_url': payment.qr_code_url,
+                'exchange_rate': str(payment.exchange_rate) if payment.exchange_rate else None,
+            })
+        
+        # Regular template response
+        return super().get(request, *args, **kwargs)
+
+
+class PaymentListView(LoginRequiredMixin, TemplateView):
+    """
+    Payment list view with filtering and search.
+    
+    Displays a paginated list of payments with advanced filtering options.
+    """
+    template_name = 'payments/payment_list.html'
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Add page metadata
+        context.update({
+            'page_title': 'Payment History',
+            'page_subtitle': 'View and manage your payment transactions',
+        })
+        
+        return context
+
+
+class PaymentDashboardView(LoginRequiredMixin, TemplateView):
+    """
+    Main payment dashboard view.
+    
+    Displays payment statistics, recent activity, and quick actions.
+    """
+    template_name = 'payments/payment_dashboard.html'
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Get payment statistics
+        user_payments = UniversalPayment.objects.filter(user=self.request.user)
+        
+        stats = {
+            'total_payments': user_payments.count(),
+            'completed_payments': user_payments.filter(status='completed').count(),
+            'pending_payments': user_payments.filter(status__in=['pending', 'processing']).count(),
+            'failed_payments': user_payments.filter(status__in=['failed', 'cancelled']).count(),
+            'total_amount': sum(p.amount_usd for p in user_payments.filter(status='completed')),
+            'recent_payments': user_payments.order_by('-created_at')[:5],
+        }
+        
+        # Add page metadata
+        context.update({
+            'page_title': 'Payment Dashboard',
+            'page_subtitle': 'Overview of your payment activity',
+            'stats': stats,
+        })
+        
+        return context
+
+
+class CurrencyConverterView(TemplateView):
+    """
+    Currency conversion tool view.
+    
+    Provides real-time currency conversion rates and calculator.
+    """
+    template_name = 'payments/currency_converter.html'
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Add page metadata
+        context.update({
+            'page_title': 'Currency Converter',
+            'page_subtitle': 'Real-time currency conversion rates',
+        })
+        
+        return context
+    
+    def post(self, request, *args, **kwargs):
+        """Handle AJAX conversion requests."""
+        if not request.headers.get('Content-Type', '').startswith('application/json'):
+            return super().get(request, *args, **kwargs)
+        
+        try:
+            import json
+            data = json.loads(request.body)
+            
+            # Use currency service for conversion
+            currency_service = CurrencyService()
+            result = currency_service.convert_currency(
+                amount=float(data.get('amount', 0)),
+                from_currency=data.get('from_currency', 'USD'),
+                to_currency=data.get('to_currency', 'BTC')
+            )
+            
+            if result.success:
+                return JsonResponse({
+                    'success': True,
+                    'converted_amount': result.data.converted_amount,
+                    'exchange_rate': result.data.exchange_rate,
+                    'from_currency': result.data.from_currency,
+                    'to_currency': result.data.to_currency,
+                    'timestamp': timezone.now().isoformat(),
+                })
+            else:
+                return JsonResponse({
+                    'success': False,
+                    'error': result.error_message
+                }, status=400)
+                
+        except Exception as e:
+            return JsonResponse({
+                'success': False,
+                'error': str(e)
+            }, status=500)

django_cfg/apps/payments/admin_interface/views/webhook_dashboard.py

@@ -0,0 +1,37 @@
+"""
+Webhook dashboard template view.
+
+Simple dashboard for monitoring webhook activity and provider status.
+"""
+
+from django.views.generic import TemplateView
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.decorators import method_decorator
+from django.http import JsonResponse
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class WebhookDashboardView(TemplateView):
+    """
+    Webhook dashboard for monitoring and management.
+    
+    Provides a simple interface for:
+    - Viewing webhook provider configurations
+    - Monitoring webhook activity
+    - Testing webhook endpoints
+    - Checking ngrok status
+    """
+    
+    template_name = 'payments/webhook_dashboard.html'
+    
+    def get_context_data(self, **kwargs):
+        """Add dashboard context data."""
+        context = super().get_context_data(**kwargs)
+        
+        # Basic context - the real data comes from API endpoints
+        context.update({
+            'page_title': 'Webhook Dashboard',
+            'auto_refresh': True,  # Enable auto-refresh
+        })
+        
+        return context

django_cfg/apps/payments/apps.py

@@ -1,22 +1,47 @@
 """
-Django app configuration for universal payments.
+Universal Payment System v2.0 - Django App Configuration.
+
+Simplified payment system focused on NowPayments with extensible architecture.
 """
 
 from django.apps import AppConfig
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("payments")
 
 
 class PaymentsConfig(AppConfig):
-    """Universal payments app configuration."""
+    """Payment system app configuration."""
     
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'django_cfg.apps.payments'
-    label = 'django_cfg_payments'
-    verbose_name = 'Universal Payments'
+    verbose_name = 'Universal Payment System v2.0'
     
     def ready(self):
-        """Called when the app is ready."""
-        # Import signals if any
+        """Initialize payment system when Django starts."""
+        logger.info("Initializing Universal Payment System v2.0")
+        
+        # Import signals to register them
+        try:
+            from . import signals  # noqa: F401
+            logger.info("Payment signals registered successfully")
+        except ImportError as e:
+            logger.warning(f"Failed to import payment signals: {e}")
+        
+        # Initialize provider registry
+        try:
+            from .services.providers.registry import get_provider_registry
+            registry = get_provider_registry()
+            logger.info(f"Provider registry initialized with {len(registry.get_available_providers())} providers")
+        except Exception as e:
+            logger.error(f"Failed to initialize provider registry: {e}")
+        
+        # Initialize cache services
         try:
-            from . import signals  # noqa
-        except ImportError:
-            pass
+            from .services.cache import get_cache_service
+            cache_service = get_cache_service()
+            logger.info("Cache service initialized successfully")
+        except Exception as e:
+            logger.warning(f"Cache service initialization failed: {e}")
+        
+        logger.info("Universal Payment System v2.0 ready")

django_cfg/apps/payments/config/__init__.py

@@ -1,65 +1,42 @@
 """
-Universal Payment Configuration.
+Configuration module for the Universal Payment System v2.0.
 
-Modular configuration system for the payments module.
+Provides clean separation between:
+- django-cfg integration (static config)
+- Constance integration (dynamic config)
+- Configuration utilities and helpers
 """
 
-# Core configuration classes
-from .settings import PaymentsSettings
-
-# Import unified settings from models.payments
-from django_cfg.models.payments import (
-    SecuritySettings,
-    RateLimitSettings,
-    NotificationSettings,
-    SubscriptionSettings
+# Django-cfg integration
+from .django_cfg_integration import (
+    PaymentsConfigMixin,
+    get_payments_config,
+    is_payments_enabled,
 )
 
-# Provider configurations - import from models.payments
-from django_cfg.models.payments import (
-    PaymentProviderConfig,
-    NowPaymentsConfig,
-    StripeConfig,
-    CryptAPIConfig
+# Constance integration (safe - no Django models)
+from .constance import (
+    get_django_cfg_payments_constance_fields,
+    PaymentConstanceSettings,
 )
 
-# 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
+# Configuration helpers
+from .helpers import (
+    MiddlewareConfigHelper,
+    CacheConfigHelper,
 )
 
-# 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
+    # Django-cfg integration
+    'PaymentsConfigMixin',
     'get_payments_config',
-    'get_provider_config',
     'is_payments_enabled',
+    
+    # Constance integration
+    'get_django_cfg_payments_constance_fields',
+    'PaymentConstanceSettings',
+    
+    # Configuration helpers
+    'MiddlewareConfigHelper',
+    'CacheConfigHelper',
 ]

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

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

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

@@ -0,0 +1,69 @@
+"""
+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'
+        ),
+    ]