django-cfg 1.2.27__py3-none-any.whl → 1.2.31__py3-none-any.whl

django_cfg/apps/payments/views/templates/qr_code.py

@@ -0,0 +1,174 @@
+"""
+QR code views for crypto payments.
+
+Provides QR code generation and display for cryptocurrency payments.
+"""
+
+from django.views.generic import DetailView
+from django.http import JsonResponse
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    superuser_required,
+    log_view_access
+)
+from ...models import UniversalPayment
+
+
+class PaymentQRCodeView(
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    DetailView
+):
+    """QR code view for crypto payments."""
+    
+    model = UniversalPayment
+    template_name = 'payments/payment_qr.html'
+    context_object_name = 'payment'
+    page_title = 'Payment QR Code'
+    
+    def get_breadcrumbs(self):
+        payment = self.get_object()
+        return [
+            {'name': 'Dashboard', 'url': '/payments/admin/'},
+            {'name': 'Payments', 'url': '/payments/admin/list/'},
+            {'name': f'Payment #{payment.internal_payment_id or str(payment.id)[:8]}', 
+             'url': f'/payments/admin/payment/{payment.id}/'},
+            {'name': 'QR Code', 'url': ''},
+        ]
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        payment = self.get_object()
+        
+        # Log access for audit
+        log_view_access('payment_qr', self.request.user, payment_id=payment.id)
+        
+        # Check if payment supports QR codes
+        if not self._supports_qr_code(payment):
+            context['error'] = "QR codes are not supported for this payment method"
+            return context
+        
+        # Generate QR code data
+        qr_data = self._generate_qr_data(payment)
+        
+        # Get payment instructions
+        instructions = self._get_payment_instructions(payment)
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'qr_data': qr_data,
+            'qr_size': self.request.GET.get('size', 256),
+            'instructions': instructions,
+            'is_crypto': self._is_crypto_payment(payment),
+            'can_copy': True,
+            **common_context
+        })
+        
+        return context
+    
+    def _supports_qr_code(self, payment):
+        """Check if payment method supports QR codes."""
+        crypto_providers = ['nowpayments', 'cryptapi', 'cryptomus']
+        return payment.provider in crypto_providers and payment.pay_address
+    
+    def _is_crypto_payment(self, payment):
+        """Check if payment is cryptocurrency-based."""
+        crypto_providers = ['nowpayments', 'cryptapi', 'cryptomus']
+        return payment.provider in crypto_providers
+    
+    def _generate_qr_data(self, payment):
+        """Generate QR code data for the payment."""
+        if not payment.pay_address:
+            return None
+        
+        # For crypto payments, use standard format
+        if self._is_crypto_payment(payment):
+            qr_data = payment.pay_address
+            
+            # Add amount if available
+            if payment.pay_amount:
+                # Use appropriate URI scheme based on currency
+                uri_schemes = {
+                    'BTC': 'bitcoin',
+                    'LTC': 'litecoin',
+                    'ETH': 'ethereum',
+                    'BCH': 'bitcoincash',
+                }
+                
+                scheme = uri_schemes.get(payment.currency_code.upper(), 'crypto')
+                qr_data = f"{scheme}:{payment.pay_address}?amount={payment.pay_amount}"
+                
+                # Add label if available
+                if payment.internal_payment_id:
+                    qr_data += f"&label=Payment%20{payment.internal_payment_id}"
+            
+            return qr_data
+        
+        return payment.pay_address
+    
+    def _get_payment_instructions(self, payment):
+        """Get step-by-step payment instructions."""
+        if not self._is_crypto_payment(payment):
+            return []
+        
+        instructions = [
+            "Scan the QR code with your crypto wallet app",
+            f"Send exactly {payment.pay_amount} {payment.currency_code} to the address",
+            "Wait for network confirmations",
+            "Payment will be automatically confirmed"
+        ]
+        
+        # Add provider-specific instructions
+        if payment.provider == 'cryptapi':
+            instructions.append("Minimum 1 confirmation required")
+        elif payment.provider == 'nowpayments':
+            instructions.append("Minimum 2 confirmations required")
+        elif payment.provider == 'cryptomus':
+            instructions.append("Confirmations depend on selected network")
+        
+        return instructions
+
+
+@superuser_required
+def qr_code_data_ajax(request, payment_id):
+    """AJAX endpoint to get QR code data."""
+    try:
+        payment = UniversalPayment.objects.get(id=payment_id)
+        
+        # Log access for audit
+        log_view_access('qr_ajax', request.user, payment_id=payment_id)
+        
+        view = PaymentQRCodeView()
+        
+        # Check if payment supports QR codes
+        if not view._supports_qr_code(payment):
+            return JsonResponse({
+                'error': 'QR codes not supported for this payment method'
+            }, status=400)
+        
+        # Generate QR data
+        qr_data = view._generate_qr_data(payment)
+        
+        if not qr_data:
+            return JsonResponse({
+                'error': 'Unable to generate QR code data'
+            }, status=400)
+        
+        response_data = {
+            'qr_data': qr_data,
+            'payment_address': payment.pay_address,
+            'payment_amount': str(payment.pay_amount) if payment.pay_amount else None,
+            'currency': payment.currency_code,
+            'provider': payment.provider,
+            'instructions': view._get_payment_instructions(payment),
+        }
+        
+        return JsonResponse(response_data)
+        
+    except UniversalPayment.DoesNotExist:
+        return JsonResponse({'error': 'Payment not found'}, status=404)
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)

django_cfg/apps/payments/views/templates/stats.py

@@ -0,0 +1,244 @@
+"""
+Payment statistics and analytics views.
+
+Provides comprehensive analytics for payment performance and trends.
+"""
+
+from django.views.generic import TemplateView
+from django.utils import timezone
+from django.db.models import Q
+from datetime import timedelta
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentStatsMixin,
+    PaymentContextMixin,
+    log_view_access
+)
+
+
+class PaymentStatsView(
+    SuperuserRequiredMixin,
+    PaymentStatsMixin,
+    PaymentContextMixin,
+    TemplateView
+):
+    """Analytics and statistics view."""
+    
+    template_name = 'payments/stats.html'
+    page_title = 'Payment Analytics'
+    
+    def get_breadcrumbs(self):
+        return [
+            {'name': 'Dashboard', 'url': '/payments/admin/'},
+            {'name': 'Analytics', 'url': ''},
+        ]
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Log access for audit
+        log_view_access('payment_stats', self.request.user)
+        
+        # Get time period from request (default to 30 days)
+        days = int(self.request.GET.get('days', 30))
+        
+        # Calculate date ranges
+        now = timezone.now()
+        ranges = self._get_date_ranges(now, days)
+        
+        # Get comprehensive statistics
+        stats = {
+            'overview': self._get_overview_stats(),
+            'time_periods': self._get_time_period_stats(ranges),
+            'providers': self._get_detailed_provider_stats(),
+            'status_distribution': self._get_status_distribution(),
+            'trends': self._get_trend_data(days),
+            'performance': self._get_performance_metrics(),
+        }
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'stats': stats,
+            'selected_days': days,
+            'available_periods': [7, 30, 90, 365],
+            'date_ranges': ranges,
+            **common_context
+        })
+        
+        return context
+    
+    def _get_date_ranges(self, now, days):
+        """Calculate various date ranges for statistics."""
+        return {
+            'current_period_start': now - timedelta(days=days),
+            'current_period_end': now,
+            'previous_period_start': now - timedelta(days=days * 2),
+            'previous_period_end': now - timedelta(days=days),
+            'last_7_days': now - timedelta(days=7),
+            'last_30_days': now - timedelta(days=30),
+            'last_year': now - timedelta(days=365),
+        }
+    
+    def _get_overview_stats(self):
+        """Get overall payment statistics."""
+        return self.get_payment_stats()
+    
+    def _get_time_period_stats(self, ranges):
+        """Get statistics for different time periods."""
+        from ...models import UniversalPayment
+        
+        periods = {}
+        
+        # Current period
+        current_qs = UniversalPayment.objects.filter(
+            created_at__gte=ranges['current_period_start'],
+            created_at__lte=ranges['current_period_end']
+        )
+        periods['current'] = self.get_payment_stats(current_qs)
+        
+        # Previous period for comparison
+        previous_qs = UniversalPayment.objects.filter(
+            created_at__gte=ranges['previous_period_start'],
+            created_at__lte=ranges['previous_period_end']
+        )
+        periods['previous'] = self.get_payment_stats(previous_qs)
+        
+        # Calculate growth rates
+        periods['growth'] = self._calculate_growth_rates(
+            periods['current'], 
+            periods['previous']
+        )
+        
+        # Last 7 days
+        last_7_qs = UniversalPayment.objects.filter(created_at__gte=ranges['last_7_days'])
+        periods['last_7_days'] = self.get_payment_stats(last_7_qs)
+        
+        # Last 30 days
+        last_30_qs = UniversalPayment.objects.filter(created_at__gte=ranges['last_30_days'])
+        periods['last_30_days'] = self.get_payment_stats(last_30_qs)
+        
+        return periods
+    
+    def _get_detailed_provider_stats(self):
+        """Get detailed provider statistics."""
+        provider_stats = self.get_provider_stats()
+        
+        # Add additional metrics for each provider
+        for stat in provider_stats:
+            stat['avg_amount'] = stat['volume'] / stat['count'] if stat['count'] > 0 else 0
+            stat['failure_rate'] = 100 - stat['success_rate']
+            
+        return provider_stats
+    
+    def _get_status_distribution(self):
+        """Get payment status distribution."""
+        from ...models import UniversalPayment
+        from django.db.models import Count
+        
+        distribution = UniversalPayment.objects.values('status').annotate(
+            count=Count('id')
+        ).order_by('-count')
+        
+        total = sum(item['count'] for item in distribution)
+        
+        # Add percentage
+        for item in distribution:
+            item['percentage'] = (item['count'] / total * 100) if total > 0 else 0
+        
+        return distribution
+    
+    def _get_trend_data(self, days):
+        """Get trend data for charts."""
+        from ...models import UniversalPayment
+        from django.db.models import Count, Sum
+        from django.db.models.functions import TruncDate
+        
+        end_date = timezone.now()
+        start_date = end_date - timedelta(days=days)
+        
+        # Daily trends
+        daily_trends = UniversalPayment.objects.filter(
+            created_at__gte=start_date,
+            created_at__lte=end_date
+        ).annotate(
+            date=TruncDate('created_at')
+        ).values('date').annotate(
+            count=Count('id'),
+            volume=Sum('amount_usd'),
+            completed=Count('id', filter=Q(status='completed'))
+        ).order_by('date')
+        
+        # Convert to list and add calculated fields
+        trends = []
+        for item in daily_trends:
+            trends.append({
+                'date': item['date'].isoformat(),
+                'count': item['count'],
+                'volume': float(item['volume'] or 0),
+                'completed': item['completed'],
+                'success_rate': (item['completed'] / item['count'] * 100) if item['count'] > 0 else 0
+            })
+        
+        return trends
+    
+    def _get_performance_metrics(self):
+        """Get performance metrics."""
+        from ...models import UniversalPayment, PaymentEvent
+        from django.db.models import Avg, Min, Max
+        
+        # Average processing time (from created to completed)
+        completed_payments = UniversalPayment.objects.filter(
+            status='completed',
+            completed_at__isnull=False
+        )
+        
+        processing_times = []
+        for payment in completed_payments[:100]:  # Sample for performance
+            if payment.completed_at and payment.created_at:
+                duration = payment.completed_at - payment.created_at
+                processing_times.append(duration.total_seconds())
+        
+        metrics = {
+            'avg_processing_time': sum(processing_times) / len(processing_times) if processing_times else 0,
+            'min_processing_time': min(processing_times) if processing_times else 0,
+            'max_processing_time': max(processing_times) if processing_times else 0,
+        }
+        
+        # Convert seconds to human readable format
+        formatted_metrics = {}
+        for key, value in metrics.items():
+            if value > 0:
+                formatted_metrics[f"{key}_formatted"] = self._format_duration(value)
+            else:
+                formatted_metrics[f"{key}_formatted"] = "N/A"
+        
+        # Add formatted metrics to the original metrics
+        metrics.update(formatted_metrics)
+        
+        return metrics
+    
+    def _calculate_growth_rates(self, current, previous):
+        """Calculate growth rates between two periods."""
+        growth = {}
+        
+        for key in ['total_count', 'total_volume', 'completed_count']:
+            current_val = current.get(key, 0)
+            previous_val = previous.get(key, 0)
+            
+            if previous_val > 0:
+                growth[f"{key}_rate"] = ((current_val - previous_val) / previous_val) * 100
+            else:
+                growth[f"{key}_rate"] = 100 if current_val > 0 else 0
+        
+        return growth
+    
+    def _format_duration(self, seconds):
+        """Format duration in seconds to human readable format."""
+        if seconds < 60:
+            return f"{seconds:.1f}s"
+        elif seconds < 3600:
+            return f"{seconds/60:.1f}m"
+        else:
+            return f"{seconds/3600:.1f}h"

django_cfg/apps/payments/views/templates/utils.py

@@ -0,0 +1,181 @@
+"""
+Utility views for payment dashboard.
+
+Provides testing, debugging, and development functionality.
+"""
+
+from django.views.generic import TemplateView
+from django.utils import timezone
+from datetime import timedelta
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    log_view_access
+)
+
+
+class PaymentTestView(
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    TemplateView
+):
+    """Test view for development and debugging purposes."""
+    
+    template_name = 'payments/test.html'
+    page_title = 'Payment System Test'
+    
+    def get_breadcrumbs(self):
+        return [
+            {'name': 'Dashboard', 'url': '/payments/admin/'},
+            {'name': 'System Test', 'url': ''},
+        ]
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Log access for audit
+        log_view_access('payment_test', self.request.user)
+        
+        # Create sample data for testing templates
+        sample_data = self._generate_sample_data()
+        
+        # Get system information
+        system_info = self._get_system_info()
+        
+        # Get test scenarios
+        test_scenarios = self._get_test_scenarios()
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'sample_data': sample_data,
+            'system_info': system_info,
+            'test_scenarios': test_scenarios,
+            'test_mode': True,
+            **common_context
+        })
+        
+        return context
+    
+    def _generate_sample_data(self):
+        """Generate sample payment data for testing."""
+        sample_payments = []
+        statuses = ['pending', 'confirming', 'completed', 'failed']
+        providers = ['nowpayments', 'cryptapi', 'cryptomus', 'stripe']
+        
+        for i in range(12):
+            sample_payments.append({
+                'id': f'sample-{i}',
+                'internal_payment_id': f'PAY-{1000 + i}',
+                'provider_payment_id': f'PROV-{2000 + i}',
+                'amount_usd': 50.0 + (i * 25),
+                'currency_code': 'USD',
+                'status': statuses[i % len(statuses)],
+                'provider': providers[i % len(providers)],
+                'user_email': f'user{i}@example.com',
+                'created_at': timezone.now() - timedelta(hours=i),
+                'updated_at': timezone.now() - timedelta(minutes=i * 10),
+                'pay_address': f'1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa{i}' if i % 2 == 0 else None,
+                'pay_amount': 0.001 + (i * 0.0001) if i % 2 == 0 else None,
+            })
+        
+        return {
+            'payments': sample_payments,
+            'stats': {
+                'total_count': len(sample_payments),
+                'pending_count': len([p for p in sample_payments if p['status'] == 'pending']),
+                'completed_count': len([p for p in sample_payments if p['status'] == 'completed']),
+                'failed_count': len([p for p in sample_payments if p['status'] == 'failed']),
+                'total_volume': sum(p['amount_usd'] for p in sample_payments),
+            }
+        }
+    
+    def _get_system_info(self):
+        """Get system information for debugging."""
+        import django
+        import sys
+        from django.conf import settings
+        
+        info = {
+            'django_version': django.get_version(),
+            'python_version': sys.version,
+            'debug_mode': settings.DEBUG,
+            'database_engine': settings.DATABASES['default']['ENGINE'],
+            'installed_apps': len(settings.INSTALLED_APPS),
+            'timezone': str(settings.TIME_ZONE),
+            'language': settings.LANGUAGE_CODE,
+        }
+        
+        # Add payment-specific info
+        try:
+            from ...models import UniversalPayment, PaymentEvent
+            info.update({
+                'total_payments': UniversalPayment.objects.count(),
+                'total_events': PaymentEvent.objects.count(),
+                'providers_in_use': list(
+                    UniversalPayment.objects.values_list('provider', flat=True).distinct()
+                ),
+            })
+        except Exception:
+            info.update({
+                'total_payments': 'Unable to query',
+                'total_events': 'Unable to query',
+                'providers_in_use': [],
+            })
+        
+        return info
+    
+    def _get_test_scenarios(self):
+        """Get available test scenarios."""
+        scenarios = [
+            {
+                'name': 'Template Component Test',
+                'description': 'Test all payment template components with sample data',
+                'endpoint': '/payments/test/?test=components',
+                'available': True,
+            },
+            {
+                'name': 'Status Badge Test',
+                'description': 'Test payment status badges for all possible statuses',
+                'endpoint': '/payments/test/?test=status_badges',
+                'available': True,
+            },
+            {
+                'name': 'Progress Bar Test',
+                'description': 'Test payment progress bars with different percentages',
+                'endpoint': '/payments/test/?test=progress_bars',
+                'available': True,
+            },
+            {
+                'name': 'Provider Statistics Test',
+                'description': 'Test provider statistics with sample data',
+                'endpoint': '/payments/test/?test=provider_stats',
+                'available': True,
+            },
+            {
+                'name': 'Real-time Updates Test',
+                'description': 'Test WebSocket connections and real-time updates',
+                'endpoint': '/payments/test/?test=realtime',
+                'available': False,  # Requires WebSocket setup
+            },
+            {
+                'name': 'QR Code Generation Test',
+                'description': 'Test QR code generation for crypto payments',
+                'endpoint': '/payments/test/?test=qr_codes',
+                'available': True,
+            },
+            {
+                'name': 'API Integration Test',
+                'description': 'Test payment provider API integrations',
+                'endpoint': '/payments/test/?test=api_integration',
+                'available': False,  # Requires API keys
+            },
+        ]
+        
+        # Add current test parameter
+        current_test = self.request.GET.get('test', 'overview')
+        for scenario in scenarios:
+            scenario['is_current'] = scenario['endpoint'].endswith(f'test={current_test}')
+        
+        return scenarios

django_cfg/apps/payments/views/webhook_views.py

@@ -3,7 +3,7 @@ Webhook processing views with signature validation.
 """
 
 import json
-import logging
+from django_cfg.modules.django_logger import get_logger
 from typing import Dict, Any
 
 from django.http import JsonResponse, HttpResponse
@@ -20,7 +20,7 @@ from ..tasks.webhook_processing import process_webhook_with_fallback
 from ..services.security.webhook_validator import webhook_validator
 from ..services.security.error_handler import error_handler, SecurityError, ValidationError
 
-logger = logging.getLogger(__name__)
+logger = get_logger("webhook_views")
 
 
 @csrf_exempt

django_cfg/apps/payments/viewsets.py

@@ -19,7 +19,7 @@ from .views import (
     UserAPIKeyViewSet, APIKeyViewSet,
     
     # Currency ViewSets
-    CurrencyViewSet, CurrencyNetworkViewSet,
+    CurrencyViewSet, NetworkViewSet, ProviderCurrencyViewSet,
     
     # Tariff ViewSets
     TariffViewSet, TariffEndpointGroupViewSet,
@@ -49,7 +49,8 @@ class PaymentSystemRouter:
         
         # Currency and pricing
         self.router.register(r'currencies', CurrencyViewSet, basename='currency')
-        self.router.register(r'currency-networks', CurrencyNetworkViewSet, basename='currency-network')
+        self.router.register(r'networks', NetworkViewSet, basename='network')
+        self.router.register(r'provider-currencies', ProviderCurrencyViewSet, basename='provider-currency')
         self.router.register(r'tariffs', TariffViewSet, basename='tariff')
         self.router.register(r'tariff-groups', TariffEndpointGroupViewSet, basename='tariff-group')
     

django_cfg/apps/tasks/urls.py

@@ -18,6 +18,4 @@ urlpatterns = [
     # RESTful API endpoints using ViewSets
     path('api/', include(router.urls)),
     
-    # Dashboard view
-    path('dashboard/', views.dashboard_view, name='dashboard'),
 ]

django_cfg/apps/tasks/urls_admin.py

@@ -0,0 +1,14 @@
+"""
+URLs for Django CFG Tasks app.
+
+Provides RESTful endpoints for task queue management and monitoring using ViewSets and routers.
+"""
+
+from django.urls import path
+from . import views
+
+urlpatterns = [
+
+    # Dashboard view
+    path('dashboard/', views.dashboard_view, name='dashboard'),
+]

django_cfg/apps/urls.py

@@ -46,11 +46,14 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
         
         # Tasks app - enabled when knowbase or agents are enabled
         if base_module.should_enable_tasks():
-            patterns.append(path('tasks/', include('django_cfg.apps.tasks.urls')))
+            patterns.append(path('admin/django_cfg_tasks/admin/', include('django_cfg.apps.tasks.urls_admin')))
         
         # Maintenance app - multi-site maintenance mode with Cloudflare
-        if base_module.is_maintenance_enabled():
-            patterns.append(path('maintenance/', include('django_cfg.apps.maintenance.urls')))
+        # if base_module.is_maintenance_enabled():
+        #     patterns.append(path('admin/django_cfg_maintenance/', include('django_cfg.apps.maintenance.urls_admin')))
+
+        if base_module.is_payments_enabled():
+            patterns.append(path('admin/django_cfg_payments/admin/', include('django_cfg.apps.payments.urls_admin')))
             
     except Exception:
         # Fallback: include all URLs if config is not available