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

django_cfg/apps/payments/services/providers/registry.py

@@ -411,6 +411,26 @@ class ProviderRegistry:
         self._provider_configs[provider_name] = config_class
         logger.info(f"Registered provider class: {provider_name}")
     
+    def register_provider(self, provider_name: str, provider_instance: BaseProvider):
+        """
+        Register provider instance directly (for testing).
+        
+        Args:
+            provider_name: Provider name
+            provider_instance: Provider instance
+        """
+        self._providers[provider_name] = provider_instance
+        logger.info(f"Registered provider instance: {provider_name}")
+    
+    @property
+    def providers(self) -> Dict[str, BaseProvider]:
+        """Get dictionary of registered providers."""
+        return self._providers.copy()
+    
+    def list_providers(self) -> List[str]:
+        """Get list of registered provider names."""
+        return list(self._providers.keys())
+    
     def __len__(self) -> int:
         """Get number of initialized providers."""
         return len(self._providers)

django_cfg/apps/payments/signals/api_key_signals.py

@@ -43,7 +43,7 @@ def handle_api_key_changes(sender, instance: APIKey, created: bool, **kwargs):
         logger.info(f"New API key created", extra={
             'api_key_id': str(instance.id),
             'user_id': instance.user.id,
-            'name': instance.name,
+            'key_name': instance.name,
             'expires_at': instance.expires_at.isoformat() if instance.expires_at else None
         })
         
@@ -52,7 +52,7 @@ def handle_api_key_changes(sender, instance: APIKey, created: bool, **kwargs):
             f"api_key_created:{instance.user.id}:{instance.id}",
             {
                 'api_key_id': str(instance.id),
-                'name': instance.name,
+                'key_name': instance.name,
                 'timestamp': timezone.now().isoformat()
             },
             timeout=86400  # 24 hours

django_cfg/apps/payments/signals/balance_signals.py

@@ -9,6 +9,7 @@ from django.db.models.signals import post_save, post_delete, pre_save
 from django.dispatch import receiver
 from django.core.cache import cache
 from django.utils import timezone
+from decimal import Decimal
 
 from ..models import UserBalance, Transaction
 from django_cfg.modules.django_logger import get_logger
@@ -22,7 +23,8 @@ def store_original_balance(sender, instance: UserBalance, **kwargs):
     if instance.pk:
         try:
             original = UserBalance.objects.get(pk=instance.pk)
-            instance._original_balance = original.balance_usd
+            # Ensure _original_balance is always Decimal
+            instance._original_balance = Decimal(str(original.balance_usd)) if original.balance_usd is not None else None
         except UserBalance.DoesNotExist:
             instance._original_balance = None
     else:
@@ -44,8 +46,9 @@ def handle_balance_change(sender, instance: UserBalance, created: bool, **kwargs
     else:
         # Check if balance changed
         if hasattr(instance, '_original_balance'):
-            old_balance = instance._original_balance or 0.0
-            new_balance = instance.balance_usd
+            # Ensure both values are Decimal for consistent arithmetic
+            old_balance = Decimal(str(instance._original_balance or 0.0))
+            new_balance = Decimal(str(instance.balance_usd))
             
             if old_balance != new_balance:
                 balance_change = new_balance - old_balance
@@ -81,7 +84,7 @@ def handle_transaction_creation(sender, instance: Transaction, created: bool, **
             'transaction_id': str(instance.id),
             'user_id': instance.user.id,
             'transaction_type': instance.transaction_type,
-            'amount': instance.amount,
+            'amount': instance.amount_usd,
             'payment_id': str(instance.payment_id) if instance.payment_id else None
         })
         
@@ -143,7 +146,7 @@ def _handle_zero_balance(balance: UserBalance):
             f"zero_balance:{balance.user.id}",
             {
                 'timestamp': timezone.now().isoformat(),
-                'previous_balance': getattr(balance, '_original_balance', 0.0)
+                'previous_balance': getattr(balance, '_original_balance', Decimal('0.0'))
             },
             timeout=86400 * 7  # 7 days
         )

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

@@ -0,0 +1,385 @@
+/**
+ * Payment API Client
+ * Provides convenient methods for API calls with automatic JSON handling
+ */
+class PaymentAPIClient {
+    constructor() {
+        this.baseURL = '/api/payments';
+        this.adminURL = '/cfg/admin/django_cfg_payments/admin';
+    }
+
+    // Helper method to get CSRF token
+    getCSRFToken() {
+        const token = document.querySelector('[name=csrfmiddlewaretoken]');
+        return token ? token.value : '';
+    }
+
+    // Generic request method
+    async request(url, options = {}) {
+        const config = {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': this.getCSRFToken(),
+                ...options.headers
+            },
+            ...options
+        };
+
+        try {
+            const response = await fetch(url, config);
+            
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'Request failed' }));
+                throw new Error(error.message || `HTTP ${response.status}`);
+            }
+
+            return await response.json();
+        } catch (error) {
+            console.error('API Request failed:', error);
+            throw error;
+        }
+    }
+
+    // GET request
+    async get(url, params = {}) {
+        const urlWithParams = new URL(url, window.location.origin);
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== null && value !== undefined && value !== '') {
+                urlWithParams.searchParams.append(key, value);
+            }
+        });
+        
+        return this.request(urlWithParams.toString());
+    }
+
+    // POST request
+    async post(url, data = {}) {
+        return this.request(url, {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+
+    // PUT request
+    async put(url, data = {}) {
+        return this.request(url, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+        });
+    }
+
+    // DELETE request
+    async delete(url) {
+        return this.request(url, {
+            method: 'DELETE'
+        });
+    }
+
+    // PAYMENTS API
+    payments = {
+        // Get all payments
+        list: (params = {}) => this.get(`${this.baseURL}/payments/`, params),
+        
+        // Get payment by ID
+        get: (id) => this.get(`${this.baseURL}/payments/${id}/`),
+        
+        // Create payment
+        create: (data) => this.post(`${this.baseURL}/payments/create/`, data),
+        
+        // Get payment status
+        status: (id) => this.get(`${this.baseURL}/payments/status/${id}/`),
+        
+        // Check payment status
+        checkStatus: (id) => this.post(`${this.baseURL}/payments/${id}/check_status/`),
+        
+        // Cancel payment
+        cancel: (id) => this.post(`${this.baseURL}/payments/${id}/cancel/`),
+        
+        // Get payment stats
+        stats: () => this.get(`${this.baseURL}/payments/stats/`),
+        
+        // Get payment analytics
+        analytics: (params = {}) => this.get(`${this.baseURL}/payments/analytics/`, params),
+        
+        // Get payments by provider
+        byProvider: (provider) => this.get(`${this.baseURL}/payments/by_provider/`, { provider })
+    };
+
+    // WEBHOOKS API
+    webhooks = {
+        // Get webhook stats
+        stats: () => this.get(`${this.baseURL}/webhooks/stats/`),
+        
+        // Get supported providers
+        providers: () => this.get(`${this.baseURL}/webhooks/providers/`),
+        
+        // Health check
+        health: () => this.get(`${this.baseURL}/webhooks/health/`)
+    };
+
+    // CURRENCIES API
+    currencies = {
+        // Get all currencies
+        list: () => this.get(`${this.baseURL}/currencies/`),
+        
+        // Get currency by ID
+        get: (id) => this.get(`${this.baseURL}/currencies/${id}/`),
+        
+        // Get supported currencies
+        supported: (params = {}) => this.get(`${this.baseURL}/currencies/supported/`, params),
+        
+        // Get currencies by provider
+        byProvider: (provider) => this.get(`${this.baseURL}/currencies/supported/`, { provider }),
+        
+        // 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 }),
+        
+        // Get provider-specific currency configurations
+        providerConfigs: (provider) => this.get(`${this.baseURL}/provider-currencies/`, { provider }),
+        
+        // Get currencies grouped by provider
+        byProviderGrouped: () => this.get(`${this.baseURL}/provider-currencies/by_provider/`)
+    };
+
+    // BALANCES API
+    balances = {
+        // Get all balances
+        list: (params = {}) => this.get(`${this.baseURL}/balances/`, params),
+        
+        // Get balance by ID
+        get: (id) => this.get(`${this.baseURL}/balances/${id}/`),
+        
+        // Top up balance
+        topup: (id, amount, currency) => this.post(`${this.baseURL}/balances/${id}/topup/`, { amount, currency }),
+        
+        // Withdraw from balance
+        withdraw: (id, amount, currency) => this.post(`${this.baseURL}/balances/${id}/withdraw/`, { amount, currency })
+    };
+
+    // TRANSACTIONS API
+    transactions = {
+        // Get all transactions
+        list: (params = {}) => this.get(`${this.baseURL}/transactions/`, params),
+        
+        // Get transaction by ID
+        get: (id) => this.get(`${this.baseURL}/transactions/${id}/`),
+        
+        // Get recent transactions
+        recent: (limit = 10) => this.get(`${this.baseURL}/transactions/recent/`, { limit }),
+        
+        // Get transactions by type
+        byType: (type) => this.get(`${this.baseURL}/transactions/by_type/`, { type }),
+        
+        // Get transaction stats
+        stats: () => this.get(`${this.baseURL}/transactions/stats/`)
+    };
+
+    // API KEYS API
+    apiKeys = {
+        // Get all API keys
+        list: () => this.get(`${this.baseURL}/api-keys/`),
+        
+        // Get API key by ID
+        get: (id) => this.get(`${this.baseURL}/api-keys/${id}/`),
+        
+        // Generate new API key
+        generate: (data) => this.post(`${this.baseURL}/api-keys/generate/`, data),
+        
+        // Revoke API key
+        revoke: (id) => this.post(`${this.baseURL}/api-keys/${id}/revoke/`),
+        
+        // Get API key stats
+        stats: () => this.get(`${this.baseURL}/api-keys/stats/`)
+    };
+
+    // DASHBOARD API
+    dashboard = {
+        // Get dashboard overview
+        overview: () => this.get(`${this.baseURL}/overview/dashboard/overview/`),
+        
+        // Get dashboard metrics
+        metrics: () => this.get(`${this.baseURL}/overview/dashboard/metrics/`),
+        
+        // Get chart data
+        chartData: (period = '7d') => this.get(`${this.baseURL}/overview/dashboard/chart_data/`, { period }),
+        
+        // Get recent payments
+        recentPayments: (limit = 5) => this.get(`${this.baseURL}/overview/dashboard/recent_payments/`, { limit }),
+        
+        // Get recent transactions
+        recentTransactions: (limit = 5) => this.get(`${this.baseURL}/overview/dashboard/recent_transactions/`, { limit }),
+        
+        // Get payment analytics
+        paymentAnalytics: () => this.get(`${this.baseURL}/overview/dashboard/payment_analytics/`),
+        
+        // Get balance overview
+        balanceOverview: () => this.get(`${this.baseURL}/overview/dashboard/balance_overview/`),
+        
+        // Get subscription overview
+        subscriptionOverview: () => this.get(`${this.baseURL}/overview/dashboard/subscription_overview/`),
+        
+        // Get API keys overview
+        apiKeysOverview: () => this.get(`${this.baseURL}/overview/dashboard/api_keys_overview/`)
+    };
+
+    // NGROK API (custom endpoints)
+    ngrok = {
+        // Get ngrok status from webhook health endpoint
+        status: async () => {
+            try {
+                const response = await this.get('/api/payments/webhooks/health/');
+                const ngrokActive = response.details?.ngrok_available || false;
+                const apiUrl = response.details?.api_base_url || '';
+                
+                if (ngrokActive) {
+                    return {
+                        active: true,
+                        public_url: apiUrl,
+                        webhook_url: apiUrl + '/api/payments/webhooks/',
+                        region: 'auto',
+                        proto: apiUrl.startsWith('https') ? 'https' : 'http',
+                        error: null
+                    };
+                } else {
+                    return {
+                        active: false,
+                        public_url: '',
+                        webhook_url: '',
+                        region: 'us',
+                        proto: 'https',
+                        error: 'Ngrok tunnel not active'
+                    };
+                }
+            } catch (error) {
+                return {
+                    active: false,
+                    public_url: '',
+                    webhook_url: '',
+                    region: 'us',
+                    proto: 'https',
+                    error: error.message || 'Health check API not accessible'
+                };
+            }
+        },
+        
+        // Start ngrok tunnel (placeholder - not implemented)
+        start: () => this.post(`${this.adminURL}/ngrok/start/`),
+        
+        // Stop ngrok tunnel (placeholder - not implemented)
+        stop: () => this.post(`${this.adminURL}/ngrok/stop/`)
+    };
+
+    // ADMIN API ENDPOINTS (DRF nested router structure)
+    admin = {
+        // Payments API
+        payments: {
+            list: (params = {}) => this.get(`${this.adminURL}/api/payments/`, params),
+            get: (id) => this.get(`${this.adminURL}/api/payments/${id}/`),
+            create: (data) => this.post(`${this.adminURL}/api/payments/`, data),
+            update: (id, data) => this.patch(`${this.adminURL}/api/payments/${id}/`, data),
+            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/`),
+            stats: () => this.get(`${this.adminURL}/api/payments/stats/`)
+        },
+        
+        // Webhooks API
+        webhooks: {
+            list: () => this.get(`${this.adminURL}/api/webhooks/`),
+            stats: () => this.get(`${this.adminURL}/api/webhooks/stats/`),
+            
+            // Nested webhook events
+            events: {
+                list: (webhookId = 1, params = {}) => this.get(`${this.adminURL}/api/webhooks/${webhookId}/events/`, params),
+                retry: (webhookId, eventId) => this.post(`${this.adminURL}/api/webhooks/${webhookId}/events/${eventId}/retry/`),
+                clearAll: (webhookId) => this.post(`${this.adminURL}/api/webhooks/${webhookId}/events/clear_all/`),
+                retryFailed: (webhookId) => this.post(`${this.adminURL}/api/webhooks/${webhookId}/events/retry_failed/`)
+            }
+        },
+        
+        // Webhook test method
+        webhookTest: {
+            send: (url, eventType) => this.post(`${this.adminURL}/api/webhooks/test/`, { 
+                webhook_url: url, 
+                event_type: eventType 
+            })
+        },
+        
+        // Stats API
+        stats: {
+            overview: () => this.get(`${this.adminURL}/api/stats/`),
+            payments: () => this.get(`${this.adminURL}/api/stats/payments/`),
+            webhooks: () => this.get(`${this.adminURL}/api/stats/webhooks/`),
+            system: () => this.get(`${this.adminURL}/api/stats/system/`)
+        },
+        
+        // Users API
+        users: {
+            list: (params = {}) => this.get(`${this.adminURL}/api/users/`, params),
+            get: (id) => this.get(`${this.adminURL}/api/users/${id}/`),
+            search: (query) => this.get(`${this.adminURL}/api/users/`, { q: query })
+        }
+    };
+
+
+    // Utility methods
+    utils = {
+        // Format currency
+        formatCurrency: (amount, currency = 'USD') => {
+            return new Intl.NumberFormat('en-US', {
+                style: 'currency',
+                currency: currency
+            }).format(amount);
+        },
+
+        // Format date
+        formatDate: (dateString) => {
+            return new Date(dateString).toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'short',
+                day: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit'
+            });
+        },
+
+        // Show notification (simple implementation)
+        showNotification: (message, type = 'info') => {
+            const notification = document.createElement('div');
+            notification.className = `fixed top-4 right-4 px-4 py-2 rounded-md shadow-lg z-50 ${
+                type === 'success' ? 'bg-green-500 text-white' :
+                type === 'error' ? 'bg-red-500 text-white' :
+                type === 'warning' ? 'bg-yellow-500 text-white' :
+                'bg-blue-500 text-white'
+            }`;
+            notification.textContent = message;
+            document.body.appendChild(notification);
+            
+            setTimeout(() => {
+                notification.remove();
+            }, 3000);
+        },
+
+        // Copy to clipboard
+        copyToClipboard: async (text) => {
+            try {
+                await navigator.clipboard.writeText(text);
+                PaymentAPI.utils.showNotification('Copied to clipboard!', 'success');
+            } catch (error) {
+                console.error('Failed to copy:', error);
+                PaymentAPI.utils.showNotification('Failed to copy', 'error');
+            }
+        }
+    };
+}
+
+// Create global instance
+window.PaymentAPI = new PaymentAPIClient();
+
+// Export for modules
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = PaymentAPIClient;
+}

django_cfg/apps/payments/static/payments/js/ngrok-status.js

@@ -0,0 +1,58 @@
+/**
+ * Ngrok Status Component
+ * Handles ngrok tunnel status monitoring and control
+ */
+function ngrokStatus() {
+    return {
+        loading: false,
+        status: {
+            active: false,
+            public_url: '',
+            webhook_url: '',
+            error: null,
+            region: 'us',
+            proto: 'https'
+        },
+
+        async init() {
+            await this.refreshStatus();
+            // Auto-refresh every 10 seconds
+            setInterval(() => this.refreshStatus(), 10000);
+        },
+
+        async refreshStatus() {
+            this.loading = true;
+            try {
+                const data = await PaymentAPI.ngrok.status();
+                this.status = { ...this.status, ...data };
+            } catch (error) {
+                console.error('Failed to fetch ngrok status:', error);
+                this.status.active = false;
+                this.status.error = error.message || 'Connection failed';
+            } finally {
+                this.loading = false;
+            }
+        },
+
+
+
+        copyUrl() {
+            if (this.status.public_url) {
+                PaymentAPI.utils.copyToClipboard(this.status.public_url);
+            }
+        },
+
+        copyWebhookUrl() {
+            if (this.status.webhook_url) {
+                PaymentAPI.utils.copyToClipboard(this.status.webhook_url);
+            }
+        },
+
+        openTunnel() {
+            if (this.status.public_url) {
+                window.open(this.status.public_url, '_blank');
+            }
+        },
+
+    };
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Payment Dashboard Component
+ * Handles dashboard data loading and display
+ */
+function paymentDashboard() {
+    return {
+        loading: false,
+        stats: {
+            total: 0,
+            successful: 0,
+            pending: 0,
+            failed: 0
+        },
+        recentPayments: [],
+        recentActivity: [
+            { id: 1, message: 'Payment created', time: '2 minutes ago' },
+            { id: 2, message: 'Webhook received', time: '5 minutes ago' },
+            { id: 3, message: 'Payment completed', time: '10 minutes ago' }
+        ],
+
+        async init() {
+            await this.loadDashboardData();
+            // Auto-refresh every 60 seconds
+            setInterval(() => this.loadDashboardData(), 60000);
+        },
+
+        async loadDashboardData() {
+            this.loading = true;
+            try {
+                // Load dashboard data using API client
+                const [overview, recentPayments] = await Promise.all([
+                    PaymentAPI.dashboard.overview(),
+                    PaymentAPI.dashboard.recentPayments(5)
+                ]);
+
+                this.stats = overview.stats || this.stats;
+                this.recentPayments = recentPayments || [];
+            } catch (error) {
+                console.error('Failed to load dashboard data:', error);
+                PaymentAPI.utils.showNotification('Failed to load dashboard data', 'error');
+            } finally {
+                this.loading = false;
+            }
+        },
+
+        async refreshDashboard() {
+            await this.loadDashboardData();
+        }
+    };
+}