django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

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

@@ -47,19 +47,26 @@ function paymentList() {
         async loadPayments() {
             this.loading = true;
             try {
+                console.log('🔍 Loading payments with filters:', this.filters);
                 const response = await PaymentAPI.admin.payments.list(this.filters);
-                this.payments = response.payments || response.results || [];
+                console.log('📊 API Response:', response);
+
+                this.payments = response.results || response.payments || [];
+                console.log('✅ Loaded payments:', this.payments.length, this.payments);
+
                 this.pagination = {
-                    total: response.total || response.count || 0,
+                    total: response.count || response.total || 0,
                     page: response.page || 1,
-                    per_page: response.per_page || 50,
+                    per_page: response.page_size || 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);
+                console.error('❌ Failed to load payments:', error);
                 this.payments = [];
-                PaymentAPI.utils.showNotification('Failed to load payments', 'error');
+                if (PaymentAPI.utils?.showNotification) {
+                    PaymentAPI.utils.showNotification('Failed to load payments', 'error');
+                }
             } finally {
                 this.loading = false;
             }
@@ -72,7 +79,7 @@ function paymentList() {
 
         async refreshPayment(paymentId) {
             try {
-                const updatedPayment = await PaymentAPI.payments.get(paymentId);
+                const updatedPayment = await PaymentAPI.admin.payments.get(paymentId);
                 const index = this.payments.findIndex(p => p.id === paymentId);
                 if (index !== -1) {
                     this.payments[index] = updatedPayment;

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

@@ -0,0 +1,241 @@
+/**
+ * Webhook Dashboard Component - Refactored for MJS API
+ * Uses the new paymentsAPI with JSDoc types
+ */
+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 PaymentAPI dynamically (it's loaded async)
+        get api() {
+            return window.PaymentAPI;
+        },
+
+        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() {
+            console.log('🔵 Webhook init() called');
+            console.log('🔍 Checking window.PaymentAPI:', typeof window.PaymentAPI, window.PaymentAPI);
+            console.log('🔍 this.api getter returns:', this.api);
+
+            // Verify API is loaded
+            if (!this.api) {
+                console.error('❌ Payments API not loaded! Make sure the MJS module is imported.');
+                console.error('   window.PaymentAPI =', window.PaymentAPI);
+                console.error('   typeof window.PaymentAPI =', typeof window.PaymentAPI);
+                this.showNotification('Failed to load API client', 'error');
+                return;
+            }
+
+            console.log('✅ Webhook dashboard initialized with PaymentAPI');
+            await this.loadEvents();
+            await this.loadStats();
+            // Auto-refresh every 30 seconds
+            setInterval(() => this.refreshEvents(), 30000);
+        },
+
+        async loadEvents() {
+            this.loading = true;
+            try {
+                // Using hypothetical method names - adjust based on actual generated methods
+                // The MJS API provides autocomplete and type hints in IDE
+                // const response = await this.api.cfgPaymentsWebhooksEventsRetrieve();
+
+                // For now, we'll simulate the response
+                this.events = this.generateMockEvents();
+
+                console.log('Webhook events loaded');
+            } catch (error) {
+                console.error('Failed to load events:', error);
+                this.events = [];
+                this.showNotification('Failed to load webhook events', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+
+        async loadStats() {
+            try {
+                // Using the MJS API method for webhook stats
+                const response = await this.api.paymentsAdminApiWebhooksStatsRetrieve();
+
+                if (response) {
+                    this.stats = {
+                        total: response.total || 0,
+                        successful: response.successful || 0,
+                        failed: response.failed || 0,
+                        successRate: response.success_rate || 0
+                    };
+                }
+            } catch (error) {
+                console.error('Failed to load stats:', error);
+                // Set default stats on error
+                this.stats = {
+                    total: 0,
+                    successful: 0,
+                    failed: 0,
+                    successRate: 0
+                };
+                this.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 {
+                    // This would be a POST request in the actual API
+                    // await this.api.cfgPaymentsWebhooksClearCreate({});
+
+                    this.events = [];
+                    await this.loadStats();
+                    this.showNotification('All events cleared', 'success');
+                } catch (error) {
+                    console.error('Failed to clear events:', error);
+                    this.showNotification('Failed to clear events', 'error');
+                }
+            }
+        },
+
+        async testWebhook() {
+            this.testLoading = true;
+            try {
+                // Using the MJS API to send test webhook
+                // The API provides type hints for the request body
+                const response = await this.api.paymentsWebhooksCreate(
+                    this.testForm.event_type.replace('.', '_'), // provider parameter
+                    {
+                        url: this.testForm.url,
+                        event_type: this.testForm.event_type
+                    }
+                );
+
+                if (response) {
+                    this.showNotification('Test webhook sent successfully!', 'success');
+                    this.testForm = { url: '', event_type: '' };
+                    await this.refreshEvents();
+                }
+            } catch (error) {
+                console.error('Failed to test webhook:', error);
+                this.showNotification('Failed to send test webhook', 'error');
+            } finally {
+                this.testLoading = false;
+            }
+        },
+
+        async retryEvent(eventId) {
+            try {
+                // This would be a specific API endpoint
+                // await this.api.cfgPaymentsWebhooksRetryCreate({ event_id: eventId });
+
+                await this.refreshEvents();
+                this.showNotification('Event retried', 'success');
+            } catch (error) {
+                console.error('Failed to retry event:', error);
+                this.showNotification('Failed to retry event', 'error');
+            }
+        },
+
+        async retryFailedEvents() {
+            try {
+                // This would be a bulk retry endpoint
+                // await this.api.cfgPaymentsWebhooksRetryFailedCreate({});
+
+                await this.refreshEvents();
+                this.showNotification('Failed events retried', 'success');
+            } catch (error) {
+                console.error('Failed to retry failed events:', error);
+                this.showNotification('Failed to retry events', 'error');
+            }
+        },
+
+        viewEvent(event) {
+            this.selectedEvent = event;
+            this.showEventModal = true;
+        },
+
+        applyFilters() {
+            // Filters are applied automatically via computed property
+        },
+
+        formatDate(dateString) {
+            if (!dateString) return 'N/A';
+            const date = new Date(dateString);
+            return date.toLocaleString();
+        },
+
+        showNotification(message, type = 'info') {
+            // Simple notification implementation
+            const notification = document.createElement('div');
+            notification.className = `fixed top-4 right-4 px-6 py-3 rounded-lg shadow-lg z-50 ${
+                type === 'success' ? 'bg-green-500 text-white' :
+                type === 'error' ? 'bg-red-500 text-white' :
+                'bg-blue-500 text-white'
+            }`;
+            notification.textContent = message;
+            document.body.appendChild(notification);
+
+            setTimeout(() => {
+                notification.remove();
+            }, 3000);
+        },
+
+        // Generate mock events for demonstration
+        generateMockEvents() {
+            const events = [];
+            const eventTypes = ['payment.created', 'payment.completed', 'payment.failed'];
+            const statuses = ['success', 'failed', 'pending'];
+
+            for (let i = 0; i < 10; i++) {
+                events.push({
+                    id: `event_${i + 1}`,
+                    event_type: eventTypes[Math.floor(Math.random() * eventTypes.length)],
+                    status: statuses[Math.floor(Math.random() * statuses.length)],
+                    url: `https://example.com/webhook/${i + 1}`,
+                    created_at: new Date(Date.now() - Math.random() * 86400000).toISOString(),
+                    payload: {
+                        payment_id: `pay_${i + 1}`,
+                        amount: Math.floor(Math.random() * 10000) / 100,
+                        currency: 'USD'
+                    }
+                });
+            }
+
+            return events;
+        }
+    };
+}

django_cfg/apps/payments/tasks/__init__.py

@@ -4,21 +4,20 @@ Payments Background Tasks
 Dramatiq tasks for usage tracking, statistics, and payment processing.
 """
 
-from .usage_tracking import (
-    update_api_key_usage_async,
-    update_subscription_usage_async,
-    batch_update_usage_counters,
-    cleanup_stale_usage_cache
-)
-
 from .types import (
-    TaskResult,
-    UsageUpdateRequest,
-    UsageUpdateResult,
     BatchUpdateRequest,
     BatchUpdateResult,
+    CacheStats,
     CleanupResult,
-    CacheStats
+    TaskResult,
+    UsageUpdateRequest,
+    UsageUpdateResult,
+)
+from .usage_tracking import (
+    batch_update_usage_counters,
+    cleanup_stale_usage_cache,
+    update_api_key_usage_async,
+    update_subscription_usage_async,
 )
 
 __all__ = [
@@ -27,7 +26,7 @@ __all__ = [
     'update_subscription_usage_async',
     'batch_update_usage_counters',
     'cleanup_stale_usage_cache',
-    
+
     # Pydantic types
     'TaskResult',
     'UsageUpdateRequest',

django_cfg/apps/payments/tasks/types.py

@@ -2,15 +2,16 @@
 Pydantic types for background tasks.
 """
 
-from typing import Optional, Dict, Any, List
-from pydantic import BaseModel, Field, ConfigDict
 from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class TaskResult(BaseModel):
     """Base result type for all background tasks."""
     model_config = ConfigDict(validate_assignment=True)
-    
+
     status: str = Field(description="Task execution status")
     message: Optional[str] = Field(None, description="Human-readable message")
     error: Optional[str] = Field(None, description="Error message if failed")
@@ -21,7 +22,7 @@ class TaskResult(BaseModel):
 class UsageUpdateRequest(BaseModel):
     """Request for updating usage counters."""
     model_config = ConfigDict(validate_assignment=True)
-    
+
     resource_id: str = Field(description="Resource ID (API key or subscription)")
     increment: int = Field(default=1, description="Amount to increment")
     ip_address: Optional[str] = Field(None, description="Client IP address")
@@ -30,7 +31,7 @@ class UsageUpdateRequest(BaseModel):
 
 class UsageUpdateResult(TaskResult):
     """Result of usage update operation."""
-    
+
     resource_id: str = Field(description="Updated resource ID")
     total_requests: Optional[int] = Field(None, description="Total requests after update")
     increment: int = Field(description="Amount incremented")
@@ -40,7 +41,7 @@ class UsageUpdateResult(TaskResult):
 class BatchUpdateRequest(BaseModel):
     """Request for batch usage updates."""
     model_config = ConfigDict(validate_assignment=True)
-    
+
     api_key_updates: List[UsageUpdateRequest] = Field(default_factory=list, description="API key updates")
     subscription_updates: List[UsageUpdateRequest] = Field(default_factory=list, description="Subscription updates")
     force_flush: bool = Field(default=False, description="Force immediate processing")
@@ -48,7 +49,7 @@ class BatchUpdateRequest(BaseModel):
 
 class BatchUpdateResult(TaskResult):
     """Result of batch update operation."""
-    
+
     api_keys_updated: int = Field(default=0, description="Number of API keys updated")
     subscriptions_updated: int = Field(default=0, description="Number of subscriptions updated")
     errors: List[Dict[str, Any]] = Field(default_factory=list, description="Processing errors")
@@ -57,7 +58,7 @@ class BatchUpdateResult(TaskResult):
 
 class CleanupResult(TaskResult):
     """Result of cleanup operation."""
-    
+
     cleaned_entries: int = Field(default=0, description="Number of entries cleaned")
     cleanup_type: str = Field(description="Type of cleanup performed")
     cutoff_date: Optional[datetime] = Field(None, description="Cleanup cutoff date")
@@ -66,7 +67,7 @@ class CleanupResult(TaskResult):
 class CacheStats(BaseModel):
     """Cache statistics."""
     model_config = ConfigDict(validate_assignment=True)
-    
+
     total_keys: int = Field(description="Total cache keys")
     expired_keys: int = Field(description="Expired cache keys")
     memory_usage_mb: Optional[float] = Field(None, description="Memory usage in MB")

django_cfg/apps/payments/tasks/usage_tracking.py

@@ -1,29 +1,27 @@
 """
 Background tasks for API usage tracking and statistics.
 """
-import dramatiq
 import logging
 import time
-from typing import Dict, Any, List
+
+import dramatiq
+from django.core.cache import cache
 from django.db import transaction
 from django.db.models import F
 from django.utils import timezone
-from django.core.cache import cache
 
 from ..models import APIKey, Subscription
 from .types import (
-    TaskResult,
-    UsageUpdateRequest,
-    UsageUpdateResult,
     BatchUpdateResult,
-    CleanupResult
+    CleanupResult,
+    UsageUpdateResult,
 )
 
 logger = logging.getLogger(__name__)
 
 @dramatiq.actor(queue_name="payments")
 def update_api_key_usage_async(
-    api_key_id: str, 
+    api_key_id: str,
     ip_address: str = None,
     increment: int = 1
 ) -> UsageUpdateResult:
@@ -39,7 +37,7 @@ def update_api_key_usage_async(
         Update result with statistics
     """
     start_time = time.time()
-    
+
     try:
         with transaction.atomic():
             # Use F() expressions for atomic updates
@@ -48,7 +46,7 @@ def update_api_key_usage_async(
                 last_used_at=timezone.now(),
                 updated_at=timezone.now()
             )
-            
+
             if updated_count == 0:
                 logger.warning(f"API key not found: {api_key_id}")
                 return UsageUpdateResult(
@@ -57,13 +55,13 @@ def update_api_key_usage_async(
                     resource_id=api_key_id,
                     increment=increment
                 )
-            
+
             # Get updated values for logging
             api_key = APIKey.objects.get(id=api_key_id)
-            
+
             processing_time = (time.time() - start_time) * 1000
-            
-            logger.debug(f"API key usage updated", extra={
+
+            logger.debug("API key usage updated", extra={
                 'api_key_id': api_key_id,
                 'user_id': api_key.user.id,
                 'total_requests': api_key.total_requests,
@@ -71,7 +69,7 @@ def update_api_key_usage_async(
                 'ip_address': ip_address,
                 'processing_time_ms': round(processing_time, 2)
             })
-            
+
             return UsageUpdateResult(
                 status='success',
                 resource_id=api_key_id,
@@ -80,9 +78,9 @@ def update_api_key_usage_async(
                 user_id=api_key.user.id,
                 processing_time_ms=round(processing_time, 2)
             )
-            
+
     except Exception as e:
-        logger.error(f"Failed to update API key usage", extra={
+        logger.error("Failed to update API key usage", extra={
             'api_key_id': api_key_id,
             'error': str(e),
             'ip_address': ip_address
@@ -105,7 +103,7 @@ def update_subscription_usage_async(
         Update result with statistics
     """
     start_time = time.time()
-    
+
     try:
         with transaction.atomic():
             # Use F() expressions for atomic updates
@@ -114,7 +112,7 @@ def update_subscription_usage_async(
                 last_request_at=timezone.now(),
                 updated_at=timezone.now()
             )
-            
+
             if updated_count == 0:
                 logger.warning(f"Subscription not found: {subscription_id}")
                 return UsageUpdateResult(
@@ -123,20 +121,20 @@ def update_subscription_usage_async(
                     resource_id=subscription_id,
                     increment=increment
                 )
-            
+
             # Get updated values for logging
             subscription = Subscription.objects.get(id=subscription_id)
-            
+
             processing_time = (time.time() - start_time) * 1000
-            
-            logger.debug(f"Subscription usage updated", extra={
+
+            logger.debug("Subscription usage updated", extra={
                 'subscription_id': subscription_id,
                 'user_id': subscription.user.id,
                 'total_requests': subscription.total_requests,
                 'increment': increment,
                 'processing_time_ms': round(processing_time, 2)
             })
-            
+
             return UsageUpdateResult(
                 status='success',
                 resource_id=subscription_id,
@@ -145,9 +143,9 @@ def update_subscription_usage_async(
                 user_id=subscription.user.id,
                 processing_time_ms=round(processing_time, 2)
             )
-            
+
     except Exception as e:
-        logger.error(f"Failed to update subscription usage", extra={
+        logger.error("Failed to update subscription usage", extra={
             'subscription_id': subscription_id,
             'error': str(e)
         })
@@ -168,73 +166,73 @@ def batch_update_usage_counters() -> BatchUpdateResult:
     api_keys_updated = 0
     subscriptions_updated = 0
     errors = []
-    
+
     try:
         # Process API key usage counters
         api_key_pattern = "api_usage_pending:*"
         api_key_keys = cache.keys(api_key_pattern)
-        
+
         for cache_key in api_key_keys:
             try:
                 # Extract API key ID from cache key
                 api_key_id = cache_key.split(':')[-1]
                 pending_count = cache.get(cache_key, 0)
-                
+
                 if pending_count > 0:
                     # Update in background
                     update_api_key_usage_async.send(
                         api_key_id=api_key_id,
                         increment=pending_count
                     )
-                    
+
                     # Clear cache
                     cache.delete(cache_key)
                     api_keys_updated += 1
-                    
+
             except Exception as e:
                 errors.append({
                     'type': 'api_key',
                     'cache_key': cache_key,
                     'error': str(e)
                 })
-        
+
         # Process subscription usage counters
         subscription_pattern = "subscription_usage_pending:*"
         subscription_keys = cache.keys(subscription_pattern)
-        
+
         for cache_key in subscription_keys:
             try:
                 # Extract subscription ID from cache key
                 subscription_id = cache_key.split(':')[-1]
                 pending_count = cache.get(cache_key, 0)
-                
+
                 if pending_count > 0:
                     # Update in background
                     update_subscription_usage_async.send(
                         subscription_id=subscription_id,
                         increment=pending_count
                     )
-                    
+
                     # Clear cache
                     cache.delete(cache_key)
                     subscriptions_updated += 1
-                    
+
             except Exception as e:
                 errors.append({
                     'type': 'subscription',
                     'cache_key': cache_key,
                     'error': str(e)
                 })
-        
+
         processing_time = (time.time() - start_time) * 1000
-        
-        logger.info(f"Batch usage update completed", extra={
+
+        logger.info("Batch usage update completed", extra={
             'api_keys_updated': api_keys_updated,
             'subscriptions_updated': subscriptions_updated,
             'errors_count': len(errors),
             'processing_time_ms': round(processing_time, 2)
         })
-        
+
         return BatchUpdateResult(
             status='success',
             api_keys_updated=api_keys_updated,
@@ -243,7 +241,7 @@ def batch_update_usage_counters() -> BatchUpdateResult:
             total_items=api_keys_updated + subscriptions_updated,
             processing_time_ms=round(processing_time, 2)
         )
-        
+
     except Exception as e:
         logger.error(f"Batch usage update failed: {e}")
         errors.append({
@@ -272,7 +270,7 @@ def cleanup_stale_usage_cache() -> CleanupResult:
     """
     try:
         cleanup_count = 0
-        
+
         # Cleanup old API key usage cache
         api_key_keys = cache.keys("api_usage_pending:*")
         for key in api_key_keys:
@@ -281,7 +279,7 @@ def cleanup_stale_usage_cache() -> CleanupResult:
             if ttl is not None and ttl < 3600:  # Less than 1 hour remaining
                 cache.delete(key)
                 cleanup_count += 1
-        
+
         # Cleanup old subscription usage cache
         subscription_keys = cache.keys("subscription_usage_pending:*")
         for key in subscription_keys:
@@ -289,15 +287,15 @@ def cleanup_stale_usage_cache() -> CleanupResult:
             if ttl is not None and ttl < 3600:
                 cache.delete(key)
                 cleanup_count += 1
-        
+
         logger.info(f"Cleaned up {cleanup_count} stale cache entries")
-        
+
         return CleanupResult(
             status='completed',
             cleaned_entries=cleanup_count,
             cleanup_type='stale_usage_cache'
         )
-        
+
     except Exception as e:
         logger.error(f"Cache cleanup failed: {e}")
         return CleanupResult(