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

django_cfg/apps/payments/static/payments/js/api-client.js

@@ -10,8 +10,22 @@ class PaymentAPIClient {
 
     // Helper method to get CSRF token
     getCSRFToken() {
-        const token = document.querySelector('[name=csrfmiddlewaretoken]');
-        return token ? token.value : '';
+        // Try to get token from form input first
+        const tokenInput = document.querySelector('[name=csrfmiddlewaretoken]');
+        if (tokenInput && tokenInput.value) {
+            return tokenInput.value;
+        }
+        
+        // Fallback to cookie
+        const cookieString = document.cookie;
+        if (cookieString.includes('csrftoken=')) {
+            const match = cookieString.match(/csrftoken=([^;]+)/);
+            if (match) {
+                return match[1];
+            }
+        }
+            
+        return '';
     }
 
     // Generic request method
@@ -129,16 +143,20 @@ class PaymentAPIClient {
         supported: (params = {}) => this.get(`${this.baseURL}/currencies/supported/`, params),
         
         // Get currencies by provider
-        byProvider: (provider) => this.get(`${this.baseURL}/currencies/supported/`, { provider }),
+        byProvider: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider, page_size: 1000 }),
         
         // Get exchange rates
         rates: (params = {}) => this.get(`${this.baseURL}/currencies/rates/`, params),
         
         // Convert currency
-        convert: (from, to, amount) => this.post(`${this.baseURL}/currencies/convert/`, { from, to, amount }),
+        convert: (from, to, amount) => this.post(`${this.baseURL}/currencies/convert/`, { 
+            from_currency: from, 
+            to_currency: to, 
+            amount: amount 
+        }),
         
         // Get provider-specific currency configurations
-        providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider }),
+        providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider, page_size: 1000 }),
         
         // Get currencies grouped by provider
         byProviderGrouped: () => this.get(`${this.baseURL}/provider-currencies/by_provider/`)
@@ -283,6 +301,7 @@ class PaymentAPIClient {
             delete: (id) => this.delete(`${this.adminURL}/api/payments/${id}/`),
             cancel: (id) => this.post(`${this.adminURL}/api/payments/${id}/cancel/`),
             refund: (id) => this.post(`${this.adminURL}/api/payments/${id}/refund/`),
+            refreshStatus: (id) => this.post(`${this.adminURL}/api/payments/${id}/refresh_status/`),
             stats: () => this.get(`${this.adminURL}/api/payments/stats/`)
         },
         
@@ -302,7 +321,7 @@ class PaymentAPIClient {
         
         // Webhook test method
         webhookTest: {
-            send: (url, eventType) => this.post(`${this.adminURL}/api/webhooks/test/`, { 
+            send: (url, eventType) => this.post(`${this.adminURL}/api/webhook-test/test/`, { 
                 webhook_url: url, 
                 event_type: eventType 
             })
@@ -377,7 +396,11 @@ class PaymentAPIClient {
 }
 
 // Create global instance
+console.log('🔧 PaymentAPIClient: Creating global instance...');
 window.PaymentAPI = new PaymentAPIClient();
+console.log('✅ PaymentAPIClient: Global instance created');
+console.log('🔍 PaymentAPI.currencies:', window.PaymentAPI.currencies);
+console.log('🔍 PaymentAPI.admin:', window.PaymentAPI.admin);
 
 // Export for modules
 if (typeof module !== 'undefined' && module.exports) {

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

@@ -0,0 +1,167 @@
+/**
+ * Payment Detail Page JavaScript
+ * Handles payment detail page functionality including AJAX status refresh
+ */
+
+function paymentDetail() {
+    return {
+        loading: false,
+        showQRCode: false,
+        paymentId: null,
+        
+        init(paymentId) {
+            this.paymentId = paymentId;
+            // Show QR code by default if payment address exists
+            const payAddress = document.querySelector('[data-field="pay_address"]');
+            if (payAddress && payAddress.textContent.trim()) {
+                this.showQRCode = true;
+            }
+        },
+        
+        async refreshPaymentStatus() {
+            this.loading = true;
+            try {
+                // Use the existing PaymentAPI client
+                const data = await PaymentAPI.admin.payments.refreshStatus(this.paymentId);
+                
+                if (data.success) {
+                    // Show success notification
+                    PaymentAPI.utils.showNotification(data.message, 'success');
+                    
+                    // Update payment data on page without full reload
+                    this.updatePaymentData(data.payment);
+                } else {
+                    // Show error notification
+                    PaymentAPI.utils.showNotification(data.message || 'Failed to refresh payment status', 'error');
+                }
+            } catch (error) {
+                console.error('Failed to refresh payment status:', error);
+                PaymentAPI.utils.showNotification('Network error while refreshing status', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+        
+        updatePaymentData(paymentData) {
+            // Update status badge
+            const statusBadge = document.querySelector('.payment-status-badge');
+            if (statusBadge && paymentData.status) {
+                statusBadge.textContent = paymentData.status.toUpperCase();
+                statusBadge.className = `payment-status-badge inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${this.getStatusBadgeClass(paymentData.status)}`;
+            }
+            
+            // Update other fields that might have changed
+            const fields = {
+                'pay_amount': paymentData.pay_amount,
+                'transaction_hash': paymentData.transaction_hash,
+                'pay_address': paymentData.pay_address,
+                'payment_url': paymentData.payment_url,
+                'expires_at': paymentData.expires_at,
+                'confirmed_at': paymentData.confirmed_at,
+                'updated_at': paymentData.updated_at,
+                'status_changed_at': paymentData.status_changed_at
+            };
+            
+            Object.entries(fields).forEach(([field, value]) => {
+                const element = document.querySelector(`[data-field="${field}"]`);
+                if (element && value !== null && value !== undefined) {
+                    if (field.includes('_at') && value) {
+                        // Format datetime fields
+                        element.textContent = new Date(value).toLocaleString();
+                    } else if (field === 'pay_amount' && paymentData.currency) {
+                        // Format pay_amount with currency
+                        element.textContent = `${parseFloat(value).toFixed(8)} ${paymentData.currency.code}`;
+                    } else {
+                        element.textContent = value;
+                    }
+                }
+            });
+            
+            // Update error info if present
+            if (paymentData.error_info) {
+                const errorElement = document.querySelector('[data-field="error_info"]');
+                if (errorElement) {
+                    errorElement.textContent = JSON.stringify(paymentData.error_info, null, 2);
+                }
+            }
+            
+            // Update QR code visibility if pay_address changed
+            if (paymentData.pay_address && !this.showQRCode) {
+                this.showQRCode = true;
+            }
+        },
+        
+        getStatusBadgeClass(status) {
+            const statusClasses = {
+                'pending': 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-300',
+                'confirming': 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-300',
+                'completed': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300',
+                'confirmed': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300',
+                'failed': 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-300',
+                'cancelled': 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-300',
+                'expired': 'bg-orange-100 text-orange-800 dark:bg-orange-900 dark:text-orange-300',
+                'refunded': 'bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-300'
+            };
+            return statusClasses[status] || 'bg-gray-100 text-gray-800 dark:bg-gray-900 dark:text-gray-300';
+        },
+        
+        async cancelPayment() {
+            if (!confirm('Are you sure you want to cancel this payment?')) {
+                return;
+            }
+            
+            this.loading = true;
+            try {
+                const data = await PaymentAPI.admin.payments.cancel(this.paymentId);
+                PaymentAPI.utils.showNotification('Payment cancelled successfully', 'success');
+                
+                // Update payment data
+                this.updatePaymentData(data);
+            } catch (error) {
+                console.error('Failed to cancel payment:', error);
+                PaymentAPI.utils.showNotification('Failed to cancel payment', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+        
+        exportDetails() {
+            // Get payment data from the page
+            const paymentData = {
+                id: this.paymentId,
+                status: document.querySelector('.payment-status-badge')?.textContent || 'Unknown',
+                amount_usd: document.querySelector('[data-field="amount_usd"]')?.textContent || '',
+                pay_amount: document.querySelector('[data-field="pay_amount"]')?.textContent || '',
+                currency: document.querySelector('[data-field="currency"]')?.textContent || '',
+                provider: document.querySelector('[data-field="provider"]')?.textContent || '',
+                pay_address: document.querySelector('[data-field="pay_address"]')?.textContent || '',
+                transaction_hash: document.querySelector('[data-field="transaction_hash"]')?.textContent || '',
+                created_at: document.querySelector('[data-field="created_at"]')?.textContent || '',
+                updated_at: document.querySelector('[data-field="updated_at"]')?.textContent || ''
+            };
+            
+            // Create CSV content
+            const csvContent = Object.entries(paymentData)
+                .map(([key, value]) => `${key},${value}`)
+                .join('\n');
+            
+            // Download CSV
+            const blob = new Blob([csvContent], { type: 'text/csv' });
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = `payment_${this.paymentId}_details.csv`;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+        }
+    };
+}
+
+// Auto-initialize if PaymentAPI is available
+document.addEventListener('DOMContentLoaded', function() {
+    if (typeof PaymentAPI === 'undefined') {
+        console.warn('PaymentAPI not found. Make sure api-client.js is loaded before payment-detail.js');
+    }
+});

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

@@ -22,12 +22,18 @@ function paymentForm() {
         ],
         conversionResult: null,
         users: [],
+        errorMessage: '',
 
         async init() {
+            console.log('🚀 PaymentForm: Initializing...');
+            console.log('🔍 PaymentAPI object:', window.PaymentAPI);
+            console.log('🔍 PaymentAPI.currencies:', window.PaymentAPI?.currencies);
+            console.log('🔍 PaymentAPI.admin:', window.PaymentAPI?.admin);
             await this.loadInitialData();
         },
 
         async loadInitialData() {
+            console.log('📊 PaymentForm: Loading initial data...');
             this.loading = true;
             try {
                 // Load all currencies and provider-specific currencies
@@ -36,8 +42,9 @@ function paymentForm() {
                     this.loadProviderCurrencies(),
                     this.loadUsers()
                 ]);
+                console.log('✅ PaymentForm: Initial data loaded successfully');
             } catch (error) {
-                console.error('Failed to load initial data:', error);
+                console.error('❌ PaymentForm: Failed to load initial data:', error);
                 PaymentAPI.utils.showNotification('Failed to load form data', 'error');
             } finally {
                 this.loading = false;
@@ -45,44 +52,60 @@ function paymentForm() {
         },
 
         async loadAllCurrencies() {
+            console.log('💰 PaymentForm: Loading all currencies...');
+            console.log('🔍 PaymentAPI.currencies.supported type:', typeof PaymentAPI.currencies.supported);
             try {
+                if (typeof PaymentAPI.currencies.supported !== 'function') {
+                    console.error('❌ PaymentAPI.currencies.supported is not a function:', PaymentAPI.currencies.supported);
+                    console.log('🔍 Available currencies methods:', Object.keys(PaymentAPI.currencies));
+                    return;
+                }
                 const data = await PaymentAPI.currencies.supported();
-                this.allCurrencies = data.currencies || [];
+                console.log('📊 Currencies API response:', data);
+                this.allCurrencies = data.currencies?.currencies || data.currencies || [];
+                console.log('✅ Loaded currencies:', this.allCurrencies.length);
             } catch (error) {
-                console.error('Failed to load currencies:', error);
+                console.error('❌ Failed to load currencies:', error);
             }
         },
 
         async loadProviderCurrencies() {
-            if (!this.form.provider) return;
+            if (!this.form.provider) {
+                console.log('⚠️ PaymentForm: No provider selected, skipping currency load');
+                return;
+            }
+            
+            console.log('🏦 PaymentForm: Loading provider currencies for:', this.form.provider);
+            console.log('🔍 PaymentAPI.currencies.byProvider type:', typeof PaymentAPI.currencies.byProvider);
             
             this.loadingCurrencies = true;
             try {
-                const data = await PaymentAPI.currencies.providerConfigs(this.form.provider);
-                this.currencies = data.results || data.currencies || [];
+                if (typeof PaymentAPI.currencies.byProvider !== 'function') {
+                    console.error('❌ PaymentAPI.currencies.byProvider is not a function:', PaymentAPI.currencies.byProvider);
+                    console.log('🔍 Available currencies methods:', Object.keys(PaymentAPI.currencies));
+                    return;
+                }
+                
+                // Use the provider-currencies API endpoint directly
+                const response = await PaymentAPI.request(`/api/payments/provider-currencies/by_provider/?provider=${this.form.provider}`);
+                console.log('📊 Provider currencies API response:', response);
                 
-                // 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
-                }));
+                // Extract currencies for the specific provider
+                const providerData = response.currencies_by_provider?.[this.form.provider];
+                this.currencies = providerData?.currencies || [];
+                
+                console.log('🔍 Sample currency structure:', this.currencies[0]);
+                
+                console.log('✅ Loaded provider currencies:', this.currencies.length);
                 
                 // 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)) {
+                if (this.form.currency_code && !this.currencies.find(c => c.provider_currency_code === this.form.currency_code)) {
+                    console.log('⚠️ Current currency not supported by provider, resetting');
                     this.form.currency_code = '';
                     this.conversionResult = null;
                 }
             } catch (error) {
-                console.error('Failed to load provider currencies:', error);
+                console.error('❌ Failed to load provider currencies:', error);
                 this.currencies = [];
             } finally {
                 this.loadingCurrencies = false;
@@ -90,17 +113,43 @@ function paymentForm() {
         },
 
         async loadUsers() {
+            console.log('👥 PaymentForm: Loading users...');
+            console.log('🔍 PaymentAPI.admin:', PaymentAPI.admin);
+            console.log('🔍 PaymentAPI.admin?.users:', PaymentAPI.admin?.users);
+            console.log('🔍 PaymentAPI.admin?.users?.list type:', typeof PaymentAPI.admin?.users?.list);
+            
             try {
+                if (!PaymentAPI.admin) {
+                    console.error('❌ PaymentAPI.admin is undefined');
+                    this.users = [{ id: '', username: 'Select User', email: '' }];
+                    return;
+                }
+                
+                if (!PaymentAPI.admin.users) {
+                    console.error('❌ PaymentAPI.admin.users is undefined');
+                    this.users = [{ id: '', username: 'Select User', email: '' }];
+                    return;
+                }
+                
+                if (typeof PaymentAPI.admin.users.list !== 'function') {
+                    console.error('❌ PaymentAPI.admin.users.list is not a function:', PaymentAPI.admin.users.list);
+                    this.users = [{ id: '', username: 'Select User', email: '' }];
+                    return;
+                }
+                
                 const data = await PaymentAPI.admin.users.list();
+                console.log('📊 Users API response:', data);
                 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');
+                    console.warn('⚠️ No users loaded from admin API');
                     this.users = [{ id: '', username: 'Select User', email: '' }];
+                } else {
+                    console.log('✅ Loaded users:', this.users.length);
                 }
             } catch (error) {
-                console.error('Failed to load users:', error);
+                console.error('❌ Failed to load users:', error);
                 // Set empty option for user selection
                 this.users = [{ id: '', username: 'Select User', email: '' }];
             }
@@ -122,11 +171,15 @@ function paymentForm() {
             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);
+                // Get the original currency code for conversion (not provider code)
+                const currencyInfo = this.getCurrencyInfo(this.form.currency_code);
+                const originalCurrencyCode = currencyInfo.currency?.code || this.form.currency_code;
+                
+                const result = await PaymentAPI.currencies.convert('USD', originalCurrencyCode, this.form.amount_usd);
                 this.conversionResult = {
                     amount: result.converted_amount,
                     rate: result.rate,
-                    currency: this.form.currency_code
+                    currency: originalCurrencyCode
                 };
             } catch (error) {
                 console.error('Currency conversion failed:', error);
@@ -134,10 +187,10 @@ function paymentForm() {
             }
         },
 
-        getCurrencyInfo(code) {
-            return this.currencies.find(c => c.code === code) || 
-                   this.allCurrencies.find(c => c.code === code) || 
-                   { code, name: code, type: 'unknown' };
+        getCurrencyInfo(providerCurrencyCode) {
+            return this.currencies.find(c => c.provider_currency_code === providerCurrencyCode) || 
+                   this.allCurrencies.find(c => c.code === providerCurrencyCode) || 
+                   { provider_currency_code: providerCurrencyCode, currency: { code: providerCurrencyCode, name: providerCurrencyCode, currency_type: 'unknown' } };
         },
 
         validateForm() {
@@ -151,10 +204,18 @@ function paymentForm() {
             return errors;
         },
 
+        clearError() {
+            this.errorMessage = '';
+        },
+
         async submitForm() {
+            // Clear previous error
+            this.clearError();
+            
             const errors = this.validateForm();
             if (errors.length > 0) {
-                PaymentAPI.utils.showNotification(errors.join(', '), 'error');
+                this.errorMessage = errors.join(', ');
+                PaymentAPI.utils.showNotification('Please fix form errors', 'error');
                 return;
             }
 
@@ -166,7 +227,12 @@ function paymentForm() {
                 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');
+                
+                // Show detailed error in form
+                this.errorMessage = error.message || 'Failed to create payment';
+                
+                // Show brief notification
+                PaymentAPI.utils.showNotification('Payment creation failed', 'error');
             } finally {
                 this.loading = false;
             }

django_cfg/apps/payments/tasks/__init__.py

@@ -0,0 +1,39 @@
+"""
+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,
+    CleanupResult,
+    CacheStats
+)
+
+__all__ = [
+    # Usage tracking tasks
+    'update_api_key_usage_async',
+    'update_subscription_usage_async',
+    'batch_update_usage_counters',
+    'cleanup_stale_usage_cache',
+    
+    # Pydantic types
+    'TaskResult',
+    'UsageUpdateRequest',
+    'UsageUpdateResult',
+    'BatchUpdateRequest',
+    'BatchUpdateResult',
+    'CleanupResult',
+    'CacheStats',
+]

django_cfg/apps/payments/tasks/types.py

@@ -0,0 +1,73 @@
+"""
+Pydantic types for background tasks.
+"""
+
+from typing import Optional, Dict, Any, List
+from pydantic import BaseModel, Field, ConfigDict
+from datetime import datetime
+
+
+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")
+    processing_time_ms: Optional[float] = Field(None, description="Processing time in milliseconds")
+    timestamp: datetime = Field(default_factory=datetime.utcnow, description="Task completion timestamp")
+
+
+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")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+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")
+    user_id: Optional[int] = Field(None, description="Associated user ID")
+
+
+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")
+
+
+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")
+    total_items: int = Field(description="Total items processed")
+
+
+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")
+
+
+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")
+    hit_rate: Optional[float] = Field(None, description="Cache hit rate percentage")