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

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

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

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

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

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