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

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

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

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

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