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

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

@@ -0,0 +1,175 @@
+/**
+ * Payment Form Component
+ * Handles payment creation form functionality with real provider currencies
+ */
+function paymentForm() {
+    return {
+        loading: false,
+        loadingCurrencies: false,
+        form: {
+            user: '',
+            amount_usd: '',
+            currency_code: '',
+            provider: 'nowpayments',
+            description: '',
+            callback_url: '',
+            cancel_url: ''
+        },
+        currencies: [],
+        allCurrencies: [],
+        providers: [
+            { value: 'nowpayments', name: 'NowPayments', display_name: 'NowPayments' }
+        ],
+        conversionResult: null,
+        users: [],
+
+        async init() {
+            await this.loadInitialData();
+        },
+
+        async loadInitialData() {
+            this.loading = true;
+            try {
+                // Load all currencies and provider-specific currencies
+                await Promise.all([
+                    this.loadAllCurrencies(),
+                    this.loadProviderCurrencies(),
+                    this.loadUsers()
+                ]);
+            } catch (error) {
+                console.error('Failed to load initial data:', error);
+                PaymentAPI.utils.showNotification('Failed to load form data', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+
+        async loadAllCurrencies() {
+            try {
+                const data = await PaymentAPI.currencies.supported();
+                this.allCurrencies = data.currencies || [];
+            } catch (error) {
+                console.error('Failed to load currencies:', error);
+            }
+        },
+
+        async loadProviderCurrencies() {
+            if (!this.form.provider) return;
+            
+            this.loadingCurrencies = true;
+            try {
+                const data = await PaymentAPI.currencies.providerConfigs(this.form.provider);
+                this.currencies = data.results || data.currencies || [];
+                
+                // Transform provider currency data for display
+                this.currencies = this.currencies.map(pc => ({
+                    code: pc.currency?.code || pc.provider_currency_code,
+                    name: pc.currency?.name || pc.provider_currency_code,
+                    type: pc.currency?.currency_type || 'unknown',
+                    symbol: pc.currency?.symbol || '',
+                    network: pc.network?.code || null,
+                    network_name: pc.network?.name || null,
+                    min_amount: pc.min_amount,
+                    max_amount: pc.max_amount,
+                    fee_percentage: pc.fee_percentage,
+                    fixed_fee: pc.fixed_fee,
+                    provider_code: pc.provider_currency_code
+                }));
+                
+                // If current currency is not supported by provider, reset it
+                if (this.form.currency_code && !this.currencies.find(c => c.code === this.form.currency_code)) {
+                    this.form.currency_code = '';
+                    this.conversionResult = null;
+                }
+            } catch (error) {
+                console.error('Failed to load provider currencies:', error);
+                this.currencies = [];
+            } finally {
+                this.loadingCurrencies = false;
+            }
+        },
+
+        async loadUsers() {
+            try {
+                const data = await PaymentAPI.admin.users.list();
+                this.users = data.results || data || [];
+                
+                // If no users loaded, try to get current user info
+                if (this.users.length === 0) {
+                    console.warn('No users loaded from admin API');
+                    this.users = [{ id: '', username: 'Select User', email: '' }];
+                }
+            } catch (error) {
+                console.error('Failed to load users:', error);
+                // Set empty option for user selection
+                this.users = [{ id: '', username: 'Select User', email: '' }];
+            }
+        },
+
+        async onProviderChange() {
+            await this.loadProviderCurrencies();
+        },
+
+        async onAmountOrCurrencyChange() {
+            if (this.form.amount_usd && this.form.currency_code && this.form.currency_code !== 'USD') {
+                await this.convertCurrency();
+            } else {
+                this.conversionResult = null;
+            }
+        },
+
+        async convertCurrency() {
+            if (!this.form.amount_usd || !this.form.currency_code) return;
+            
+            try {
+                const result = await PaymentAPI.currencies.convert('USD', this.form.currency_code, this.form.amount_usd);
+                this.conversionResult = {
+                    amount: result.converted_amount,
+                    rate: result.rate,
+                    currency: this.form.currency_code
+                };
+            } catch (error) {
+                console.error('Currency conversion failed:', error);
+                this.conversionResult = null;
+            }
+        },
+
+        getCurrencyInfo(code) {
+            return this.currencies.find(c => c.code === code) || 
+                   this.allCurrencies.find(c => c.code === code) || 
+                   { code, name: code, type: 'unknown' };
+        },
+
+        validateForm() {
+            const errors = [];
+            
+            if (!this.form.user) errors.push('User is required');
+            if (!this.form.amount_usd || this.form.amount_usd <= 0) errors.push('Valid amount is required');
+            if (!this.form.currency_code) errors.push('Currency is required');
+            if (!this.form.provider) errors.push('Provider is required');
+            
+            return errors;
+        },
+
+        async submitForm() {
+            const errors = this.validateForm();
+            if (errors.length > 0) {
+                PaymentAPI.utils.showNotification(errors.join(', '), 'error');
+                return;
+            }
+
+            this.loading = true;
+            
+            try {
+                const data = await PaymentAPI.admin.payments.create(this.form);
+                PaymentAPI.utils.showNotification('Payment created successfully!', 'success');
+                window.location.href = `/cfg/admin/django_cfg_payments/admin/payments/${data.id}/`;
+            } catch (error) {
+                console.error('Error:', error);
+                PaymentAPI.utils.showNotification(error.message || 'Failed to create payment', 'error');
+            } finally {
+                this.loading = false;
+            }
+        }
+    };
+}

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']