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

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

@@ -1,244 +0,0 @@
-"""
-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

@@ -1,181 +0,0 @@
-"""
-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

@@ -1,266 +0,0 @@
-"""
-Webhook processing views with signature validation.
-"""
-
-import json
-from django_cfg.modules.django_logger import get_logger
-from typing import Dict, Any
-
-from django.http import JsonResponse, HttpResponse
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_http_methods
-from django.utils.decorators import method_decorator
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.permissions import AllowAny
-from rest_framework.response import Response
-from rest_framework import status
-
-from ..services.core.payment_service import PaymentService
-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 = get_logger("webhook_views")
-
-
-@csrf_exempt
-@require_http_methods(["POST"])
-def webhook_handler(request, provider: str):
-    """
-    Main webhook handler with signature validation.
-    
-    Accepts webhooks from payment providers and processes them
-    with proper validation and fallback mechanisms.
-    """
-    try:
-        # Parse webhook data
-        webhook_data = json.loads(request.body.decode('utf-8'))
-        
-        # Extract request headers
-        request_headers = {
-            key: value for key, value in request.META.items()
-            if key.startswith('HTTP_')
-        }
-        
-        # Generate idempotency key for deduplication
-        idempotency_key = _generate_idempotency_key(provider, webhook_data, request_headers)
-        
-        logger.info(f"📥 Received webhook from {provider}, key: {idempotency_key}")
-        
-        # Validate webhook with enhanced security
-        is_valid, validation_error = webhook_validator.validate_webhook(
-            provider=provider,
-            webhook_data=webhook_data,
-            request_headers=request_headers,
-            raw_body=request.body
-        )
-        
-        if not is_valid:
-            security_error = SecurityError(
-                f"Webhook validation failed: {validation_error}",
-                details={'provider': provider, 'validation_error': validation_error}
-            )
-            error_handler.handle_error(security_error, {
-                'provider': provider,
-                'webhook_data_keys': list(webhook_data.keys()),
-                'headers_count': len(request_headers)
-            }, request)
-            
-            return JsonResponse(
-                {'error': 'Webhook validation failed', 'code': 'INVALID_WEBHOOK'}, 
-                status=403
-            )
-        
-        # Process webhook (async with fallback to sync)
-        result = process_webhook_with_fallback(
-            provider=provider,
-            webhook_data=webhook_data,
-            idempotency_key=idempotency_key,
-            request_headers=request_headers
-        )
-        
-        if result.get('success'):
-            logger.info(f"✅ Webhook processed successfully: {idempotency_key}")
-            return JsonResponse({
-                'status': 'success',
-                'idempotency_key': idempotency_key,
-                'processing_mode': result.get('mode', 'unknown')
-            })
-        else:
-            logger.error(f"❌ Webhook processing failed: {result.get('error')}")
-            return JsonResponse({
-                'status': 'error',
-                'error': result.get('error', 'Processing failed'),
-                'idempotency_key': idempotency_key
-            }, status=400)
-            
-    except json.JSONDecodeError as e:
-        validation_error = ValidationError(
-            f"Invalid JSON in webhook from {provider}",
-            details={'provider': provider, 'json_error': str(e)}
-        )
-        error_result = error_handler.handle_error(validation_error, {
-            'provider': provider,
-            'raw_body_length': len(request.body) if request.body else 0
-        }, request)
-        
-        return JsonResponse({
-            'error': 'Invalid JSON',
-            'code': validation_error.error_code
-        }, status=400)
-        
-    except Exception as e:
-        # Handle unexpected errors with centralized error handler
-        error_result = error_handler.handle_error(e, {
-            'provider': provider,
-            'operation': 'webhook_processing',
-            'webhook_data_available': 'webhook_data' in locals()
-        }, request)
-    
-        return JsonResponse({
-            'error': 'Internal server error',
-            'code': error_result.error.error_code
-        }, status=500)
-
-
-@api_view(['POST'])
-@permission_classes([AllowAny])
-def webhook_test(request):
-    """
-    Test webhook endpoint for development.
-    
-    Allows testing webhook processing without requiring
-    actual payment provider signatures.
-    """
-    try:
-        provider = request.data.get('provider', 'test')
-        webhook_data = request.data.get('webhook_data', {})
-        
-        # Add test marker
-        webhook_data['_test_webhook'] = True
-        
-        # Generate test idempotency key
-        import uuid
-        idempotency_key = f"test_{uuid.uuid4().hex[:8]}"
-        
-        logger.info(f"🧪 Processing test webhook: {provider}")
-        
-        # Process with PaymentService directly (sync)
-        payment_service = PaymentService()
-        result = payment_service.process_webhook(
-            provider=provider,
-            webhook_data=webhook_data,
-            request_headers={'HTTP_X_TEST': 'true'}
-        )
-        
-        return Response({
-            'status': 'success',
-            'test_mode': True,
-            'provider': provider,
-            'idempotency_key': idempotency_key,
-            'result': result.dict() if hasattr(result, 'dict') else result
-        })
-        
-    except Exception as e:
-        logger.error(f"❌ Test webhook error: {e}")
-        return Response({
-            'status': 'error',
-            'error': str(e),
-            'test_mode': True
-        }, status=status.HTTP_400_BAD_REQUEST)
-
-
-def _validate_webhook_signature(provider: str, webhook_data: Dict[str, Any], 
-                               request_headers: Dict[str, str]) -> bool:
-    """
-    Validate webhook signature based on provider.
-    
-    Each provider has different signature validation methods.
-    """
-    try:
-        if provider == 'nowpayments':
-            return _validate_nowpayments_signature(webhook_data, request_headers)
-        elif provider == 'cryptapi':
-            return _validate_cryptapi_signature(webhook_data, request_headers)
-        elif provider == 'test':
-            return True  # Allow test webhooks
-        else:
-            logger.warning(f"Unknown provider for signature validation: {provider}")
-            return False
-            
-    except Exception as e:
-        logger.error(f"Signature validation error for {provider}: {e}")
-        return False
-
-
-def _validate_nowpayments_signature(webhook_data: Dict[str, Any], 
-                                  request_headers: Dict[str, str]) -> bool:
-    """Validate NowPayments webhook signature."""
-    import hmac
-    import hashlib
-    from ..utils.config_utils import get_payments_config
-    
-    # Get IPN secret from config
-    config = get_payments_config()
-    if not config or not hasattr(config, 'providers') or 'nowpayments' not in config.providers:
-        logger.warning("NowPayments IPN secret not configured, skipping validation")
-        return True  # Allow if not configured (development mode)
-    
-    nowpayments_config = config.providers['nowpayments']
-    ipn_secret = getattr(nowpayments_config, 'ipn_secret', None)
-    
-    if not ipn_secret:
-        logger.warning("NowPayments IPN secret not configured, skipping validation")
-        return True
-    
-    # Get signature from headers
-    signature = request_headers.get('HTTP_X_NOWPAYMENTS_SIG')
-    if not signature:
-        logger.warning("No NowPayments signature found in headers")
-        return False
-    
-    # Calculate expected signature
-    payload = json.dumps(webhook_data, separators=(',', ':'), sort_keys=True)
-    expected_signature = hmac.new(
-        ipn_secret.encode(),
-        payload.encode(),
-        hashlib.sha512
-    ).hexdigest()
-    
-    return hmac.compare_digest(signature, expected_signature)
-
-
-def _validate_cryptapi_signature(webhook_data: Dict[str, Any], 
-                                request_headers: Dict[str, str]) -> bool:
-    """Validate CryptAPI webhook signature."""
-    # CryptAPI uses different validation method
-    # For now, implement basic validation
-    
-    # Check if required fields are present
-    required_fields = ['address_in', 'address_out', 'txid_in', 'value_coin', 'coin', 'confirmations']
-    for field in required_fields:
-        if field not in webhook_data:
-            logger.warning(f"Missing required field in CryptAPI webhook: {field}")
-            return False
-    
-    return True
-
-
-def _generate_idempotency_key(provider: str, webhook_data: Dict[str, Any], 
-                            request_headers: Dict[str, str]) -> str:
-    """Generate idempotency key for webhook deduplication."""
-    import hashlib
-    
-    # Use provider + payment ID + timestamp for uniqueness
-    payment_id = (
-        webhook_data.get('payment_id') or 
-        webhook_data.get('order_id') or
-        webhook_data.get('id') or
-        'unknown'
-    )
-    
-    timestamp = webhook_data.get('created_at') or webhook_data.get('timestamp')
-    
-    # Create hash from key components
-    key_data = f"{provider}:{payment_id}:{timestamp}"
-    return hashlib.md5(key_data.encode()).hexdigest()[:16]