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

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_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

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

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)