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

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

@@ -1,23 +1,34 @@
 """
-Template views for the Universal Payment System v2.0.
+Admin Interface Views for Universal Payment System v2.0.
 
-Django template views for dashboard and management interfaces.
+DRF ViewSets and template views for admin dashboard and management interfaces.
 """
 
-from .webhook_dashboard import WebhookDashboardView
-from .payment_views import (
-    PaymentFormView,
-    PaymentStatusView,
-    PaymentListView,
-    PaymentDashboardView,
-    CurrencyConverterView,
+# Template Views
+from .dashboard import PaymentDashboardView, WebhookDashboardView
+from .forms import PaymentFormView, PaymentDetailView, PaymentListView
+
+# API ViewSets
+from .api import (
+    AdminPaymentViewSet,
+    AdminWebhookViewSet,
+    AdminWebhookEventViewSet,
+    AdminStatsViewSet,
+    AdminUserViewSet,
 )
 
 __all__ = [
+    # Template Views
+    'PaymentDashboardView',
     'WebhookDashboardView',
-    'PaymentFormView',
-    'PaymentStatusView',
+    'PaymentFormView', 
+    'PaymentDetailView',
     'PaymentListView',
-    'PaymentDashboardView',
-    'CurrencyConverterView',
-]
+    
+    # API ViewSets
+    'AdminPaymentViewSet',
+    'AdminWebhookViewSet',
+    'AdminWebhookEventViewSet',
+    'AdminStatsViewSet',
+    'AdminUserViewSet',
+]

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

@@ -0,0 +1,20 @@
+"""
+Admin Interface API ViewSets.
+
+DRF ViewSets for admin dashboard with nested routing.
+"""
+
+from .payments import AdminPaymentViewSet
+from .webhook_admin import AdminWebhookViewSet, AdminWebhookEventViewSet
+from .webhook_public import WebhookTestViewSet
+from .stats import AdminStatsViewSet
+from .users import AdminUserViewSet
+
+__all__ = [
+    'AdminPaymentViewSet',
+    'AdminWebhookViewSet',
+    'AdminWebhookEventViewSet', 
+    'WebhookTestViewSet',
+    'AdminStatsViewSet',
+    'AdminUserViewSet',
+]

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

@@ -0,0 +1,191 @@
+"""
+Admin Payment ViewSets.
+
+DRF ViewSets for payment management in admin interface.
+"""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django.db.models import Count, Sum, Avg, Q
+from django.utils import timezone
+from datetime import timedelta
+
+from django_cfg.apps.payments.admin_interface.views.base import AdminBaseViewSet
+from django_cfg.apps.payments.models import UniversalPayment
+from django_cfg.apps.payments.admin_interface.serializers import (
+    AdminPaymentListSerializer,
+    AdminPaymentDetailSerializer,
+    AdminPaymentCreateSerializer,
+    AdminPaymentUpdateSerializer,
+    AdminPaymentStatsSerializer,
+)
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("admin_payment_api")
+
+
+class AdminPaymentViewSet(AdminBaseViewSet):
+    """
+    Admin ViewSet for payment management.
+    
+    Provides full CRUD operations for payments with admin-specific features.
+    """
+    
+    queryset = UniversalPayment.objects.select_related('user').order_by('-created_at')
+    serializer_class = AdminPaymentDetailSerializer
+    
+    serializer_classes = {
+        'list': AdminPaymentListSerializer,
+        'create': AdminPaymentCreateSerializer,
+        'update': AdminPaymentUpdateSerializer,
+        'partial_update': AdminPaymentUpdateSerializer,
+        'stats': AdminPaymentStatsSerializer,
+    }
+    
+    filterset_fields = ['status', 'provider', 'currency__code', 'user']
+    search_fields = ['internal_payment_id', 'transaction_hash', 'description', 'user__username', 'user__email']
+    ordering_fields = ['created_at', 'amount_usd', 'status']
+    
+    def get_queryset(self):
+        """Optimized queryset for admin interface."""
+        queryset = super().get_queryset()
+        
+        # Add filters based on query params
+        status_filter = self.request.query_params.get('status')
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+        
+        provider_filter = self.request.query_params.get('provider')
+        if provider_filter:
+            queryset = queryset.filter(provider=provider_filter)
+        
+        # Date range filter
+        date_from = self.request.query_params.get('date_from')
+        date_to = self.request.query_params.get('date_to')
+        if date_from:
+            queryset = queryset.filter(created_at__gte=date_from)
+        if date_to:
+            queryset = queryset.filter(created_at__lte=date_to)
+        
+        return queryset
+    
+    @action(detail=False, methods=['get'])
+    def stats(self, request):
+        """Get comprehensive payment statistics."""
+        queryset = self.get_queryset()
+        
+        # Basic stats
+        total_payments = queryset.count()
+        total_amount = queryset.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0
+        
+        # Status breakdown
+        status_stats = queryset.values('status').annotate(count=Count('id'))
+        successful = sum(s['count'] for s in status_stats if s['status'] in ['completed', 'confirmed'])
+        failed = sum(s['count'] for s in status_stats if s['status'] == 'failed')
+        pending = sum(s['count'] for s in status_stats if s['status'] in ['pending', 'confirming'])
+        
+        success_rate = (successful / total_payments * 100) if total_payments > 0 else 0
+        
+        # Provider breakdown
+        provider_stats = {}
+        for provider_data in queryset.values('provider').annotate(
+            count=Count('id'),
+            total_amount=Sum('amount_usd')
+        ):
+            provider_stats[provider_data['provider']] = {
+                'count': provider_data['count'],
+                'total_amount': provider_data['total_amount'] or 0,
+            }
+        
+        # Currency breakdown
+        currency_stats = {}
+        for currency_data in queryset.values('currency_code').annotate(
+            count=Count('id'),
+            total_amount=Sum('amount_usd')
+        ):
+            currency_stats[currency_data['currency_code']] = {
+                'count': currency_data['count'],
+                'total_amount': currency_data['total_amount'] or 0,
+            }
+        
+        # Time-based stats
+        now = timezone.now()
+        last_24h = queryset.filter(created_at__gte=now - timedelta(hours=24)).aggregate(
+            count=Count('id'),
+            amount=Sum('amount_usd')
+        )
+        last_7d = queryset.filter(created_at__gte=now - timedelta(days=7)).aggregate(
+            count=Count('id'),
+            amount=Sum('amount_usd')
+        )
+        last_30d = queryset.filter(created_at__gte=now - timedelta(days=30)).aggregate(
+            count=Count('id'),
+            amount=Sum('amount_usd')
+        )
+        
+        stats_data = {
+            'total_payments': total_payments,
+            'total_amount_usd': total_amount,
+            'successful_payments': successful,
+            'failed_payments': failed,
+            'pending_payments': pending,
+            'success_rate': round(success_rate, 2),
+            'by_provider': provider_stats,
+            'by_currency': currency_stats,
+            'last_24h': {
+                'count': last_24h['count'] or 0,
+                'amount': last_24h['amount'] or 0,
+            },
+            'last_7d': {
+                'count': last_7d['count'] or 0,
+                'amount': last_7d['amount'] or 0,
+            },
+            'last_30d': {
+                'count': last_30d['count'] or 0,
+                'amount': last_30d['amount'] or 0,
+            },
+        }
+        
+        serializer = self.get_serializer(stats_data)
+        return Response(serializer.data)
+    
+    @action(detail=True, methods=['post'])
+    def cancel(self, request, pk=None):
+        """Cancel a payment."""
+        payment = self.get_object()
+        
+        if payment.status not in ['pending', 'confirming']:
+            return Response(
+                {'error': 'Payment cannot be cancelled in current status'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        payment.status = UniversalPayment.PaymentStatus.CANCELLED
+        payment.save()
+        
+        logger.info(f"Payment {payment.id} cancelled by admin {request.user.id}")
+        
+        serializer = self.get_serializer(payment)
+        return Response(serializer.data)
+    
+    @action(detail=True, methods=['post'])
+    def refund(self, request, pk=None):
+        """Refund a payment."""
+        payment = self.get_object()
+        
+        if payment.status != 'completed':
+            return Response(
+                {'error': 'Only completed payments can be refunded'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        
+        payment.status = UniversalPayment.PaymentStatus.REFUNDED
+        payment.save()
+        
+        logger.info(f"Payment {payment.id} refunded by admin {request.user.id}")
+        
+        serializer = self.get_serializer(payment)
+        return Response(serializer.data)

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

@@ -0,0 +1,206 @@
+"""
+Admin Statistics ViewSets.
+
+DRF ViewSets for comprehensive statistics in admin interface.
+"""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django.db.models import Count, Sum, Avg, Q
+from django.utils import timezone
+from datetime import timedelta
+
+
+from django_cfg.modules.django_logger import get_logger
+from django_cfg.apps.payments.models import UniversalPayment
+from ..base import AdminReadOnlyViewSet
+from django_cfg.apps.payments.admin_interface.serializers import AdminPaymentStatsSerializer, WebhookStatsSerializer
+
+logger = get_logger("admin_stats_api")
+
+
+class AdminStatsViewSet(AdminReadOnlyViewSet):
+    """
+    Admin ViewSet for comprehensive system statistics.
+    
+    Provides aggregated statistics across all system components.
+    """
+    
+    # No model - this is for aggregated statistics
+    serializer_class = AdminPaymentStatsSerializer
+    
+    def list(self, request):
+        """Get overview statistics."""
+        now = timezone.now()
+        
+        # Payment statistics
+        payments_queryset = UniversalPayment.objects.all()
+        
+        payment_stats = {
+            'total_payments': payments_queryset.count(),
+            'total_amount_usd': payments_queryset.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0,
+            'successful_payments': payments_queryset.filter(status='completed').count(),
+            'failed_payments': payments_queryset.filter(status='failed').count(),
+            'pending_payments': payments_queryset.filter(status__in=['pending', 'confirming']).count(),
+        }
+        
+        # Calculate success rate
+        total = payment_stats['total_payments']
+        if total > 0:
+            payment_stats['success_rate'] = (payment_stats['successful_payments'] / total) * 100
+        else:
+            payment_stats['success_rate'] = 0
+        
+        # Time-based payment stats
+        payment_stats['last_24h'] = {
+            'count': payments_queryset.filter(created_at__gte=now - timedelta(hours=24)).count(),
+            'amount': payments_queryset.filter(created_at__gte=now - timedelta(hours=24)).aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0,
+        }
+        
+        # Mock webhook statistics (replace with real data)
+        webhook_stats = {
+            'total_events': 156,
+            'successful_events': 142,
+            'failed_events': 12,
+            'pending_events': 2,
+            'webhook_success_rate': 91.0,
+        }
+        
+        # System health metrics
+        system_stats = {
+            'active_users_24h': 45,  # Mock data
+            'api_requests_24h': 1250,  # Mock data
+            'avg_response_time': 245.5,  # Mock data
+            'uptime_percentage': 99.9,  # Mock data
+        }
+        
+        return Response({
+            'payments': payment_stats,
+            'webhooks': webhook_stats,
+            'system': system_stats,
+            'last_updated': now.isoformat(),
+        })
+    
+    @action(detail=False, methods=['get'])
+    def payments(self, request):
+        """Get detailed payment statistics."""
+        queryset = UniversalPayment.objects.all()
+        now = timezone.now()
+        
+        # Basic stats
+        total_payments = queryset.count()
+        total_amount = queryset.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0
+        
+        # Status breakdown
+        status_stats = queryset.values('status').annotate(count=Count('id'))
+        successful = sum(s['count'] for s in status_stats if s['status'] in ['completed', 'confirmed'])
+        failed = sum(s['count'] for s in status_stats if s['status'] == 'failed')
+        pending = sum(s['count'] for s in status_stats if s['status'] in ['pending', 'confirming'])
+        
+        success_rate = (successful / total_payments * 100) if total_payments > 0 else 0
+        
+        # Provider breakdown
+        provider_stats = {}
+        for provider_data in queryset.values('provider').annotate(
+            count=Count('id'),
+            total_amount=Sum('amount_usd'),
+            successful=Count('id', filter=Q(status='completed')),
+            failed=Count('id', filter=Q(status='failed'))
+        ):
+            provider = provider_data['provider']
+            provider_stats[provider] = {
+                'count': provider_data['count'],
+                'total_amount': provider_data['total_amount'] or 0,
+                'successful': provider_data['successful'],
+                'failed': provider_data['failed'],
+                'success_rate': (provider_data['successful'] / provider_data['count'] * 100) if provider_data['count'] > 0 else 0,
+            }
+        
+        # Currency breakdown
+        currency_stats = {}
+        for currency_data in queryset.values('currency__code').annotate(
+            count=Count('id'),
+            total_amount=Sum('amount_usd')
+        ):
+            currency_stats[currency_data['currency__code']] = {
+                'count': currency_data['count'],
+                'total_amount': currency_data['total_amount'] or 0,
+            }
+        
+        # Time-based stats
+        time_ranges = {
+            'last_24h': now - timedelta(hours=24),
+            'last_7d': now - timedelta(days=7),
+            'last_30d': now - timedelta(days=30),
+        }
+        
+        time_stats = {}
+        for period, start_date in time_ranges.items():
+            period_queryset = queryset.filter(created_at__gte=start_date)
+            time_stats[period] = {
+                'count': period_queryset.count(),
+                'amount': period_queryset.aggregate(Sum('amount_usd'))['amount_usd__sum'] or 0,
+                'successful': period_queryset.filter(status='completed').count(),
+                'failed': period_queryset.filter(status='failed').count(),
+            }
+        
+        stats_data = {
+            'total_payments': total_payments,
+            'total_amount_usd': total_amount,
+            'successful_payments': successful,
+            'failed_payments': failed,
+            'pending_payments': pending,
+            'success_rate': round(success_rate, 2),
+            'by_provider': provider_stats,
+            'by_currency': currency_stats,
+            **time_stats,
+        }
+        
+        serializer = AdminPaymentStatsSerializer(stats_data)
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['get'])
+    def webhooks(self, request):
+        """Get detailed webhook statistics."""
+        # Mock webhook statistics - replace with real data from webhook event model
+        stats_data = {
+            'total': 156,
+            'successful': 142,
+            'failed': 12,
+            'pending': 2,
+            'success_rate': 91.0,
+            'providers': {
+                'nowpayments': {'total': 89, 'successful': 85, 'failed': 4, 'success_rate': 95.5},
+                'stripe': {'total': 45, 'successful': 42, 'failed': 3, 'success_rate': 93.3},
+                'cryptapi': {'total': 22, 'successful': 15, 'failed': 5, 'pending': 2, 'success_rate': 68.2},
+            },
+            'last_24h': {
+                'total': 23,
+                'successful': 21,
+                'failed': 2,
+            },
+            'avg_response_time': 245.5,
+            'max_response_time': 3000,
+        }
+        
+        serializer = WebhookStatsSerializer(stats_data)
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['get'])
+    def system(self, request):
+        """Get system health and performance statistics."""
+        # Mock system statistics - replace with real metrics
+        system_data = {
+            'uptime': '99.9%',
+            'active_users_24h': 45,
+            'api_requests_24h': 1250,
+            'avg_response_time_ms': 245.5,
+            'error_rate_24h': 0.8,
+            'database_connections': 12,
+            'memory_usage': '68%',
+            'cpu_usage': '23%',
+            'disk_usage': '45%',
+        }
+        
+        return Response(system_data)

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

@@ -0,0 +1,60 @@
+"""
+Admin User ViewSet.
+
+Simple ViewSet for user management in admin interface.
+"""
+
+from rest_framework import viewsets
+from rest_framework.permissions import IsAdminUser
+from rest_framework.response import Response
+from django.contrib.auth import get_user_model
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+
+from django_cfg.apps.payments.admin_interface.views.base import AdminReadOnlyViewSet
+from django_cfg.apps.payments.admin_interface.serializers import AdminUserSerializer
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("admin_user_api")
+
+User = get_user_model()
+
+
+class AdminUserViewSet(AdminReadOnlyViewSet):
+    """
+    Admin ViewSet for user management.
+    
+    Provides read-only access to users for admin interface.
+    """
+    
+    queryset = User.objects.filter(is_active=True).order_by('username')
+    serializer_class = AdminUserSerializer
+    permission_classes = [IsAdminUser]
+    
+    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
+    filterset_fields = ['is_active', 'is_staff', 'is_superuser']
+    search_fields = ['username', 'email', 'first_name', 'last_name']
+    ordering_fields = ['username', 'email', 'date_joined']
+    ordering = ['username']  # Override base class ordering
+    
+    def get_queryset(self):
+        """Optimized queryset for admin interface."""
+        # Don't slice here - let DRF handle pagination and ordering first
+        return super().get_queryset()
+    
+    def list(self, request, *args, **kwargs):
+        """Override list to limit results for dropdown."""
+        # Get the filtered and ordered queryset from DRF
+        queryset = self.filter_queryset(self.get_queryset())
+        
+        # Now apply limit after filtering/ordering
+        queryset = queryset[:100]  # Limit to first 100 users
+        
+        # Use DRF pagination if needed
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            return self.get_paginated_response(serializer.data)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)