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

django_cfg/apps/payments/admin_interface/views/api/webhook_admin.py

@@ -23,9 +23,14 @@ from django_cfg.apps.payments.admin_interface.serializers import (
     WebhookActionSerializer,
     WebhookActionResultSerializer,
 )
-from django_cfg.apps.payments.services.core.webhook_service import WebhookService
 from django_cfg.apps.payments.models import UniversalPayment
 from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.services.integrations.ngrok_service import (
+    get_all_webhook_urls, 
+    get_api_base_url, 
+    is_ngrok_available
+)
+from django_cfg.apps.payments.services.core.webhook_service import WebhookService
 
 logger = get_logger("admin_webhook_api")
 
@@ -41,31 +46,57 @@ class AdminWebhookViewSet(AdminReadOnlyViewSet):
     # No model - this is for webhook configuration data
     serializer_class = WebhookStatsSerializer
     
+    def __init__(self, **kwargs):
+        """Initialize with ngrok service."""
+        super().__init__(**kwargs)
+        
+        self.get_webhook_urls = get_all_webhook_urls
+        self.get_base_url = get_api_base_url
+        self.is_ngrok_active = is_ngrok_available
+    
     def list(self, request):
-        """List webhook providers and configurations."""
-        # Mock webhook provider data - replace with real configuration
-        providers_data = [
-            {
-                'name': 'nowpayments',
-                'display_name': 'NowPayments',
-                'enabled': True,
-                'webhook_url': 'https://api.nowpayments.io/v1/webhooks',
+        """List webhook providers and configurations with real ngrok URLs."""
+        # Get real webhook URLs
+        webhook_urls = self.get_webhook_urls()
+        base_url = self.get_base_url()
+        ngrok_active = self.is_ngrok_active()
+        
+        # Get real provider data based on actual payments
+        active_providers = UniversalPayment.objects.values('provider').distinct()
+        
+        providers_data = []
+        for provider_data in active_providers:
+            provider_name = provider_data['provider']
+            provider_payments = UniversalPayment.objects.filter(provider=provider_name)
+            
+            # Calculate real statistics
+            total_payments = provider_payments.count()
+            last_payment = provider_payments.order_by('-created_at').first()
+            
+            provider_info = {
+                'name': provider_name,
+                'display_name': provider_name.title(),
+                'enabled': total_payments > 0,
+                'webhook_url': webhook_urls.get(provider_name, f"{base_url}/api/webhooks/{provider_name}/"),
                 'supported_events': ['payment.created', 'payment.completed', 'payment.failed'],
-                'last_ping': timezone.now() - timedelta(minutes=5),
-                'status': 'active'
-            },
-            {
-                'name': 'stripe',
-                'display_name': 'Stripe',
-                'enabled': False,
-                'webhook_url': 'https://api.stripe.com/v1/webhooks',
-                'supported_events': ['payment_intent.succeeded', 'payment_intent.payment_failed'],
-                'last_ping': None,
-                'status': 'inactive'
+                'last_ping': last_payment.created_at if last_payment else None,
+                'status': 'active' if total_payments > 0 else 'inactive',
+                'ngrok_active': ngrok_active,
+                'base_url': base_url
+            }
+            providers_data.append(provider_info)
+        
+        # Add ngrok status to response
+        response_data = {
+            'providers': providers_data,
+            'ngrok_status': {
+                'active': ngrok_active,
+                'base_url': base_url,
+                'webhook_urls': webhook_urls
             }
-        ]
+        }
         
-        serializer = self.get_serializer(providers_data, many=True)
+        serializer = self.get_serializer(response_data)
         return Response(serializer.data)
     
     @action(detail=False, methods=['get'])
@@ -79,39 +110,34 @@ class AdminWebhookViewSet(AdminReadOnlyViewSet):
         
         # Mock webhook stats based on real payment data
         stats_data = {
-            'total_events': total_payments * 2,  # Assume 2 events per payment on average
-            'successful_events': int(total_payments * 1.8),  # 90% success rate
-            'failed_events': int(total_payments * 0.2),  # 10% failure rate
+            'total': total_payments * 2,  # Assume 2 events per payment on average
+            'successful': int(total_payments * 1.8),  # 90% success rate
+            'failed': int(total_payments * 0.2),  # 10% failure rate
+            'pending': 0,  # No pending events for now
             'success_rate': 90.0,
-            'recent_events': recent_payments * 2,
             'providers': {
                 'nowpayments': {
                     'total': int(total_payments * 0.7),
                     'successful': int(total_payments * 0.65),
                     'failed': int(total_payments * 0.05),
+                    'pending': 0,
                     'success_rate': 92.8
                 },
                 'stripe': {
                     'total': int(total_payments * 0.3),
                     'successful': int(total_payments * 0.28),
                     'failed': int(total_payments * 0.02),
+                    'pending': 0,
                     'success_rate': 93.3
                 }
             },
-            'events_by_type': {
-                'payment.created': int(total_payments * 1.0),
-                'payment.completed': int(total_payments * 0.8),
-                'payment.failed': int(total_payments * 0.2),
+            'last_24h': {
+                'total': recent_payments * 2,
+                'successful': int(recent_payments * 1.8),
+                'failed': int(recent_payments * 0.2),
             },
-            'recent_activity': [
-                {
-                    'timestamp': timezone.now() - timedelta(minutes=i*5),
-                    'event_type': 'payment.created' if i % 3 == 0 else 'payment.completed',
-                    'provider': 'nowpayments' if i % 2 == 0 else 'stripe',
-                    'status': 'success' if i % 4 != 0 else 'failed'
-                }
-                for i in range(10)
-            ]
+            'avg_response_time': 150.5,  # milliseconds
+            'max_response_time': 2500,  # milliseconds
         }
         
         serializer = self.get_serializer(stats_data)
@@ -131,8 +157,17 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
     filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
     filterset_fields = ['event_type', 'status', 'provider']
     search_fields = ['event_type', 'webhook_url']
-    ordering_fields = ['created_at', 'event_type', 'status']
-    ordering = ['-created_at']
+    ordering_fields = ['timestamp', 'event_type', 'status']
+    ordering = ['-timestamp']
+    
+    def __init__(self, **kwargs):
+        """Initialize with webhook and ngrok services."""
+        super().__init__(**kwargs)
+        
+        self.webhook_service = WebhookService()
+        self.get_webhook_urls = get_all_webhook_urls
+        self.get_base_url = get_api_base_url
+        self.is_ngrok_active = is_ngrok_available
     
     def get_queryset(self):
         """Get webhook events queryset."""
@@ -140,12 +175,12 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
         # In real implementation, this would return WebhookEvent.objects.all()
         return UniversalPayment.objects.none()
     
-    def list(self, request):
+    def list(self, request, webhook_pk=None):
         """List webhook events with filtering and pagination."""
         # Get filter parameters
-        event_type = request.query_params.get('event_type')
-        status_filter = request.query_params.get('status')
-        provider = request.query_params.get('provider')
+        event_type = request.GET.get('event_type')
+        status_filter = request.GET.get('status')
+        provider = request.GET.get('provider')
         
         # Get real payment data to generate realistic mock events
         payments = UniversalPayment.objects.all()[:50]  # Limit for performance
@@ -157,23 +192,28 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
             event_types = ['payment.created', 'payment.completed'] if payment.status == 'completed' else ['payment.created']
             
             for event_type_name in event_types:
+                # Create payload for the event
+                payload = {
+                    'payment_id': str(payment.id),
+                    'amount': str(payment.amount_usd),
+                    'currency': payment.currency.code if payment.currency else payment.currency_code,
+                    'status': payment.status,
+                    'timestamp': payment.created_at.isoformat()
+                }
+                
                 event = {
-                    'id': f"evt_{payment.id}_{event_type_name.split('.')[1]}",
+                    'id': int(str(hash(f"{payment.id}_{event_type_name}_{i}"))[:8], 16),
+                    'provider': payment.provider,
                     'event_type': event_type_name,
-                    'webhook_url': f'https://example.com/webhook/{payment.id}',
                     'status': 'success' if i % 5 != 0 else 'failed',
-                    'provider': 'nowpayments' if i % 2 == 0 else 'stripe',
-                    'created_at': payment.created_at,
-                    'response_code': 200 if i % 5 != 0 else 500,
-                    'response_time': f"{50 + (i % 200)}ms",
-                    'attempts': 1 if i % 5 != 0 else 3,
-                    'payload': {
-                        'payment_id': str(payment.id),
-                        'amount': str(payment.amount),
-                        'currency': payment.currency,
-                        'status': payment.status,
-                        'timestamp': payment.created_at.isoformat()
-                    }
+                    'timestamp': payment.created_at,
+                    'payload_size': len(str(payload)),
+                    'response_time': 50 + (i % 200),
+                    'retry_count': 0 if i % 5 != 0 else 2,
+                    'error_message': '' if i % 5 != 0 else 'Connection timeout',
+                    'payload_preview': str(payload)[:200],
+                    'response_status_code': 200 if i % 5 != 0 else 500,
+                    'webhook_url': self.get_webhook_urls().get(payment.provider, f"{self.get_base_url()}/api/webhooks/{payment.provider}/"),
                 }
                 
                 # Apply filters
@@ -186,12 +226,13 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
                     
                 events.append(event)
         
-        # Sort by created_at descending
-        events.sort(key=lambda x: x['created_at'], reverse=True)
+        # Sort by timestamp descending (only if events exist)
+        if events:
+            events.sort(key=lambda x: x.get('timestamp', timezone.now()), reverse=True)
         
         # Pagination
         page_size = 20
-        page = int(request.query_params.get('page', 1))
+        page = int(request.GET.get('page', 1))
         start = (page - 1) * page_size
         end = start + page_size
         paginated_events = events[start:end]
@@ -202,7 +243,12 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
             'page': page,
             'per_page': page_size,
             'has_next': end < len(events),
-            'has_previous': page > 1
+            'has_previous': page > 1,
+            'ngrok_status': {
+                'active': self.is_ngrok_active(),
+                'base_url': self.get_base_url(),
+                'webhook_urls': self.get_webhook_urls()
+            }
         }
         
         serializer = self.get_serializer(response_data)

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

@@ -51,7 +51,7 @@ class PaymentDetailView(AdminTemplateViewMixin, LoginRequiredMixin, DetailView):
     
     def get_queryset(self):
         """Optimized queryset with related objects."""
-        return UniversalPayment.objects.select_related('user')
+        return UniversalPayment.objects.select_related('user', 'currency', 'network')
     
     def get_context_data(self, **kwargs):
         """Add detail context data."""
@@ -59,7 +59,11 @@ class PaymentDetailView(AdminTemplateViewMixin, LoginRequiredMixin, DetailView):
         
         payment = self.get_object()
         
+        # Force refresh from database to get latest data
+        payment.refresh_from_db()
+        
         context.update({
+            'payment': payment,
             'page_title': f'Payment {payment.internal_payment_id or payment.id}',
             'page_subtitle': f'Payment details and transaction history',
             'show_actions': True,

django_cfg/apps/payments/config/__init__.py

@@ -1,42 +1,41 @@
 """
 Configuration module for the Universal Payment System v2.0.
 
-Provides clean separation between:
-- django-cfg integration (static config)
-- Constance integration (dynamic config)
+Provides unified configuration through BaseCfgAutoModule:
+- django-cfg integration (all configuration)
 - Configuration utilities and helpers
 """
 
-# Django-cfg integration
+# Django-cfg integration (BaseCfgAutoModule)
 from .django_cfg_integration import (
+    PaymentsConfigManager,
     PaymentsConfigMixin,
     get_payments_config,
     is_payments_enabled,
-)
-
-# Constance integration (safe - no Django models)
-from .constance import (
-    get_django_cfg_payments_constance_fields,
-    PaymentConstanceSettings,
+    is_payments_configured,
+    get_config_summary,
+    reset_payments_config_cache,
 )
 
 # Configuration helpers
 from .helpers import (
     MiddlewareConfigHelper,
     CacheConfigHelper,
+    RedisConfigHelper,
 )
 
 __all__ = [
-    # Django-cfg integration
+    # Django-cfg integration (BaseCfgAutoModule)
+    'PaymentsConfigManager',
     'PaymentsConfigMixin',
     'get_payments_config',
     'is_payments_enabled',
-    
-    # Constance integration
-    'get_django_cfg_payments_constance_fields',
-    'PaymentConstanceSettings',
+    'is_payments_configured',
+    'get_config_summary',
+    'reset_payments_config_cache',
     
     # Configuration helpers
     'MiddlewareConfigHelper',
     'CacheConfigHelper',
+    'RedisConfigHelper',
 ]

django_cfg/apps/payments/config/django_cfg_integration.py

@@ -136,7 +136,7 @@ class PaymentsConfigManager:
                 'rate_limiting_enabled': config.rate_limiting_enabled,
                 'usage_tracking_enabled': config.usage_tracking_enabled,
                 'cache_timeouts': config.cache_timeouts,
-                'api_prefixes': config.api_prefixes,
+                'enabled_providers': config.get_enabled_providers(),
             }
         except Exception as e:
             return {
@@ -144,6 +144,64 @@ class PaymentsConfigManager:
                 'error': str(e),
                 'enabled': False,
             }
+    
+    @classmethod
+    def get_provider_api_config(cls, provider: str) -> dict:
+        """
+        Get provider-specific API configuration from BaseCfgAutoModule.
+        
+        Args:
+            provider: Provider name (e.g., 'nowpayments')
+            
+        Returns:
+            Dictionary with provider API configuration
+        """
+        try:
+            config = cls.get_payments_config()
+            return config.get_provider_api_config(provider)
+        except Exception as e:
+            logger.error(f"Failed to get provider config for {provider}: {e}")
+            return {'enabled': False}
+    
+    @classmethod
+    def get_all_provider_configs(cls) -> dict:
+        """
+        Get all provider configurations for registry initialization.
+        
+        Returns:
+            Dictionary with all provider configurations
+        """
+        try:
+            config = cls.get_payments_config()
+            providers = {}
+            
+            # Get all enabled providers
+            for provider_name in config.get_enabled_providers():
+                provider_config = config.get_provider_api_config(provider_name)
+                if provider_config.get('enabled', False):
+                    providers[provider_name] = provider_config
+            
+            return providers
+        except Exception as e:
+            logger.error(f"Failed to get all provider configs: {e}")
+            return {}
+    
+    @classmethod
+    def is_provider_enabled(cls, provider: str) -> bool:
+        """
+        Check if a specific provider is enabled.
+        
+        Args:
+            provider: Provider name
+            
+        Returns:
+            True if provider is enabled
+        """
+        try:
+            config = cls.get_payments_config()
+            return config.is_provider_enabled(provider)
+        except Exception:
+            return False
 
 
 # Legacy compatibility - keep old interface

django_cfg/apps/payments/config/helpers.py

@@ -18,20 +18,11 @@ class MiddlewareConfigHelper(PaymentsConfigMixin):
     
     @classmethod
     def get_middleware_config(cls) -> Dict[str, Any]:
-        """Get middleware configuration combining django-cfg and Constance."""
+        """Get middleware configuration from BaseCfgAutoModule."""
         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
+            # All settings from BaseCfgAutoModule (django-cfg)
             'enabled': config.enabled and config.middleware_enabled,
             'protected_paths': config.protected_paths,
             'protected_patterns': config.protected_patterns,
@@ -41,8 +32,12 @@ class MiddlewareConfigHelper(PaymentsConfigMixin):
             'track_anonymous_usage': config.track_anonymous_usage,
             'cache_timeouts': config.cache_timeouts,
             
-            # Dynamic settings from Constance (if available)
-            'constance_settings': constance_settings,
+            # Provider API configurations
+            'enabled_providers': config.get_enabled_providers(),
+            'provider_configs': {
+                provider: config.get_provider_api_config(provider)
+                for provider in config.get_enabled_providers()
+            },
         }