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

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

@@ -0,0 +1,257 @@
+"""
+Admin Webhook ViewSets.
+
+DRF ViewSets for webhook management in admin interface.
+Requires admin permissions.
+"""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.generics import ListAPIView
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django.utils import timezone
+from django.db import models
+from datetime import datetime, timedelta
+
+from django_cfg.apps.payments.admin_interface.views.base import AdminBaseViewSet, AdminReadOnlyViewSet
+from django_cfg.apps.payments.admin_interface.serializers import (
+    WebhookEventSerializer,
+    WebhookEventListSerializer,
+    WebhookStatsSerializer,
+    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
+
+logger = get_logger("admin_webhook_api")
+
+
+class AdminWebhookViewSet(AdminReadOnlyViewSet):
+    """
+    Admin ViewSet for webhook configuration management.
+    
+    Read-only view for webhook configurations and provider info.
+    Requires admin permissions.
+    """
+    
+    # No model - this is for webhook configuration data
+    serializer_class = WebhookStatsSerializer
+    
+    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',
+                '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'
+            }
+        ]
+        
+        serializer = self.get_serializer(providers_data, many=True)
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """Get webhook statistics."""
+        # Get real payment data for stats
+        total_payments = UniversalPayment.objects.count()
+        recent_payments = UniversalPayment.objects.filter(
+            created_at__gte=timezone.now() - timedelta(days=7)
+        ).count()
+        
+        # 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
+            '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),
+                    'success_rate': 92.8
+                },
+                'stripe': {
+                    'total': int(total_payments * 0.3),
+                    'successful': int(total_payments * 0.28),
+                    'failed': int(total_payments * 0.02),
+                    '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),
+            },
+            '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)
+            ]
+        }
+        
+        serializer = self.get_serializer(stats_data)
+        return Response(serializer.data)
+
+
+class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
+    """
+    Admin ViewSet for webhook events management.
+    
+    Provides listing, filtering, and actions for webhook events.
+    Requires admin permissions.
+    """
+    
+    # No model - using mock data for now
+    serializer_class = WebhookEventListSerializer
+    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']
+    
+    def get_queryset(self):
+        """Get webhook events queryset."""
+        # For now, return empty queryset since we're using mock data
+        # In real implementation, this would return WebhookEvent.objects.all()
+        return UniversalPayment.objects.none()
+    
+    def list(self, request):
+        """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')
+        
+        # Get real payment data to generate realistic mock events
+        payments = UniversalPayment.objects.all()[:50]  # Limit for performance
+        
+        # Generate mock webhook events based on real payments
+        events = []
+        for i, payment in enumerate(payments):
+            # Create multiple events per payment
+            event_types = ['payment.created', 'payment.completed'] if payment.status == 'completed' else ['payment.created']
+            
+            for event_type_name in event_types:
+                event = {
+                    'id': f"evt_{payment.id}_{event_type_name.split('.')[1]}",
+                    '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()
+                    }
+                }
+                
+                # Apply filters
+                if event_type and event['event_type'] != event_type:
+                    continue
+                if status_filter and event['status'] != status_filter:
+                    continue
+                if provider and event['provider'] != provider:
+                    continue
+                    
+                events.append(event)
+        
+        # Sort by created_at descending
+        events.sort(key=lambda x: x['created_at'], reverse=True)
+        
+        # Pagination
+        page_size = 20
+        page = int(request.query_params.get('page', 1))
+        start = (page - 1) * page_size
+        end = start + page_size
+        paginated_events = events[start:end]
+        
+        response_data = {
+            'events': paginated_events,
+            'total': len(events),
+            'page': page,
+            'per_page': page_size,
+            'has_next': end < len(events),
+            'has_previous': page > 1
+        }
+        
+        serializer = self.get_serializer(response_data)
+        return Response(serializer.data)
+    
+    @action(detail=True, methods=['post'])
+    def retry(self, request, pk=None):
+        """Retry a failed webhook event."""
+        # Mock retry logic
+        result_data = {
+            'success': True,
+            'message': f'Webhook event {pk} retry initiated',
+            'event_id': pk,
+            'retry_count': 2,
+            'next_retry': timezone.now() + timedelta(minutes=5)
+        }
+        
+        serializer = WebhookActionResultSerializer(result_data)
+        logger.info(f"Webhook event {pk} retry initiated by admin {request.user.id}")
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['post'])
+    def clear_all(self, request):
+        """Clear all webhook events."""
+        # Mock clear all logic
+        result_data = {
+            'success': True,
+            'message': 'All webhook events cleared',
+            'cleared_count': 150,  # Mock count
+        }
+        
+        serializer = WebhookActionResultSerializer(result_data)
+        logger.info(f"All webhook events cleared by admin {request.user.id}")
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['post'])
+    def retry_failed(self, request):
+        """Retry all failed webhook events."""
+        # Mock retry failed logic
+        # In real implementation:
+        # failed_events = WebhookEvent.objects.filter(status='failed')
+        # results = [retry_webhook_event(event) for event in failed_events]
+        
+        result_data = {
+            'success': True,
+            'message': 'All failed webhook events retry initiated',
+            'processed_count': 0,  # Mock count
+        }
+        
+        serializer = WebhookActionResultSerializer(result_data)
+        logger.info(f"All failed webhook events retry initiated by admin {request.user.id}")
+        return Response(serializer.data)

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

@@ -0,0 +1,70 @@
+"""
+Public Webhook ViewSets.
+
+DRF ViewSets for public webhook functionality.
+No authentication required.
+"""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from django.utils import timezone
+
+from django_cfg.apps.payments.admin_interface.serializers import WebhookStatsSerializer
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("webhook_public_api")
+
+
+class WebhookTestViewSet(viewsets.ViewSet):
+    """
+    Public ViewSet for webhook testing functionality.
+    
+    Allows testing webhook endpoints without admin permissions.
+    Perfect for development and integration testing.
+    """
+    
+    permission_classes = [AllowAny]  # Explicitly allow any user
+    serializer_class = WebhookStatsSerializer  # For schema generation
+    
+    @action(detail=False, methods=['post'])
+    def test(self, request):
+        """
+        Test webhook endpoint.
+        
+        Sends a test webhook to the specified URL with the given event type.
+        Useful for developers to test their webhook implementations.
+        """
+        webhook_url = request.data.get('webhook_url')
+        event_type = request.data.get('event_type')
+        
+        if not webhook_url or not event_type:
+            return Response({
+                'success': False,
+                'error': 'webhook_url and event_type are required'
+            }, status=status.HTTP_400_BAD_REQUEST)
+        
+        # TODO: In real implementation, send actual HTTP request to webhook_url
+        # For now, return mock success response
+        
+        logger.info(f"Test webhook sent to {webhook_url} with event type {event_type}")
+        
+        return Response({
+            'success': True,
+            'message': f'Test webhook sent to {webhook_url} with event type {event_type}',
+            'webhook_url': webhook_url,
+            'event_type': event_type,
+            'timestamp': timezone.now().isoformat(),
+            'test_payload': {
+                'event': event_type,
+                'data': {
+                    'id': 'test_payment_123',
+                    'amount': '100.00',
+                    'currency': 'USD',
+                    'status': 'completed',
+                    'created_at': timezone.now().isoformat()
+                },
+                'timestamp': timezone.now().isoformat()
+            }
+        })

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

@@ -0,0 +1,114 @@
+"""
+Base ViewSet classes for Admin Interface API.
+
+Common functionality for all admin interface ViewSets.
+"""
+
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAdminUser
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.decorators import method_decorator
+from django.utils import timezone
+from datetime import timedelta
+
+
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("admin_api")
+
+
+class AdminBaseViewSet(viewsets.ModelViewSet):
+    """
+    Base ViewSet for admin interface with staff permissions.
+    
+    Provides standard CRUD operations with admin-only access.
+    """
+    
+    permission_classes = [IsAdminUser]
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    ordering = ['-created_at']
+    
+    # Serializer classes mapping for different actions
+    serializer_classes = {}
+    
+    def get_queryset(self):
+        """
+        Optimized queryset for admin interface.
+        
+        Override in subclasses to add specific optimizations.
+        """
+        queryset = super().get_queryset()
+        
+        # Add common optimizations for admin
+        if hasattr(self.queryset.model, 'user'):
+            queryset = queryset.select_related('user')
+        
+        return queryset
+    
+    def get_serializer_class(self):
+        """
+        Dynamic serializer selection based on action.
+        """
+        serializer_classes = getattr(self, 'serializer_classes', {})
+        return serializer_classes.get(self.action, self.serializer_class)
+    
+    def get_serializer_context(self):
+        """Enhanced context for admin serializers."""
+        context = super().get_serializer_context()
+        context.update({
+            'is_admin': True,
+            'admin_user': self.request.user,
+        })
+        return context
+    
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """Get statistics for this resource."""
+        queryset = self.get_queryset()
+        stats = {
+            'total': queryset.count(),
+            'recent': queryset.filter(
+                created_at__gte=timezone.now() - timedelta(days=7)
+            ).count(),
+        }
+        return Response(stats)
+
+
+class AdminReadOnlyViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Read-only ViewSet for admin interface.
+    
+    For resources that should only be viewed, not modified.
+    """
+    
+    permission_classes = [IsAdminUser]
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    ordering = ['-created_at']
+    
+    def get_serializer_context(self):
+        """Enhanced context for admin serializers."""
+        context = super().get_serializer_context()
+        context.update({
+            'is_admin': True,
+            'admin_user': self.request.user,
+        })
+        return context
+
+
+class AdminTemplateViewMixin:
+    """
+    Mixin for template views requiring staff access.
+    """
+    
+    def get_context_data(self, **kwargs):
+        """Add admin-specific context."""
+        context = super().get_context_data(**kwargs)
+        context.update({
+            'is_admin_interface': True,
+            'admin_user': self.request.user,
+        })
+        return context

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

@@ -0,0 +1,60 @@
+"""
+Admin Dashboard Template Views.
+
+Django template views for admin dashboard interface.
+"""
+
+from django.views.generic import TemplateView
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.decorators import method_decorator
+
+from .base import AdminTemplateViewMixin
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class PaymentDashboardView(AdminTemplateViewMixin, LoginRequiredMixin, TemplateView):
+    """
+    Main admin dashboard view.
+    
+    Displays overview of payments, webhooks, and system statistics.
+    """
+    
+    template_name = 'payments/payment_dashboard.html'
+    
+    def get_context_data(self, **kwargs):
+        """Add dashboard context data."""
+        context = super().get_context_data(**kwargs)
+        
+        context.update({
+            'page_title': 'Payment Dashboard',
+            'page_subtitle': 'Overview of payment system activity',
+            'show_stats': True,
+            'auto_refresh': True,
+        })
+        
+        return context
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class WebhookDashboardView(AdminTemplateViewMixin, LoginRequiredMixin, TemplateView):
+    """
+    Webhook dashboard view.
+    
+    Displays webhook events, provider status, and ngrok configuration.
+    """
+    
+    template_name = 'payments/webhook_dashboard.html'
+    
+    def get_context_data(self, **kwargs):
+        """Add webhook dashboard context data."""
+        context = super().get_context_data(**kwargs)
+        
+        context.update({
+            'page_title': 'Webhook Dashboard',
+            'page_subtitle': 'Monitor and test webhook endpoints',
+            'show_ngrok_status': True,
+            'auto_refresh': True,
+        })
+        
+        return context

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

@@ -0,0 +1,94 @@
+"""
+Admin Form Template Views.
+
+Django template views for payment forms and detail pages.
+"""
+
+from django.views.generic import TemplateView, DetailView
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.decorators import method_decorator
+from django.shortcuts import get_object_or_404
+
+from .base import AdminTemplateViewMixin
+from django_cfg.apps.payments.models import UniversalPayment
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class PaymentFormView(AdminTemplateViewMixin, LoginRequiredMixin, TemplateView):
+    """
+    Payment creation form view.
+    
+    Displays form for creating new payments with provider selection.
+    """
+    
+    template_name = 'payments/payment_form.html'
+    
+    def get_context_data(self, **kwargs):
+        """Add form context data."""
+        context = super().get_context_data(**kwargs)
+        
+        context.update({
+            'page_title': 'Create Payment',
+            'page_subtitle': 'Process a payment through the universal payment system',
+            'form_mode': 'create',
+        })
+        
+        return context
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class PaymentDetailView(AdminTemplateViewMixin, LoginRequiredMixin, DetailView):
+    """
+    Payment detail view.
+    
+    Displays detailed information about a specific payment.
+    """
+    
+    model = UniversalPayment
+    template_name = 'payments/payment_detail.html'
+    context_object_name = 'payment'
+    
+    def get_queryset(self):
+        """Optimized queryset with related objects."""
+        return UniversalPayment.objects.select_related('user')
+    
+    def get_context_data(self, **kwargs):
+        """Add detail context data."""
+        context = super().get_context_data(**kwargs)
+        
+        payment = self.get_object()
+        
+        context.update({
+            'page_title': f'Payment {payment.internal_payment_id or payment.id}',
+            'page_subtitle': f'Payment details and transaction history',
+            'show_actions': True,
+            'can_cancel': payment.status in ['pending', 'confirming'],
+            'can_refund': payment.status == 'completed',
+        })
+        
+        return context
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class PaymentListView(AdminTemplateViewMixin, LoginRequiredMixin, TemplateView):
+    """
+    Payment list view.
+    
+    Displays paginated list of payments with filtering options.
+    """
+    
+    template_name = 'payments/payment_list.html'
+    
+    def get_context_data(self, **kwargs):
+        """Add list context data."""
+        context = super().get_context_data(**kwargs)
+        
+        context.update({
+            'page_title': 'Payment List',
+            'page_subtitle': 'Manage and monitor all payments',
+            'show_filters': True,
+            'show_bulk_actions': True,
+        })
+        
+        return context

django_cfg/apps/payments/config/helpers.py

@@ -33,8 +33,8 @@ class MiddlewareConfigHelper(PaymentsConfigMixin):
         return {
             # Static settings from django-cfg
             'enabled': config.enabled and config.middleware_enabled,
-            'api_prefixes': config.api_prefixes,
-            'exempt_paths': config.exempt_paths,
+            'protected_paths': config.protected_paths,
+            'protected_patterns': config.protected_patterns,
             'rate_limiting_enabled': config.rate_limiting_enabled,
             'default_rate_limits': config.default_rate_limits,
             'usage_tracking_enabled': config.usage_tracking_enabled,

django_cfg/apps/payments/management/commands/cleanup_expired_data.py

@@ -15,7 +15,7 @@ from django.core.cache import cache
 
 from django_cfg.modules.django_logger import get_logger
 from django_cfg.apps.payments.models import UniversalPayment, APIKey, Transaction
-from django_cfg.apps.payments.services.cache.cache_service import get_cache_service
+from django_cfg.apps.payments.services.cache_service import get_cache_service
 
 logger = get_logger("cleanup_expired_data")
 
@@ -68,6 +68,12 @@ class Command(BaseCommand):
             help='Clean up all types of expired data'
         )
         
+        parser.add_argument(
+            '--payments-only',
+            action='store_true',
+            help='Clean up only expired payments'
+        )
+        
         parser.add_argument(
             '--dry-run',
             action='store_true',
@@ -107,16 +113,20 @@ class Command(BaseCommand):
             
             # Determine what to clean
             clean_all = options['all']
+            payments_only = options['payments_only']
             
-            if clean_all or not any([options['api_keys'], options['cache']]):
+            if payments_only:
+                # Only clean payments
+                self.cleanup_expired_payments()
+            elif clean_all or not any([options['api_keys'], options['cache']]):
                 # Default: clean payments and transactions
                 self.cleanup_expired_payments()
                 self.cleanup_old_transactions()
             
-            if clean_all or options['api_keys']:
+            if not payments_only and (clean_all or options['api_keys']):
                 self.cleanup_expired_api_keys()
             
-            if clean_all or options['cache']:
+            if not payments_only and (clean_all or options['cache']):
                 self.cleanup_stale_cache()
             
             self.show_summary()
@@ -217,8 +227,8 @@ class Command(BaseCommand):
         old_transactions = Transaction.objects.filter(
             created_at__lt=cutoff_date
         ).exclude(
-            # Keep transactions for completed payments
-            payment__status='completed'
+            # Keep transactions with payment references (important transactions)
+            payment_id__isnull=False
         )
         
         total_count = old_transactions.count()