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

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

@@ -24,10 +24,15 @@ function paymentForm() {
         users: [],
 
         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 +41,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,20 +51,42 @@ 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);
+                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;
+                }
+                
+                const data = await PaymentAPI.currencies.byProvider(this.form.provider);
+                console.log('📊 Provider currencies API response:', data);
                 this.currencies = data.results || data.currencies || [];
                 
                 // Transform provider currency data for display
@@ -76,13 +104,16 @@ function paymentForm() {
                     provider_code: pc.provider_currency_code
                 }));
                 
+                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)) {
+                    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 +121,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: '' }];
             }

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")

django_cfg/apps/payments/tasks/usage_tracking.py

@@ -0,0 +1,308 @@
+"""
+Background tasks for API usage tracking and statistics.
+"""
+import dramatiq
+import logging
+import time
+from typing import Dict, Any, List
+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
+)
+
+logger = logging.getLogger(__name__)
+
+@dramatiq.actor(queue_name="payments")
+def update_api_key_usage_async(
+    api_key_id: str, 
+    ip_address: str = None,
+    increment: int = 1
+) -> UsageUpdateResult:
+    """
+    Update API key usage counters asynchronously.
+    
+    Args:
+        api_key_id: API key UUID to update
+        ip_address: Client IP address for logging
+        increment: Number to increment (default: 1)
+        
+    Returns:
+        Update result with statistics
+    """
+    start_time = time.time()
+    
+    try:
+        with transaction.atomic():
+            # Use F() expressions for atomic updates
+            updated_count = APIKey.objects.filter(id=api_key_id).update(
+                total_requests=F('total_requests') + increment,
+                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(
+                    status='error',
+                    error='API key not found',
+                    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={
+                'api_key_id': api_key_id,
+                'user_id': api_key.user.id,
+                'total_requests': api_key.total_requests,
+                'increment': increment,
+                'ip_address': ip_address,
+                'processing_time_ms': round(processing_time, 2)
+            })
+            
+            return UsageUpdateResult(
+                status='success',
+                resource_id=api_key_id,
+                total_requests=api_key.total_requests,
+                increment=increment,
+                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={
+            'api_key_id': api_key_id,
+            'error': str(e),
+            'ip_address': ip_address
+        })
+        raise  # Re-raise for Dramatiq retry logic
+
+@dramatiq.actor(queue_name="payments")
+def update_subscription_usage_async(
+    subscription_id: str,
+    increment: int = 1
+) -> UsageUpdateResult:
+    """
+    Update subscription usage counters asynchronously.
+    
+    Args:
+        subscription_id: Subscription UUID to update
+        increment: Number to increment (default: 1)
+        
+    Returns:
+        Update result with statistics
+    """
+    start_time = time.time()
+    
+    try:
+        with transaction.atomic():
+            # Use F() expressions for atomic updates
+            updated_count = Subscription.objects.filter(id=subscription_id).update(
+                total_requests=F('total_requests') + increment,
+                last_request_at=timezone.now(),
+                updated_at=timezone.now()
+            )
+            
+            if updated_count == 0:
+                logger.warning(f"Subscription not found: {subscription_id}")
+                return UsageUpdateResult(
+                    status='error',
+                    error='Subscription not found',
+                    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={
+                '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,
+                total_requests=subscription.total_requests,
+                increment=increment,
+                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={
+            'subscription_id': subscription_id,
+            'error': str(e)
+        })
+        raise  # Re-raise for Dramatiq retry logic
+
+@dramatiq.actor(queue_name="payments")
+def batch_update_usage_counters() -> BatchUpdateResult:
+    """
+    Batch update usage counters from cache to reduce database load.
+    
+    This task processes accumulated usage data from Redis cache
+    and performs batch updates to the database.
+    
+    Returns:
+        Batch processing results
+    """
+    start_time = time.time()
+    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={
+            '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,
+            subscriptions_updated=subscriptions_updated,
+            errors=errors,
+            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({
+            'type': 'batch_processing',
+            'error': str(e)
+        })
+        return BatchUpdateResult(
+            status='error',
+            api_keys_updated=api_keys_updated,
+            subscriptions_updated=subscriptions_updated,
+            errors=errors,
+            total_items=api_keys_updated + subscriptions_updated,
+            error=str(e)
+        )
+
+@dramatiq.actor(queue_name="payments")
+def cleanup_stale_usage_cache() -> CleanupResult:
+    """
+    Cleanup stale usage tracking cache entries.
+    
+    Removes old cache entries that might have been left behind
+    due to processing errors or system restarts.
+    
+    Returns:
+        Cleanup results
+    """
+    try:
+        cleanup_count = 0
+        
+        # Cleanup old API key usage cache
+        api_key_keys = cache.keys("api_usage_pending:*")
+        for key in api_key_keys:
+            # Check if cache entry is older than 1 hour
+            ttl = cache.ttl(key)
+            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:
+            ttl = cache.ttl(key)
+            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(
+            status='error',
+            error=str(e),
+            cleaned_entries=0,
+            cleanup_type='stale_usage_cache'
+        )

django_cfg/apps/payments/templates/admin/payments/_components/dashboard_header.html

@@ -0,0 +1,23 @@
+{% comment %}
+Reusable dashboard header component
+
+Usage:
+{% include "admin/payments/_components/dashboard_header.html" with title="Payment Overview" icon="💳" %}
+
+Parameters:
+- title: Dashboard title
+- icon: Emoji or icon to display
+- subtitle: Optional subtitle
+{% endcomment %}
+
+<div class="bg-white border border-base-200 dark:bg-base-900 dark:border-base-700 p-4 rounded-default mb-4">
+    <h3 class="text-lg font-semibold text-font-important-light dark:text-font-important-dark mb-3">
+        {% if icon %}{{ icon }} {% endif %}{{ title }}
+        {% if subtitle %}
+            <span class="text-sm font-normal text-font-subtle-light dark:text-font-subtle-dark">{{ subtitle }}</span>
+        {% endif %}
+    </h3>
+    
+    {% block dashboard_content %}
+    {% endblock %}
+</div>

django_cfg/apps/payments/templates/admin/payments/_components/stats_card.html

@@ -0,0 +1,25 @@
+{% comment %}
+Reusable stats card component for payment admin dashboards
+
+Usage:
+{% include "admin/payments/_components/stats_card.html" with title="Total Users" value="1,234" color="primary" icon="👥" %}
+
+Parameters:
+- title: Card title
+- value: Main value to display
+- color: Color theme (primary, success, warning, error, info)
+- icon: Emoji or icon to display
+- subtitle: Optional subtitle text
+{% endcomment %}
+
+{% load humanize %}
+
+<div class="text-center bg-base-50 dark:bg-base-800 p-3 rounded-default">
+    <p class="text-2xl font-bold text-{{ color|default:'primary' }}-600 dark:text-{{ color|default:'primary' }}-400">
+        {% if icon %}<span class="mr-1">{{ icon }}</span>{% endif %}{{ value|default:0 }}
+    </p>
+    <p class="text-sm text-font-subtle-light dark:text-font-subtle-dark">{{ title }}</p>
+    {% if subtitle %}
+        <p class="text-xs text-gray-500">{{ subtitle }}</p>
+    {% endif %}
+</div>

django_cfg/apps/payments/templates/admin/payments/_components/stats_grid.html

@@ -0,0 +1,16 @@
+{% comment %}
+Reusable stats grid component for payment admin dashboards
+
+Usage:
+{% include "admin/payments/_components/stats_grid.html" with stats=stats_data columns=4 %}
+
+Parameters:
+- stats: List of stat objects with title, value, color, icon properties
+- columns: Number of columns (2, 3, 4, 5)
+{% endcomment %}
+
+<div class="grid grid-cols-{{ columns|default:4 }} gap-4 mb-4">
+    {% for stat in stats %}
+        {% include "admin/payments/_components/stats_card.html" with title=stat.title value=stat.value color=stat.color icon=stat.icon subtitle=stat.subtitle %}
+    {% endfor %}
+</div>

django_cfg/apps/payments/templates/admin/payments/apikey/change_list.html

@@ -0,0 +1,39 @@
+{% extends "admin/change_list.html" %}
+{% load static %}
+
+{% block result_list %}
+    <!-- API Key Statistics Dashboard -->
+    {% include "admin/payments/_components/dashboard_header.html" with title="API Keys Overview" icon="🔑" %}
+    
+    {% if api_key_stats %}
+        {% with stats=api_key_stats %}
+            <div class="grid grid-cols-4 gap-4 mb-4">
+                {% include "admin/payments/_components/stats_card.html" with title="Total Keys" value=stats.total_keys color="primary" %}
+                {% include "admin/payments/_components/stats_card.html" with title="Active" value=stats.active_keys color="success" %}
+                {% include "admin/payments/_components/stats_card.html" with title="Expiring Soon" value=stats.expiring_soon color="warning" %}
+                {% include "admin/payments/_components/stats_card.html" with title="Expired" value=stats.expired_keys color="error" %}
+            </div>
+        {% endwith %}
+    {% endif %}
+        
+        <div class="grid grid-cols-2 gap-4">
+            <div class="bg-base-50 dark:bg-base-800 p-3 rounded-default">
+                <h4 class="font-semibold text-font-important-light dark:text-font-important-dark mb-2">Usage Statistics</h4>
+                <ul class="text-sm space-y-1 text-font-default-light dark:text-font-default-dark">
+                    <li>📊 Total Requests: <span class="font-medium text-primary-600 dark:text-primary-400">{{ stats.total_requests|default:0 }}</span></li>
+                    <li>📈 Recently Used: <span class="font-medium text-success-600 dark:text-success-400">{{ stats.recently_used|default:0 }}</span></li>
+                    <li>🆕 Unused: <span class="font-medium text-warning-600 dark:text-warning-400">{{ stats.unused_keys|default:0 }}</span></li>
+                </ul>
+            </div>
+            <div class="bg-base-50 dark:bg-base-800 p-3 rounded-default">
+                <h4 class="font-semibold text-font-important-light dark:text-font-important-dark mb-2">🔒 Security</h4>
+                <ul class="text-sm space-y-1 text-font-default-light dark:text-font-default-dark">
+                    <li>🔥 Heavy Usage: <span class="font-medium text-purple-600 dark:text-purple-400">{{ stats.heavy_usage_keys|default:0 }}</span></li>
+                    <li>⚠️ Old Unused: <span class="font-medium text-error-600 dark:text-error-400">{{ stats.never_used_old_keys|default:0 }}</span></li>
+                    <li>👥 Top Users: <span class="font-medium text-info-600 dark:text-info-400">{{ stats.top_users|length|default:0 }}</span></li>
+                </ul>
+            </div>
+        </div>
+
+    {{ block.super }}
+{% endblock %}