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

django_cfg/apps/payments/urls_templates.py

@@ -0,0 +1,52 @@
+"""
+Template URLs for Payment Dashboard.
+
+All URLs require superuser access as this is an internal admin tool.
+"""
+
+from django.urls import path
+from .views.templates import (
+    PaymentDashboardView,
+    PaymentDetailView,
+    PaymentCreateView,
+    PaymentStatsView,
+    PaymentListView,
+    PaymentQRCodeView,
+    PaymentTestView,
+    payment_status_ajax,
+    payment_events_ajax,
+)
+from .views.templates.ajax import (
+    payment_stats_ajax,
+    payment_search_ajax,
+    payment_action_ajax,
+)
+from .views.templates.qr_code import qr_code_data_ajax
+
+app_name = 'payments_dashboard'
+
+urlpatterns = [
+    # Main dashboard
+    path('', PaymentDashboardView.as_view(), name='dashboard'),
+    path('dashboard/', PaymentDashboardView.as_view(), name='dashboard_alt'),
+    
+    # Payment management
+    path('list/', PaymentListView.as_view(), name='list'),
+    path('create/', PaymentCreateView.as_view(), name='create'),
+    path('stats/', PaymentStatsView.as_view(), name='stats'),
+    
+    # Payment details
+    path('payment/<uuid:pk>/', PaymentDetailView.as_view(), name='detail'),
+    path('payment/<uuid:pk>/qr/', PaymentQRCodeView.as_view(), name='qr_code'),
+    
+    # AJAX endpoints
+    path('ajax/payment/<uuid:payment_id>/status/', payment_status_ajax, name='payment_status_ajax'),
+    path('ajax/payment/<uuid:payment_id>/events/', payment_events_ajax, name='payment_events_ajax'),
+    path('ajax/payment/<uuid:payment_id>/qr-data/', qr_code_data_ajax, name='qr_data_ajax'),
+    path('ajax/payment/<uuid:payment_id>/action/', payment_action_ajax, name='payment_action_ajax'),
+    path('ajax/stats/', payment_stats_ajax, name='payment_stats_ajax'),
+    path('ajax/search/', payment_search_ajax, name='payment_search_ajax'),
+    
+    # Development/testing
+    path('test/', PaymentTestView.as_view(), name='test'),
+]

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

@@ -0,0 +1,25 @@
+"""
+Template views package for Payment Dashboard.
+
+All views require superuser access as this is an internal admin tool.
+"""
+
+from .dashboard import PaymentDashboardView
+from .payment_detail import PaymentDetailView
+from .payment_management import PaymentCreateView, PaymentListView
+from .stats import PaymentStatsView
+from .qr_code import PaymentQRCodeView
+from .ajax import payment_status_ajax, payment_events_ajax
+from .utils import PaymentTestView
+
+__all__ = [
+    'PaymentDashboardView',
+    'PaymentDetailView', 
+    'PaymentCreateView',
+    'PaymentListView',
+    'PaymentStatsView',
+    'PaymentQRCodeView',
+    'PaymentTestView',
+    'payment_status_ajax',
+    'payment_events_ajax',
+]

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

@@ -0,0 +1,312 @@
+"""
+AJAX endpoints for payment dashboard.
+
+Provides real-time data updates and interactive functionality.
+"""
+
+from django.http import JsonResponse
+from django.shortcuts import get_object_or_404
+from django.utils import timezone
+from .base import superuser_required, get_progress_percentage, log_view_access
+from ...models import UniversalPayment, PaymentEvent
+
+
+@superuser_required
+def payment_status_ajax(request, payment_id):
+    """AJAX endpoint for real-time payment status."""
+    try:
+        payment = get_object_or_404(UniversalPayment, id=payment_id)
+        
+        # Log access for audit
+        log_view_access('payment_status_ajax', request.user, payment_id=payment_id)
+        
+        data = {
+            'id': str(payment.id),
+            'status': payment.status,
+            'status_display': payment.get_status_display(),
+            'progress_percentage': get_progress_percentage(payment.status),
+            'amount_usd': float(payment.amount_usd),
+            'currency_code': payment.currency_code,
+            'provider': payment.provider,
+            'provider_display': payment.provider.title(),
+            'created_at': payment.created_at.isoformat(),
+            'updated_at': payment.updated_at.isoformat(),
+        }
+        
+        # Add completion time if available
+        if payment.completed_at:
+            data['completed_at'] = payment.completed_at.isoformat()
+        
+        # Add crypto-specific data
+        if payment.provider in ['nowpayments', 'cryptapi', 'cryptomus']:
+            data.update({
+                'is_crypto': True,
+                'pay_address': payment.pay_address,
+                'pay_amount': str(payment.pay_amount) if payment.pay_amount else None,
+                'network': getattr(payment, 'network', None),
+                'confirmations': getattr(payment, 'confirmations_count', 0),
+            })
+        else:
+            data['is_crypto'] = False
+        
+        return JsonResponse(data)
+        
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=400)
+
+
+@superuser_required
+def payment_events_ajax(request, payment_id):
+    """AJAX endpoint for payment events."""
+    try:
+        payment = get_object_or_404(UniversalPayment, id=payment_id)
+        
+        # Log access for audit
+        log_view_access('payment_events_ajax', request.user, payment_id=payment_id)
+        
+        events = PaymentEvent.objects.filter(payment=payment).order_by('-created_at')
+        
+        events_data = []
+        for event in events:
+            event_data = {
+                'id': event.id,
+                'event_type': event.event_type,
+                'created_at': event.created_at.isoformat(),
+                'metadata': event.metadata or {},
+            }
+            
+            # Add human-readable description
+            event_data['description'] = _get_event_description(event)
+            
+            events_data.append(event_data)
+        
+        return JsonResponse({
+            'events': events_data,
+            'count': len(events_data)
+        })
+        
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=400)
+
+
+@superuser_required
+def payment_stats_ajax(request):
+    """AJAX endpoint for dashboard statistics."""
+    try:
+        # Log access for audit
+        log_view_access('payment_stats_ajax', request.user)
+        
+        from .base import PaymentStatsMixin
+        
+        # Create instance to use mixin methods
+        stats_mixin = PaymentStatsMixin()
+        
+        # Get basic stats
+        payment_stats = stats_mixin.get_payment_stats()
+        provider_stats = stats_mixin.get_provider_stats()
+        
+        # Get time range stats if requested
+        days = int(request.GET.get('days', 30))
+        time_range_stats = stats_mixin.get_time_range_stats(days)
+        
+        data = {
+            'payment_stats': payment_stats,
+            'provider_stats': list(provider_stats),
+            'time_range_stats': time_range_stats,
+            'last_updated': timezone.now().isoformat(),
+        }
+        
+        return JsonResponse(data)
+        
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)
+
+
+@superuser_required
+def payment_search_ajax(request):
+    """AJAX endpoint for payment search."""
+    try:
+        query = request.GET.get('q', '').strip()
+        if not query:
+            return JsonResponse({'results': []})
+        
+        # Log access for audit
+        log_view_access('payment_search_ajax', request.user, query=query)
+        
+        from django.db.models import Q
+        
+        # Search payments
+        payments = UniversalPayment.objects.filter(
+            Q(internal_payment_id__icontains=query) |
+            Q(provider_payment_id__icontains=query) |
+            Q(user__email__icontains=query) |
+            Q(pay_address__icontains=query)
+        ).order_by('-created_at')[:20]
+        
+        results = []
+        for payment in payments:
+            results.append({
+                'id': str(payment.id),
+                'internal_id': payment.internal_payment_id,
+                'provider_id': payment.provider_payment_id,
+                'amount_usd': float(payment.amount_usd),
+                'currency_code': payment.currency_code,
+                'status': payment.status,
+                'status_display': payment.get_status_display(),
+                'provider': payment.provider,
+                'provider_display': payment.provider.title(),
+                'user_email': payment.user.email,
+                'created_at': payment.created_at.isoformat(),
+                'url': f'/payments/payment/{payment.id}/',
+            })
+        
+        return JsonResponse({
+            'results': results,
+            'count': len(results),
+            'query': query
+        })
+        
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)
+
+
+@superuser_required
+def payment_action_ajax(request, payment_id):
+    """AJAX endpoint for payment actions (cancel, retry, etc.)."""
+    try:
+        if request.method != 'POST':
+            return JsonResponse({'error': 'POST method required'}, status=405)
+        
+        payment = get_object_or_404(UniversalPayment, id=payment_id)
+        action = request.POST.get('action')
+        
+        # Log access for audit
+        log_view_access('payment_action_ajax', request.user, 
+                       payment_id=payment_id, action=action)
+        
+        if action == 'cancel':
+            return _handle_cancel_payment(payment, request.user)
+        elif action == 'retry':
+            return _handle_retry_payment(payment, request.user)
+        elif action == 'refresh':
+            return _handle_refresh_payment(payment, request.user)
+        else:
+            return JsonResponse({'error': 'Invalid action'}, status=400)
+        
+    except Exception as e:
+        return JsonResponse({'error': str(e)}, status=500)
+
+
+def _get_event_description(event):
+    """Get human-readable description for payment event."""
+    descriptions = {
+        'created': 'Payment was created',
+        'pending': 'Payment is pending confirmation',
+        'confirming': 'Payment is being confirmed',
+        'confirmed': 'Payment has been confirmed',
+        'completed': 'Payment was completed successfully',
+        'failed': 'Payment failed',
+        'cancelled': 'Payment was cancelled',
+        'expired': 'Payment expired',
+        'refunded': 'Payment was refunded',
+        'webhook_received': 'Webhook notification received',
+        'status_updated': 'Payment status was updated',
+    }
+    
+    description = descriptions.get(event.event_type, f'Event: {event.event_type}')
+    
+    # Add metadata details if available
+    if event.metadata:
+        if 'reason' in event.metadata:
+            description += f" - {event.metadata['reason']}"
+        if 'amount' in event.metadata:
+            description += f" (Amount: ${event.metadata['amount']})"
+    
+    return description
+
+
+def _handle_cancel_payment(payment, user):
+    """Handle payment cancellation."""
+    if payment.status not in ['pending', 'confirming']:
+        return JsonResponse({
+            'error': 'Payment cannot be cancelled in current status'
+        }, status=400)
+    
+    try:
+        # Update payment status
+        payment.status = 'cancelled'
+        payment.save()
+        
+        # Create event
+        PaymentEvent.objects.create(
+            payment=payment,
+            event_type='cancelled',
+            metadata={'cancelled_by': user.email}
+        )
+        
+        return JsonResponse({
+            'success': True,
+            'message': 'Payment cancelled successfully',
+            'new_status': payment.status
+        })
+        
+    except Exception as e:
+        return JsonResponse({'error': f'Failed to cancel payment: {str(e)}'}, status=500)
+
+
+def _handle_retry_payment(payment, user):
+    """Handle payment retry."""
+    if payment.status not in ['failed', 'expired']:
+        return JsonResponse({
+            'error': 'Payment cannot be retried in current status'
+        }, status=400)
+    
+    try:
+        # Reset payment status
+        payment.status = 'pending'
+        payment.save()
+        
+        # Create event
+        PaymentEvent.objects.create(
+            payment=payment,
+            event_type='retried',
+            metadata={'retried_by': user.email}
+        )
+        
+        return JsonResponse({
+            'success': True,
+            'message': 'Payment retry initiated',
+            'new_status': payment.status
+        })
+        
+    except Exception as e:
+        return JsonResponse({'error': f'Failed to retry payment: {str(e)}'}, status=500)
+
+
+def _handle_refresh_payment(payment, user):
+    """Handle payment status refresh."""
+    try:
+        # Try to refresh payment status from provider
+        from ...services.core.payment_service import PaymentService
+        
+        payment_service = PaymentService()
+        updated_payment = payment_service.refresh_payment_status(payment.id)
+        
+        # Create event
+        PaymentEvent.objects.create(
+            payment=payment,
+            event_type='refreshed',
+            metadata={'refreshed_by': user.email}
+        )
+        
+        return JsonResponse({
+            'success': True,
+            'message': 'Payment status refreshed',
+            'new_status': updated_payment.status
+        })
+        
+    except Exception as e:
+        return JsonResponse({
+            'success': False,
+            'message': f'Failed to refresh payment: {str(e)}'
+        })

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

@@ -0,0 +1,204 @@
+"""
+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
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+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 Decimal to float for JSON serialization
+        if stats['total_volume']:
+            stats['total_volume'] = float(stats['total_volume'])
+        else:
+            stats['total_volume'] = 0.0
+            
+        return stats
+    
+    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
+        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
+        
+        return provider_stats
+    
+    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
+        recent_events = PaymentEvent.objects.select_related('payment').order_by('-created_at')[:10]
+        
+        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