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

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

@@ -1,451 +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, Currency, Network, ProviderCurrency
-from ...services.providers.registry import get_provider_registry
-from ...services.internal_types import ProviderCurrencyOptionsResponse, CurrencyOptionModel
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger("ajax_views")
-
-
-@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_id=payment.id).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)}'
-        })
-
-
-@superuser_required
-def provider_currencies_ajax(request):
-    """AJAX endpoint for getting supported currencies by provider using new ProviderCurrency model."""
-    try:
-        provider_name = request.GET.get('provider')
-        if not provider_name:
-            return JsonResponse({'error': 'Provider parameter required'}, status=400)
-
-        # Log access for audit
-        log_view_access('provider_currencies_ajax', request.user, provider=provider_name)
-
-        # Get flat currency options using manager method
-        try:
-            currency_options_dicts = ProviderCurrency.objects.get_currency_options_for_provider(provider_name)
-            
-            # Convert dicts to Pydantic models for validation
-            currency_options = [CurrencyOptionModel(**option) for option in currency_options_dicts]
-            
-            # Create typed response
-            response_data = ProviderCurrencyOptionsResponse(
-                success=True,
-                provider=provider_name,
-                currency_options=currency_options,
-                count=len(currency_options)
-            )
-
-            return JsonResponse(response_data.model_dump())
-
-        except Exception as e:
-            logger.error(f"Error getting currencies for {provider_name}: {e}")
-            
-            # Create typed error response
-            error_response = ProviderCurrencyOptionsResponse(
-                success=False,
-                provider=provider_name,
-                currency_options=[],
-                count=0,
-                error=f'Failed to get currencies for {provider_name}: {str(e)}'
-            )
-            return JsonResponse(error_response.model_dump())
-
-    except Exception as e:
-        logger.error(f"Provider currencies AJAX error: {e}")
-        return JsonResponse({'error': str(e)}, status=500)
-
-
-# currency_networks_ajax removed - networks now included in provider_currencies_ajax
-
-
-@superuser_required
-def all_providers_data_ajax(request):
-    """AJAX endpoint for getting all providers with their currencies and capabilities."""
-    try:
-        # Log access for audit
-        log_view_access('all_providers_data_ajax', request.user)
-
-        # Get provider registry
-        registry = get_provider_registry()
-        all_providers = registry.list_providers()
-
-        providers_data = {}
-        
-        for provider_name in all_providers:
-            try:
-                provider_instance = registry.get_provider(provider_name)
-                
-                if provider_instance:
-                    # Get provider info
-                    provider_info = {
-                        'name': provider_name,
-                        'display_name': provider_name.title(),
-                        'enabled': provider_instance.enabled,
-                        'is_crypto': provider_name in ['nowpayments', 'cryptapi', 'cryptomus'],
-                        'supports_webhooks': hasattr(provider_instance, 'validate_webhook'),
-                        'currencies': [],
-                        'default_currency': None
-                    }
-
-                    # Get supported currencies from ProviderCurrency model
-                    try:
-                        provider_currencies = ProviderCurrency.objects.enabled_for_provider(provider_name).select_related(
-                            'base_currency'
-                        ).distinct('base_currency')[:10]  # Limit to first 10 for performance
-                        
-                        for pc in provider_currencies:
-                            provider_info['currencies'].append({
-                                'code': pc.base_currency.code,
-                                'name': pc.base_currency.name,
-                                'type': pc.base_currency.currency_type
-                            })
-                        
-                        # Set default currency
-                        if provider_info['currencies']:
-                            defaults = {
-                                'cryptapi': 'BTC',
-                                'cryptomus': 'USDT',
-                                'nowpayments': 'BTC',
-                                'stripe': 'USD'
-                            }
-                            default_code = defaults.get(provider_name)
-                            if default_code and any(c['code'] == default_code for c in provider_info['currencies']):
-                                provider_info['default_currency'] = default_code
-                            else:
-                                provider_info['default_currency'] = provider_info['currencies'][0]['code']
-
-                    except Exception as e:
-                        provider_info['error'] = f'Failed to load currencies: {str(e)}'
-
-                    providers_data[provider_name] = provider_info
-
-                else:
-                    providers_data[provider_name] = {
-                        'name': provider_name,
-                        'enabled': False,
-                        'error': 'Provider instance not available'
-                    }
-
-            except Exception as e:
-                providers_data[provider_name] = {
-                    'name': provider_name,
-                    'enabled': False,
-                    'error': str(e)
-                }
-
-        return JsonResponse({
-            'success': True,
-            'providers': providers_data,
-            'count': len(providers_data)
-        })
-
-    except Exception as e:
-        return JsonResponse({'error': str(e)}, status=500)

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

@@ -1,212 +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
-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}"
-    )