django-cfg 1.2.25__py3-none-any.whl → 1.2.29__py3-none-any.whl

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

@@ -0,0 +1,102 @@
+"""
+Payment detail view.
+
+Provides detailed information about a single payment for superuser access.
+"""
+
+from django.views.generic import DetailView
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    log_view_access
+)
+from ...models import UniversalPayment, PaymentEvent
+
+
+class PaymentDetailView(
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    DetailView
+):
+    """Detailed view for a single payment."""
+    
+    model = UniversalPayment
+    template_name = 'payments/payment_detail.html'
+    context_object_name = 'payment'
+    page_title = 'Payment Details'
+    
+    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': ''},
+        ]
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        payment = self.get_object()
+        
+        # Log access for audit
+        log_view_access('payment_detail', self.request.user, payment_id=payment.id)
+        
+        # Get payment events for this payment
+        events = PaymentEvent.objects.filter(payment=payment).order_by('-created_at')
+        
+        # Get related payments (same user, similar amount range)
+        related_payments = UniversalPayment.objects.filter(
+            user=payment.user,
+            amount_usd__gte=payment.amount_usd * 0.8,
+            amount_usd__lte=payment.amount_usd * 1.2
+        ).exclude(id=payment.id).order_by('-created_at')[:5]
+        
+        # Get provider-specific information
+        provider_info = self._get_provider_info(payment)
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'events': events,
+            'related_payments': related_payments,
+            'provider_info': provider_info,
+            'can_retry': self._can_retry_payment(payment),
+            'can_cancel': self._can_cancel_payment(payment),
+            'can_refund': self._can_refund_payment(payment),
+            **common_context
+        })
+        
+        return context
+    
+    def _get_provider_info(self, payment):
+        """Get provider-specific information for the payment."""
+        info = {
+            'display_name': payment.provider.title(),
+            'is_crypto': payment.provider in ['nowpayments', 'cryptapi', 'cryptomus'],
+            'supports_qr': payment.provider in ['nowpayments', 'cryptapi', 'cryptomus'],
+            'supports_webhook': True,
+        }
+        
+        # Add crypto-specific info
+        if info['is_crypto'] and payment.pay_address:
+            info.update({
+                'crypto_address': payment.pay_address,
+                'crypto_amount': payment.pay_amount,
+                'crypto_currency': payment.currency_code,
+                'network': getattr(payment, 'network', 'mainnet'),
+                'confirmations': getattr(payment, 'confirmations_count', 0),
+            })
+        
+        return info
+    
+    def _can_retry_payment(self, payment):
+        """Check if payment can be retried."""
+        return payment.status in ['failed', 'expired']
+    
+    def _can_cancel_payment(self, payment):
+        """Check if payment can be cancelled."""
+        return payment.status in ['pending', 'confirming']
+    
+    def _can_refund_payment(self, payment):
+        """Check if payment can be refunded."""
+        return payment.status == 'completed'

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

@@ -0,0 +1,164 @@
+"""
+Payment management views.
+
+Provides list, create, and management functionality for payments.
+"""
+
+from django.views.generic import TemplateView, ListView
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentFilterMixin,
+    PaymentContextMixin,
+    log_view_access
+)
+from ...models import UniversalPayment
+
+
+class PaymentCreateView(
+    SuperuserRequiredMixin,
+    PaymentContextMixin,
+    TemplateView
+):
+    """Form view for creating a new payment."""
+    
+    template_name = 'payments/payment_create.html'
+    page_title = 'Create Payment'
+    
+    def get_breadcrumbs(self):
+        return [
+            {'name': 'Dashboard', 'url': '/payments/admin/'},
+            {'name': 'Payments', 'url': '/payments/admin/list/'},
+            {'name': 'Create Payment', 'url': ''},
+        ]
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Log access for audit
+        log_view_access('payment_create', self.request.user)
+        
+        # Get available providers
+        providers = self._get_available_providers()
+        
+        # Get available currencies
+        currencies = self._get_available_currencies()
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'providers': providers,
+            'currencies': currencies,
+            'default_amount': 10.0,  # Default test amount
+            **common_context
+        })
+        
+        return context
+    
+    def _get_available_providers(self):
+        """Get list of available payment providers."""
+        try:
+            from ...services.providers.registry import ProviderRegistry
+            providers = []
+            for provider_name, provider_class in ProviderRegistry.get_all_providers().items():
+                providers.append({
+                    'name': provider_name,
+                    'display_name': provider_name.title(),
+                    'is_crypto': provider_name in ['nowpayments', 'cryptapi', 'cryptomus'],
+                    'description': getattr(provider_class, '__doc__', ''),
+                })
+            return providers
+        except Exception:
+            # Fallback if registry is not available
+            return [
+                {'name': 'nowpayments', 'display_name': 'NowPayments', 'is_crypto': True},
+                {'name': 'cryptapi', 'display_name': 'CryptAPI', 'is_crypto': True},
+                {'name': 'cryptomus', 'display_name': 'Cryptomus', 'is_crypto': True},
+                {'name': 'stripe', 'display_name': 'Stripe', 'is_crypto': False},
+            ]
+    
+    def _get_available_currencies(self):
+        """Get list of available currencies."""
+        from ...models import Currency
+        
+        try:
+            # Get currencies from database
+            currencies = Currency.objects.filter(is_active=True).order_by('code')
+            return [{'code': c.code, 'name': c.name} for c in currencies]
+        except Exception:
+            # Fallback list
+            return [
+                {'code': 'USD', 'name': 'US Dollar'},
+                {'code': 'EUR', 'name': 'Euro'},
+                {'code': 'BTC', 'name': 'Bitcoin'},
+                {'code': 'ETH', 'name': 'Ethereum'},
+                {'code': 'LTC', 'name': 'Litecoin'},
+            ]
+
+
+class PaymentListView(
+    SuperuserRequiredMixin,
+    PaymentFilterMixin,
+    PaymentContextMixin,
+    ListView
+):
+    """Paginated list view for all payments."""
+    
+    model = UniversalPayment
+    template_name = 'payments/payment_list.html'
+    context_object_name = 'payments'
+    paginate_by = 20
+    ordering = ['-created_at']
+    page_title = 'All Payments'
+    
+    def get_breadcrumbs(self):
+        return [
+            {'name': 'Dashboard', 'url': '/payments/admin/'},
+            {'name': 'All Payments', 'url': ''},
+        ]
+    
+    def get_queryset(self):
+        # Log access for audit
+        log_view_access('payment_list', self.request.user)
+        
+        # Use filter mixin to get filtered queryset
+        return self.get_filtered_payments().order_by(*self.ordering)
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Get filter context
+        filter_context = self.get_filter_context()
+        
+        # Get available filter options
+        filter_options = self._get_filter_options()
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'filters': filter_context,
+            'filter_options': filter_options,
+            'total_count': self.get_queryset().count(),
+            **common_context
+        })
+        
+        return context
+    
+    def _get_filter_options(self):
+        """Get available options for filter dropdowns."""
+        from django.db.models import Value
+        from django.db.models.functions import Concat
+        
+        # Get unique statuses
+        statuses = UniversalPayment.objects.values_list('status', flat=True).distinct()
+        status_choices = [(status, status.title()) for status in statuses if status]
+        
+        # Get unique providers
+        providers = UniversalPayment.objects.values_list('provider', flat=True).distinct()
+        provider_choices = [(provider, provider.title()) for provider in providers if provider]
+        
+        return {
+            'statuses': status_choices,
+            'providers': provider_choices,
+        }

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,240 @@
+"""
+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
+        for key in metrics:
+            if metrics[key] > 0:
+                metrics[f"{key}_formatted"] = self._format_duration(metrics[key])
+            else:
+                metrics[f"{key}_formatted"] = "N/A"
+        
+        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"