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

django_cfg/apps/payments/static/payments/js/payment-list.js

@@ -0,0 +1,95 @@
+/**
+ * Payment List Component
+ * Handles payment listing, filtering, and pagination
+ */
+function paymentList() {
+    return {
+        loading: false,
+        payments: [],
+        filters: {
+            search: '',
+            status: ''
+        },
+        currentPage: 1,
+        pageSize: 10,
+
+        get filteredPayments() {
+            let filtered = this.payments;
+            
+            if (this.filters.search) {
+                const search = this.filters.search.toLowerCase();
+                filtered = filtered.filter(payment => 
+                    payment.id.toLowerCase().includes(search) ||
+                    payment.external_id?.toLowerCase().includes(search) ||
+                    payment.provider.toLowerCase().includes(search)
+                );
+            }
+            
+            if (this.filters.status) {
+                filtered = filtered.filter(payment => payment.status === this.filters.status);
+            }
+            
+            return filtered;
+        },
+
+        get paginatedPayments() {
+            const start = (this.currentPage - 1) * this.pageSize;
+            const end = start + this.pageSize;
+            return this.filteredPayments.slice(start, end);
+        },
+
+        async init() {
+            await this.loadPayments();
+            // Auto-refresh every 30 seconds
+            setInterval(() => this.loadPayments(), 30000);
+        },
+
+        async loadPayments() {
+            this.loading = true;
+            try {
+                const response = await PaymentAPI.admin.payments.list(this.filters);
+                this.payments = response.payments || response.results || [];
+                this.pagination = {
+                    total: response.total || response.count || 0,
+                    page: response.page || 1,
+                    per_page: response.per_page || 50,
+                    has_next: response.has_next || false,
+                    has_previous: response.has_previous || false
+                };
+            } catch (error) {
+                console.error('Failed to load payments:', error);
+                this.payments = [];
+                PaymentAPI.utils.showNotification('Failed to load payments', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+
+        async refreshPayments() {
+            await this.loadPayments();
+            PaymentAPI.utils.showNotification('Payments refreshed', 'success');
+        },
+
+        async refreshPayment(paymentId) {
+            try {
+                const updatedPayment = await PaymentAPI.payments.get(paymentId);
+                const index = this.payments.findIndex(p => p.id === paymentId);
+                if (index !== -1) {
+                    this.payments[index] = updatedPayment;
+                }
+                PaymentAPI.utils.showNotification('Payment updated', 'success');
+            } catch (error) {
+                console.error('Failed to refresh payment:', error);
+                PaymentAPI.utils.showNotification('Failed to refresh payment', 'error');
+            }
+        },
+
+        applyFilters() {
+            this.currentPage = 1;
+        },
+
+        formatDate(dateString) {
+            return PaymentAPI.utils.formatDate(dateString);
+        }
+    };
+}

django_cfg/apps/payments/static/payments/js/webhook-dashboard.js

@@ -0,0 +1,154 @@
+/**
+ * Webhook Dashboard Component
+ * Handles webhook events monitoring and testing
+ */
+function webhookDashboard() {
+    return {
+        loading: false,
+        testLoading: false,
+        events: [],
+        filters: {
+            event_type: '',
+            status: ''
+        },
+        stats: {
+            total: 0,
+            successful: 0,
+            failed: 0,
+            successRate: 0
+        },
+        testForm: {
+            url: '',
+            event_type: ''
+        },
+        showEventModal: false,
+        selectedEvent: null,
+
+        get filteredEvents() {
+            let filtered = this.events;
+            
+            if (this.filters.event_type) {
+                filtered = filtered.filter(event => event.event_type === this.filters.event_type);
+            }
+            
+            if (this.filters.status) {
+                filtered = filtered.filter(event => event.status === this.filters.status);
+            }
+            
+            return filtered;
+        },
+
+        async init() {
+            await this.loadEvents();
+            await this.loadStats();
+            // Auto-refresh every 30 seconds
+            setInterval(() => this.refreshEvents(), 30000);
+        },
+
+        async loadEvents() {
+            this.loading = true;
+            try {
+                const response = await PaymentAPI.admin.webhooks.events.list();
+                this.events = response.events || [];
+                this.pagination = {
+                    total: response.total || 0,
+                    page: response.page || 1,
+                    per_page: response.per_page || 50,
+                    has_next: response.has_next || false,
+                    has_previous: response.has_previous || false
+                };
+            } catch (error) {
+                console.error('Failed to load events:', error);
+                this.events = [];
+                PaymentAPI.utils.showNotification('Failed to load webhook events', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+
+        async loadStats() {
+            try {
+                this.stats = await PaymentAPI.admin.webhooks.stats();
+            } catch (error) {
+                console.error('Failed to load stats:', error);
+                // Set default stats on error
+                this.stats = {
+                    total: 0,
+                    successful: 0,
+                    failed: 0,
+                    successRate: 0
+                };
+                PaymentAPI.utils.showNotification('Failed to load webhook stats', 'error');
+            }
+        },
+
+        async refreshEvents() {
+            await this.loadEvents();
+            await this.loadStats();
+        },
+
+        async clearEvents() {
+            if (confirm('Are you sure you want to clear all events?')) {
+                try {
+                    await PaymentAPI.admin.webhooks.events.clearAll(1);
+                    this.events = [];
+                    await this.loadStats();
+                    PaymentAPI.utils.showNotification('All events cleared', 'success');
+                } catch (error) {
+                    console.error('Failed to clear events:', error);
+                    PaymentAPI.utils.showNotification('Failed to clear events', 'error');
+                }
+            }
+        },
+
+        async testWebhook() {
+            this.testLoading = true;
+            try {
+                await PaymentAPI.admin.webhookTest.send(this.testForm.url, this.testForm.event_type);
+                PaymentAPI.utils.showNotification('Test webhook sent successfully!', 'success');
+                this.testForm = { url: '', event_type: '' };
+                await this.refreshEvents();
+            } catch (error) {
+                console.error('Failed to test webhook:', error);
+                PaymentAPI.utils.showNotification('Failed to send test webhook', 'error');
+            } finally {
+                this.testLoading = false;
+            }
+        },
+
+        async retryEvent(eventId) {
+            try {
+                await PaymentAPI.admin.webhooks.events.retry(1, eventId);
+                await this.refreshEvents();
+                PaymentAPI.utils.showNotification('Event retried', 'success');
+            } catch (error) {
+                console.error('Failed to retry event:', error);
+                PaymentAPI.utils.showNotification('Failed to retry event', 'error');
+            }
+        },
+
+        async retryFailedEvents() {
+            try {
+                await PaymentAPI.admin.webhooks.events.retryFailed(1);
+                await this.refreshEvents();
+                PaymentAPI.utils.showNotification('Failed events retried', 'success');
+            } catch (error) {
+                console.error('Failed to retry failed events:', error);
+                PaymentAPI.utils.showNotification('Failed to retry events', 'error');
+            }
+        },
+
+        viewEvent(event) {
+            this.selectedEvent = event;
+            this.showEventModal = true;
+        },
+
+        applyFilters() {
+            // Filters are applied automatically via computed property
+        },
+
+        formatDate(dateString) {
+            return PaymentAPI.utils.formatDate(dateString);
+        }
+    };
+}

django_cfg/apps/payments/urls.py

@@ -16,6 +16,7 @@ from .views.api import (
     APIKeyViewSet, UserAPIKeyViewSet, APIKeyCreateView, APIKeyValidateView,
     UniversalWebhookView, webhook_health_check, webhook_stats, supported_providers,
 )
+from .views.overview import urls as overview_urls
 
 app_name = 'cfg_payments'
 
@@ -74,4 +75,7 @@ urlpatterns = [
     
     # Health check endpoint
     path('health/', PaymentViewSet.as_view({'get': 'health'}), name='health-check'),
+    
+    # Overview dashboard endpoints
+    path('overview/', include(overview_urls)),
 ]

django_cfg/apps/payments/urls_admin.py

@@ -1,49 +1,68 @@
 """
 Admin URLs for Universal Payment System v2.0.
 
-Internal dashboard and management interfaces.
+Internal dashboard and management interfaces with DRF nested routing.
 All URLs require staff/superuser access.
 """
 
 from django.urls import path, include
 from django.contrib.admin.views.decorators import staff_member_required
+from rest_framework.routers import DefaultRouter
+from rest_framework_nested import routers
 
 from .admin_interface.views import (
-    WebhookDashboardView,
+    PaymentDashboardView,
     PaymentFormView,
-    PaymentStatusView,
+    PaymentDetailView,
     PaymentListView,
-    PaymentDashboardView,
-    CurrencyConverterView,
+    AdminPaymentViewSet,
+    AdminWebhookViewSet,
+    AdminWebhookEventViewSet,
+    WebhookTestViewSet,
+    AdminStatsViewSet,
+    AdminUserViewSet,
 )
+from .admin_interface.views.dashboard import WebhookDashboardView
 
 app_name = 'cfg_payments_admin'
 
+# DRF Routers for Admin API
+admin_router = DefaultRouter()
+admin_router.register(r'payments', AdminPaymentViewSet, basename='admin-payment')
+admin_router.register(r'webhooks', AdminWebhookViewSet, basename='admin-webhook')
+admin_router.register(r'stats', AdminStatsViewSet, basename='admin-stats')
+admin_router.register(r'users', AdminUserViewSet, basename='admin-user')
+
+# Nested router for webhook events
+webhook_events_router = routers.NestedSimpleRouter(admin_router, r'webhooks', lookup='webhook')
+webhook_events_router.register(r'events', AdminWebhookEventViewSet, basename='admin-webhook-events')
+
+# Public API router (no authentication required)
+public_router = DefaultRouter()
+public_router.register(r'webhooks', WebhookTestViewSet, basename='webhook-test')
+
 urlpatterns = [
-    # Main dashboard
+    # Template Views
     path('', staff_member_required(PaymentDashboardView.as_view()), name='dashboard'),
     path('dashboard/', staff_member_required(PaymentDashboardView.as_view()), name='dashboard_alt'),
     
-    # Payment management
+    # Payment management templates
     path('payments/', include([
         path('', staff_member_required(PaymentListView.as_view()), name='payment-list'),
-        path('create/', staff_member_required(PaymentFormView.as_view()), name='payment-create'),
-        path('<uuid:pk>/', staff_member_required(PaymentStatusView.as_view()), name='payment-detail'),
-        path('status/<uuid:pk>/', staff_member_required(PaymentStatusView.as_view()), name='payment-status'),
+        path('create/', staff_member_required(PaymentFormView.as_view()), name='payment-form'),
+        path('<uuid:pk>/', staff_member_required(PaymentDetailView.as_view()), name='payment-detail'),
     ])),
     
-    # Webhook management
+    # Webhook management templates
     path('webhooks/', include([
         path('', staff_member_required(WebhookDashboardView.as_view()), name='webhook-dashboard'),
         path('dashboard/', staff_member_required(WebhookDashboardView.as_view()), name='webhook-dashboard-alt'),
     ])),
     
-    # Tools and utilities
-    path('tools/', include([
-        path('converter/', staff_member_required(CurrencyConverterView.as_view()), name='currency-converter'),
+    # API Routes with DRF ViewSets
+    path('api/', include([
+        path('', include(admin_router.urls)),
+        path('', include(webhook_events_router.urls)),
+        path('', include(public_router.urls)),  # Public API endpoints
     ])),
-    
-    # Development/testing tools (only in DEBUG mode)
-    # path('test/', PaymentTestView.as_view(), name='test'),
-    # path('debug/', PaymentDebugView.as_view(), name='debug'),
 ]

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

@@ -11,6 +11,7 @@ from django_filters.rest_framework import DjangoFilterBackend
 from django.contrib.auth import get_user_model
 from django.db import models
 from django.utils import timezone
+from drf_spectacular.utils import extend_schema, extend_schema_view
 
 from .base import PaymentBaseViewSet, NestedPaymentViewSet, ReadOnlyPaymentViewSet
 from ...models import APIKey
@@ -21,6 +22,7 @@ from ..serializers.api_keys import (
     APIKeyUpdateSerializer,
     APIKeyActionSerializer,
     APIKeyValidationSerializer,
+    APIKeyValidationResponseSerializer,
     APIKeyStatsSerializer,
 )
 from django_cfg.modules.django_logger import get_logger
@@ -78,6 +80,12 @@ class APIKeyViewSet(PaymentBaseViewSet):
         
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
     
+    @extend_schema(
+        summary="Validate API Key",
+        description="Validate an API key and return key information",
+        request=APIKeyValidationSerializer,
+        responses={200: APIKeyValidationResponseSerializer}
+    )
     @action(detail=False, methods=['post'])
     def validate_key(self, request):
         """
@@ -376,6 +384,12 @@ class APIKeyValidateView(generics.GenericAPIView):
     serializer_class = APIKeyValidationSerializer
     permission_classes = [permissions.IsAuthenticated]
     
+    @extend_schema(
+        summary="Validate API Key (Standalone)",
+        description="Standalone endpoint to validate an API key and return key information",
+        request=APIKeyValidationSerializer,
+        responses={200: APIKeyValidationResponseSerializer}
+    )
     def post(self, request, *args, **kwargs):
         """Validate API key."""
         serializer = self.get_serializer(data=request.data)

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

@@ -32,6 +32,7 @@ class PaymentBaseViewSet(viewsets.ModelViewSet):
     permission_classes = [permissions.IsAuthenticated]
     filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
     ordering = ['-created_at']
+    versioning_class = None  # Disable versioning for payments API
     
     # Serializer classes mapping for different actions
     serializer_classes = {}

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

@@ -195,7 +195,7 @@ class NetworkViewSet(ReadOnlyPaymentViewSet):
     queryset = Network.objects.filter(is_active=True)
     serializer_class = NetworkSerializer
     permission_classes = [permissions.IsAuthenticated]
-    filterset_fields = ['currency', 'is_active']
+    filterset_fields = ['native_currency__code', 'is_active']
     search_fields = ['name', 'code']
     ordering_fields = ['name', 'code', 'created_at']
     
@@ -251,7 +251,7 @@ class ProviderCurrencyViewSet(ReadOnlyPaymentViewSet):
     queryset = ProviderCurrency.objects.filter(is_enabled=True)
     serializer_class = ProviderCurrencySerializer
     permission_classes = [permissions.IsAuthenticated]
-    filterset_fields = ['provider', 'currency', 'network', 'is_enabled']
+    filterset_fields = ['provider', 'currency__code', 'network__code', 'is_enabled']
     search_fields = ['provider_currency_code']
     ordering_fields = ['provider', 'created_at', 'min_amount', 'max_amount']
     

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

@@ -37,8 +37,8 @@ class PaymentViewSet(PaymentBaseViewSet):
     
     queryset = UniversalPayment.objects.all()
     serializer_class = PaymentSerializer
-    permission_classes = [permissions.IsAdminUser]  # Admin only for global access
-    filterset_fields = ['status', 'provider', 'currency_code', 'user']
+    permission_classes = [permissions.IsAuthenticated]  # Allow authenticated users
+    filterset_fields = ['status', 'provider', 'currency__code', 'user']
     search_fields = ['description', 'provider_payment_id', 'transaction_hash']
     ordering_fields = ['created_at', 'updated_at', 'amount_usd', 'expires_at']
     
@@ -52,9 +52,15 @@ class PaymentViewSet(PaymentBaseViewSet):
     
     def get_queryset(self):
         """Optimized queryset with related objects."""
-        return super().get_queryset().select_related('user').prefetch_related(
-            'user__userbalance_set'
+        queryset = super().get_queryset().select_related('user').prefetch_related(
+            'user__payment_balance'
         )
+        
+        # Non-staff users can only see their own payments
+        if not self.request.user.is_staff:
+            queryset = queryset.filter(user=self.request.user)
+        
+        return queryset
     
     @action(detail=True, methods=['post'])
     def check_status(self, request, pk=None):
@@ -178,7 +184,7 @@ class UserPaymentViewSet(NestedPaymentViewSet):
     queryset = UniversalPayment.objects.all()
     serializer_class = PaymentSerializer
     permission_classes = [permissions.IsAuthenticated]
-    filterset_fields = ['status', 'provider', 'currency_code']
+    filterset_fields = ['status', 'provider', 'currency__code']
     search_fields = ['description', 'provider_payment_id']
     ordering_fields = ['created_at', 'updated_at', 'amount_usd', 'expires_at']
     

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

@@ -40,9 +40,9 @@ class SubscriptionViewSet(PaymentBaseViewSet):
     
     queryset = Subscription.objects.all()
     serializer_class = SubscriptionSerializer
-    permission_classes = [permissions.IsAdminUser]  # Admin only for global access
-    filterset_fields = ['status', 'tier', 'tariff', 'endpoint_group', 'user']
-    search_fields = ['user__username', 'user__email', 'tariff__name']
+    permission_classes = [permissions.IsAuthenticated]  # Allow authenticated users
+    filterset_fields = ['status', 'tier', 'user']
+    search_fields = ['user__username', 'user__email']
     ordering_fields = ['created_at', 'updated_at', 'expires_at', 'total_requests']
     
     serializer_classes = {
@@ -55,11 +55,17 @@ class SubscriptionViewSet(PaymentBaseViewSet):
     
     def get_queryset(self):
         """Optimized queryset with related objects."""
-        return super().get_queryset().select_related(
-            'user', 'tariff', 'endpoint_group'
+        queryset = super().get_queryset().select_related(
+            'user'
         ).prefetch_related(
-            'tariff__endpoint_groups'
+            'endpoint_groups'
         )
+        
+        # Non-staff users can only see their own subscriptions
+        if not self.request.user.is_staff:
+            queryset = queryset.filter(user=self.request.user)
+        
+        return queryset
     
     @action(detail=True, methods=['post'])
     def update_status(self, request, pk=None):
@@ -161,43 +167,42 @@ class SubscriptionViewSet(PaymentBaseViewSet):
             )
     
     @action(detail=False, methods=['get'])
-    def by_tariff(self, request):
+    def by_tier(self, request):
         """
-        Get subscriptions grouped by tariff.
+        Get subscriptions grouped by tier.
         
-        GET /api/subscriptions/by_tariff/
+        GET /api/subscriptions/by_tier/
         """
         try:
             queryset = self.filter_queryset(self.get_queryset())
             
-            tariff_stats = {}
-            for subscription in queryset.select_related('tariff'):
-                tariff_name = subscription.tariff.name if subscription.tariff else 'No Tariff'
-                tariff_id = subscription.tariff.id if subscription.tariff else None
+            tier_stats = {}
+            for tier_choice in Subscription.SubscriptionTier.choices:
+                tier_code = tier_choice[0]
+                tier_name = tier_choice[1]
                 
-                if tariff_name not in tariff_stats:
-                    tariff_stats[tariff_name] = {
-                        'tariff_id': tariff_id,
-                        'tariff_name': tariff_name,
-                        'total_subscriptions': 0,
-                        'active_subscriptions': 0,
-                        'total_requests': 0,
-                    }
+                tier_subscriptions = queryset.filter(tier=tier_code)
                 
-                tariff_stats[tariff_name]['total_subscriptions'] += 1
-                if subscription.is_active():
-                    tariff_stats[tariff_name]['active_subscriptions'] += 1
-                tariff_stats[tariff_name]['total_requests'] += subscription.total_requests or 0
+                tier_stats[tier_code] = {
+                    'name': tier_name,
+                    'total_subscriptions': tier_subscriptions.count(),
+                    'active_subscriptions': tier_subscriptions.filter(
+                        status=Subscription.SubscriptionStatus.ACTIVE
+                    ).count(),
+                    'total_requests': tier_subscriptions.aggregate(
+                        total=models.Sum('total_requests')
+                    )['total'] or 0,
+                }
             
             return Response({
-                'tariff_stats': tariff_stats,
+                'tier_stats': tier_stats,
                 'generated_at': timezone.now().isoformat()
             })
             
         except Exception as e:
-            logger.error(f"Subscription tariff stats failed: {e}")
+            logger.error(f"Subscription tier stats failed: {e}")
             return Response(
-                {'error': f'Tariff stats failed: {e}'},
+                {'error': f'Tier stats failed: {e}'},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR
             )
 
@@ -212,8 +217,8 @@ class UserSubscriptionViewSet(NestedPaymentViewSet):
     queryset = Subscription.objects.all()
     serializer_class = SubscriptionSerializer
     permission_classes = [permissions.IsAuthenticated]
-    filterset_fields = ['status', 'tier', 'tariff', 'endpoint_group']
-    search_fields = ['tariff__name']
+    filterset_fields = ['status', 'tier']
+    search_fields = []
     ordering_fields = ['created_at', 'updated_at', 'expires_at']
     
     # Nested ViewSet configuration
@@ -236,7 +241,7 @@ class UserSubscriptionViewSet(NestedPaymentViewSet):
             if str(self.request.user.id) != str(user_id):
                 return queryset.none()
         
-        return queryset.select_related('tariff', 'endpoint_group')
+        return queryset.select_related('user').prefetch_related('endpoint_groups')
     
     @action(detail=True, methods=['post'])
     def update_status(self, request, user_pk=None, pk=None):

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

@@ -0,0 +1,40 @@
+"""
+💰 Payments Overview Dashboard
+
+Overview dashboard for user payment metrics and analytics.
+"""
+
+from .views import PaymentsDashboardViewSet
+from .serializers import (
+    PaymentsDashboardOverviewSerializer,
+    PaymentsMetricsSerializer,
+    BalanceOverviewSerializer,
+    SubscriptionOverviewSerializer,
+    APIKeysOverviewSerializer,
+    PaymentsChartResponseSerializer,
+)
+from .services import (
+    PaymentsDashboardMetricsService,
+    PaymentsUsageChartService,
+    RecentPaymentsService,
+    PaymentsAnalyticsService,
+)
+
+__all__ = [
+    # Views
+    'PaymentsDashboardViewSet',
+    
+    # Serializers
+    'PaymentsDashboardOverviewSerializer',
+    'PaymentsMetricsSerializer',
+    'BalanceOverviewSerializer',
+    'SubscriptionOverviewSerializer',
+    'APIKeysOverviewSerializer',
+    'PaymentsChartResponseSerializer',
+    
+    # Services
+    'PaymentsDashboardMetricsService',
+    'PaymentsUsageChartService',
+    'RecentPaymentsService',
+    'PaymentsAnalyticsService',
+]