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

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

@@ -0,0 +1,212 @@
+"""
+Base mixins and decorators for payment template views.
+
+Provides security and common functionality for all payment dashboard views.
+"""
+
+from django.contrib.auth.decorators import user_passes_test
+from django.utils.decorators import method_decorator
+from django.db.models import Q, Count, Sum
+from django.utils import timezone
+from datetime import timedelta
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("view_base")
+
+
+def superuser_required(function=None):
+    """Decorator that checks if user is superuser."""
+    actual_decorator = user_passes_test(
+        lambda u: u.is_authenticated and u.is_superuser,
+        login_url='/admin/login/'
+    )
+    if function:
+        return actual_decorator(function)
+    return actual_decorator
+
+
+class SuperuserRequiredMixin:
+    """Mixin that requires superuser access for all views."""
+    
+    @method_decorator(superuser_required)
+    def dispatch(self, request, *args, **kwargs):
+        return super().dispatch(request, *args, **kwargs)
+
+
+class PaymentFilterMixin:
+    """Mixin that provides common payment filtering functionality."""
+    
+    def get_filtered_payments(self, request=None):
+        """Get payments with common filters applied."""
+        if request is None:
+            request = self.request
+            
+        from ...models import UniversalPayment
+        
+        # Base queryset
+        payments_qs = UniversalPayment.objects.select_related('user')
+        
+        # Apply filters from GET parameters
+        status_filter = request.GET.get('status', '')
+        provider_filter = request.GET.get('provider', '')
+        search_query = request.GET.get('search', '')
+        date_filter = request.GET.get('date', '')
+        
+        if status_filter:
+            payments_qs = payments_qs.filter(status=status_filter)
+        if provider_filter:
+            payments_qs = payments_qs.filter(provider=provider_filter)
+        if search_query:
+            payments_qs = payments_qs.filter(
+                Q(internal_payment_id__icontains=search_query) |
+                Q(provider_payment_id__icontains=search_query) |
+                Q(amount_usd__icontains=search_query) |
+                Q(user__email__icontains=search_query)
+            )
+        if date_filter:
+            try:
+                filter_date = timezone.datetime.strptime(date_filter, '%Y-%m-%d').date()
+                payments_qs = payments_qs.filter(created_at__date=filter_date)
+            except ValueError:
+                pass  # Invalid date format, ignore filter
+        
+        return payments_qs
+    
+    def get_filter_context(self, request=None):
+        """Get filter values for template context."""
+        if request is None:
+            request = self.request
+            
+        return {
+            'status': request.GET.get('status', ''),
+            'provider': request.GET.get('provider', ''),
+            'search': request.GET.get('search', ''),
+            'date': request.GET.get('date', ''),
+        }
+
+
+class PaymentStatsMixin:
+    """Mixin that provides payment statistics functionality."""
+    
+    def get_payment_stats(self, queryset=None):
+        """Get payment statistics from queryset or all payments."""
+        if queryset is None:
+            from ...models import UniversalPayment
+            queryset = UniversalPayment.objects.all()
+        
+        stats = queryset.aggregate(
+            total_count=Count('id'),
+            pending_count=Count('id', filter=Q(status='pending')),
+            confirming_count=Count('id', filter=Q(status='confirming')),
+            completed_count=Count('id', filter=Q(status='completed')),
+            failed_count=Count('id', filter=Q(status='failed')),
+            total_volume=Sum('amount_usd')
+        )
+        
+        # Convert to template format
+        return {
+            'total_payments_count': stats['total_count'] or 0,
+            'pending_payments_count': stats['pending_count'] or 0,
+            'confirming_payments_count': stats['confirming_count'] or 0,
+            'completed_payments_count': stats['completed_count'] or 0,
+            'failed_payments_count': stats['failed_count'] or 0,
+            'total_volume': float(stats['total_volume'] or 0),
+        }
+    
+    def get_provider_stats(self, queryset=None):
+        """Get provider-specific statistics."""
+        if queryset is None:
+            from ...models import UniversalPayment
+            queryset = UniversalPayment.objects.all()
+        
+        provider_stats = queryset.values('provider').annotate(
+            count=Count('id'),
+            volume=Sum('amount_usd'),
+            completed_count=Count('id', filter=Q(status='completed')),
+        ).order_by('-volume')
+        
+        # Calculate success rate and convert to list of dicts
+        stats_list = []
+        for stat in provider_stats:
+            if stat['count'] > 0:
+                stat['success_rate'] = (stat['completed_count'] / stat['count']) * 100
+            else:
+                stat['success_rate'] = 0
+            
+            # Convert Decimal to float
+            if stat['volume']:
+                stat['volume'] = float(stat['volume'])
+            else:
+                stat['volume'] = 0.0
+                
+            stats_list.append(stat)
+        
+        return stats_list
+    
+    def get_time_range_stats(self, days=30):
+        """Get statistics for a specific time range."""
+        from ...models import UniversalPayment
+        
+        end_date = timezone.now()
+        start_date = end_date - timedelta(days=days)
+        
+        queryset = UniversalPayment.objects.filter(
+            created_at__gte=start_date,
+            created_at__lte=end_date
+        )
+        
+        return self.get_payment_stats(queryset)
+
+
+class PaymentContextMixin:
+    """Mixin that provides common context data for payment views."""
+    
+    def get_common_context(self):
+        """Get common context data used across multiple views."""
+        from ...models import PaymentEvent
+        
+        # Get recent events for activity feed (if any exist)
+        try:
+            recent_events = PaymentEvent.objects.order_by('-created_at')[:10]
+        except Exception:
+            recent_events = []
+        
+        return {
+            'recent_events': recent_events,
+            'page_title': self.get_page_title(),
+            'breadcrumbs': self.get_breadcrumbs(),
+        }
+    
+    def get_page_title(self):
+        """Get page title for the view."""
+        return getattr(self, 'page_title', 'Payment Dashboard')
+    
+    def get_breadcrumbs(self):
+        """Get breadcrumb navigation for the view."""
+        return getattr(self, 'breadcrumbs', [
+            {'name': 'Payment Dashboard', 'url': '/payments/admin/'},
+        ])
+
+
+def get_progress_percentage(status):
+    """Helper function to calculate progress percentage."""
+    progress_map = {
+        'pending': 10,
+        'confirming': 40,
+        'confirmed': 70,
+        'completed': 100,
+        'failed': 0,
+        'expired': 0,
+        'cancelled': 0,
+        'refunded': 50,
+    }
+    return progress_map.get(status, 0)
+
+
+def log_view_access(view_name, user, **kwargs):
+    """Log access to payment views for audit purposes."""
+    extra_info = ', '.join([f"{k}={v}" for k, v in kwargs.items()])
+    logger.info(
+        f"Payment dashboard access: {view_name} by {user.email} "
+        f"(superuser={user.is_superuser}) {extra_info}"
+    )

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

@@ -0,0 +1,60 @@
+"""
+Main payment dashboard view.
+
+Provides overview, statistics, and recent payments for superuser access.
+"""
+
+from django.views.generic import TemplateView
+from .base import (
+    SuperuserRequiredMixin, 
+    PaymentFilterMixin, 
+    PaymentStatsMixin, 
+    PaymentContextMixin,
+    log_view_access
+)
+
+
+class PaymentDashboardView(
+    SuperuserRequiredMixin,
+    PaymentFilterMixin,
+    PaymentStatsMixin,
+    PaymentContextMixin,
+    TemplateView
+):
+    """Main payment dashboard with overview and recent payments."""
+    
+    template_name = 'payments/dashboard.html'
+    page_title = 'Payment Dashboard'
+    
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        
+        # Log access for audit
+        log_view_access('dashboard', self.request.user)
+        
+        # Get filtered payments
+        payments_qs = self.get_filtered_payments()
+        
+        # Get recent payments (limit to 20 for performance)
+        recent_payments = payments_qs.order_by('-created_at')[:20]
+        
+        # Check if there are more payments for pagination
+        has_more = payments_qs.count() > 20
+        
+        # Get statistics
+        payment_stats = self.get_payment_stats()
+        provider_stats = self.get_provider_stats()
+        
+        # Get common context
+        common_context = self.get_common_context()
+        
+        context.update({
+            'payments': recent_payments,
+            'has_more_payments': has_more,
+            'payment_stats': payment_stats,
+            'provider_stats': provider_stats,
+            'filters': self.get_filter_context(),
+            **common_context
+        })
+        
+        return context

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_id=payment.id).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,158 @@
+"""
+Payment management views.
+
+Provides list, create, and management functionality for payments.
+"""
+
+import json
+from django.views.generic import TemplateView, ListView
+from .base import (
+    SuperuserRequiredMixin,
+    PaymentFilterMixin,
+    PaymentContextMixin,
+    log_view_access
+)
+from ...models import UniversalPayment, Currency, PaymentProvider
+from ...services.providers.registry import ProviderRegistry
+
+
+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()
+        
+        # Provider enum with defaults (serialize to JSON for JavaScript)
+        provider_defaults = {
+            PaymentProvider.NOWPAYMENTS.value: 'USDTTRC20',
+            PaymentProvider.CRYPTAPI.value: 'BTC', 
+            PaymentProvider.CRYPTOMUS.value: 'USDTTRC20',
+            PaymentProvider.STRIPE.value: 'USD'
+        }
+        provider_defaults_json = json.dumps(provider_defaults)
+        
+        context.update({
+            'providers': providers,
+            'currencies': currencies,
+            'provider_enum': PaymentProvider,
+            'provider_defaults_json': provider_defaults_json,
+            'default_amount': 10.0,  # Default test amount
+            **common_context
+        })
+        
+        return context
+    
+    def _get_available_providers(self):
+        """Get list of available payment providers from registry."""
+        registry = ProviderRegistry()
+        provider_names = registry.list_providers()
+        
+        providers = []
+        for provider_name in provider_names:
+            provider_instance = registry.get_provider(provider_name)
+            providers.append({
+                'name': provider_name,
+                'display_name': provider_name.title(),
+                'is_crypto': provider_name in ['nowpayments', 'cryptapi', 'cryptomus'],
+                'description': getattr(provider_instance.__class__, '__doc__', '') if provider_instance else '',
+            })
+        return providers
+    
+    def _get_available_currencies(self):
+        """Get list of available currencies from database."""
+        # Get all active currencies - both fiat and crypto
+        return Currency.objects.all().order_by('currency_type', 'code')
+    
+    
+
+
+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."""
+
+        # 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,
+        }