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

django_cfg/apps/payments/views/currency_views.py

@@ -1,122 +0,0 @@
-"""
-Currency ViewSets.
-"""
-
-from rest_framework import viewsets, permissions, generics
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from django_filters.rest_framework import DjangoFilterBackend
-from ..models import Currency, Network, ProviderCurrency
-from ..serializers import (
-    CurrencySerializer, NetworkSerializer, ProviderCurrencySerializer, CurrencyListSerializer
-)
-
-
-class CurrencyViewSet(viewsets.ReadOnlyModelViewSet):
-    """Currency ViewSet: /currencies/"""
-    
-    queryset = Currency.objects.all()
-    serializer_class = CurrencySerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['currency_type']
-    
-    def get_serializer_class(self):
-        """Use list serializer for list action."""
-        if self.action == 'list':
-            return CurrencyListSerializer
-        return CurrencySerializer
-    
-    @action(detail=False, methods=['get'])
-    def crypto(self, request):
-        """Get only cryptocurrencies."""
-        cryptos = self.get_queryset().filter(currency_type='crypto')
-        serializer = CurrencyListSerializer(cryptos, many=True)
-        return Response(serializer.data)
-    
-    @action(detail=False, methods=['get'])
-    def fiat(self, request):
-        """Get only fiat currencies."""
-        fiats = self.get_queryset().filter(currency_type='fiat')
-        serializer = CurrencyListSerializer(fiats, many=True)
-        return Response(serializer.data)
-    
-    @action(detail=True, methods=['get'])
-    def networks(self, request, pk=None):
-        """Get networks for specific currency."""
-        currency = self.get_object()
-        provider_currencies = ProviderCurrency.objects.filter(
-            base_currency=currency,
-            is_enabled=True
-        ).select_related('network').distinct('network')
-        
-        networks = [pc.network for pc in provider_currencies if pc.network]
-        serializer = NetworkSerializer(networks, many=True)
-        return Response(serializer.data)
-
-
-class NetworkViewSet(viewsets.ReadOnlyModelViewSet):
-    """Network ViewSet: /networks/"""
-    
-    queryset = Network.objects.all()
-    serializer_class = NetworkSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['code', 'name']
-
-
-class ProviderCurrencyViewSet(viewsets.ReadOnlyModelViewSet):
-    """Provider Currency ViewSet: /provider-currencies/"""
-    
-    queryset = ProviderCurrency.objects.select_related('base_currency', 'network')
-    serializer_class = ProviderCurrencySerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['provider_name', 'base_currency', 'network', 'is_enabled']
-    
-    @action(detail=False, methods=['get'])
-    def by_currency(self, request):
-        """Get networks grouped by currency."""
-        currency_code = request.query_params.get('currency')
-        if not currency_code:
-            return Response({'error': 'currency parameter required'}, status=400)
-        
-        try:
-            currency = Currency.objects.get(code=currency_code)
-            networks = self.get_queryset().filter(currency=currency)
-            serializer = self.get_serializer(networks, many=True)
-            return Response(serializer.data)
-        except Currency.DoesNotExist:
-            return Response({'error': 'Currency not found'}, status=404)
-
-
-# Generic views for specific use cases
-class SupportedCurrenciesView(generics.ListAPIView):
-    """Generic view to list supported currencies."""
-    
-    serializer_class = CurrencyListSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def get_queryset(self):
-        """Get active currencies."""
-        return Currency.objects.all().order_by('code')
-
-
-class CurrencyRatesView(generics.GenericAPIView):
-    """Generic view to get currency exchange rates."""
-    
-    serializer_class = CurrencySerializer  # For schema generation
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def get(self, request):
-        """Get current exchange rates."""
-        currencies = Currency.objects.all()
-        
-        rates = {}
-        for currency in currencies:
-            rates[currency.code] = {
-                'name': currency.name,
-                'currency_type': currency.currency_type,
-            }
-        
-        return Response(rates)

django_cfg/apps/payments/views/payment_views.py

@@ -1,149 +0,0 @@
-"""
-Payment ViewSets with nested routing.
-"""
-
-from rest_framework import viewsets, permissions, status, generics
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from django_filters.rest_framework import DjangoFilterBackend
-from django.contrib.auth import get_user_model
-from ..models import UniversalPayment
-from ..serializers import (
-    UniversalPaymentSerializer, PaymentCreateSerializer, PaymentListSerializer
-)
-
-User = get_user_model()
-
-
-class UserPaymentViewSet(viewsets.ModelViewSet):
-    """Nested ViewSet for user payments: /users/{user_id}/payments/"""
-    
-    serializer_class = UniversalPaymentSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['status', 'provider', 'currency_code']
-    
-    def get_queryset(self):
-        """Filter by user from URL."""
-        user_id = self.kwargs.get('user_pk')
-        return UniversalPayment.objects.filter(user_id=user_id).order_by('-created_at')
-    
-    def get_serializer_class(self):
-        """Use different serializers for different actions."""
-        if self.action == 'create':
-            return PaymentCreateSerializer
-        elif self.action == 'list':
-            return PaymentListSerializer
-        return UniversalPaymentSerializer
-    
-    def perform_create(self, serializer):
-        """Set user from URL when creating."""
-        user_id = self.kwargs.get('user_pk')
-        user = User.objects.get(id=user_id)
-        serializer.save(user=user)
-    
-    @action(detail=True, methods=['post'])
-    def check_status(self, request, user_pk=None, pk=None):
-        """Check payment status via provider API."""
-        payment = self.get_object()
-        
-        # Import PaymentService to check status with provider
-        from ..services.core.payment_service import PaymentService
-        
-        try:
-            payment_service = PaymentService()
-            status_result = payment_service.get_payment_status(str(payment.id))
-            
-            if status_result.success:
-                # Update local payment status if it changed
-                if payment.status != status_result.status:
-                    payment.status = status_result.status
-                    payment.save(update_fields=['status', 'updated_at'])
-                
-                return Response({
-                    'payment_id': str(payment.id),
-                    'status': status_result.status,
-                    'provider_status': status_result.provider_status,
-                    'updated': payment.status != status_result.status
-                })
-            else:
-                return Response({
-                    'payment_id': str(payment.id),
-                    'status': payment.status,
-                    'error': status_result.error_message,
-                    'provider_check_failed': True
-                }, status=status.HTTP_400_BAD_REQUEST)
-                
-        except Exception as e:
-            # Log error but don't fail completely
-            from django_cfg.modules.django_logger import get_logger
-            logger = get_logger("payment_views")
-            logger.error(f"Payment status check failed for {payment.id}: {e}")
-            
-            return Response({
-                'payment_id': str(payment.id),
-                'status': payment.status,
-                'error': 'Status check temporarily unavailable',
-                'provider_check_failed': True
-            })
-    
-    @action(detail=False, methods=['get'])
-    def summary(self, request, user_pk=None):
-        """Get payment summary for user."""
-        queryset = self.get_queryset()
-        
-        total_payments = queryset.count()
-        total_amount = sum(p.amount_usd for p in queryset if p.status == 'completed')
-        pending_amount = sum(p.amount_usd for p in queryset if p.status == 'pending')
-        
-        return Response({
-            'total_payments': total_payments,
-            'total_amount_usd': total_amount,
-            'pending_amount_usd': pending_amount,
-            'completed_payments': queryset.filter(status='completed').count(),
-            'pending_payments': queryset.filter(status='pending').count(),
-        })
-
-
-class UniversalPaymentViewSet(viewsets.ReadOnlyModelViewSet):
-    """Global payment ViewSet: /payments/"""
-    
-    queryset = UniversalPayment.objects.all()
-    serializer_class = UniversalPaymentSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['status', 'provider', 'currency_code']
-    
-    def get_queryset(self):
-        """Filter by current user for security."""
-        return UniversalPayment.objects.filter(user=self.request.user).order_by('-created_at')
-    
-    def get_serializer_class(self):
-        """Use list serializer for list action."""
-        if self.action == 'list':
-            return PaymentListSerializer
-        return UniversalPaymentSerializer
-
-
-# Generic views for specific use cases
-class PaymentCreateView(generics.CreateAPIView):
-    """Generic view to create payment."""
-    
-    serializer_class = PaymentCreateSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def perform_create(self, serializer):
-        """Set current user when creating."""
-        serializer.save(user=self.request.user)
-
-
-class PaymentStatusView(generics.RetrieveAPIView):
-    """Generic view to check payment status."""
-    
-    serializer_class = UniversalPaymentSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    lookup_field = 'internal_payment_id'
-    
-    def get_queryset(self):
-        """Filter by current user."""
-        return UniversalPayment.objects.filter(user=self.request.user)

django_cfg/apps/payments/views/subscription_views.py

@@ -1,135 +0,0 @@
-"""
-Subscription ViewSets with nested routing.
-"""
-
-from rest_framework import viewsets, permissions, status, generics
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from django_filters.rest_framework import DjangoFilterBackend
-from django.contrib.auth import get_user_model
-from ..models import Subscription, EndpointGroup
-from ..serializers import (
-    SubscriptionSerializer, SubscriptionCreateSerializer, SubscriptionListSerializer,
-    EndpointGroupSerializer
-)
-
-User = get_user_model()
-
-
-class UserSubscriptionViewSet(viewsets.ModelViewSet):
-    """Nested ViewSet for user subscriptions: /users/{user_id}/subscriptions/"""
-    
-    serializer_class = SubscriptionSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['status', 'tier', 'endpoint_group']
-    
-    def get_queryset(self):
-        """Filter by user from URL."""
-        user_id = self.kwargs.get('user_pk')
-        return Subscription.objects.filter(user_id=user_id).order_by('-created_at')
-    
-    def get_serializer_class(self):
-        """Use different serializers for different actions."""
-        if self.action == 'create':
-            return SubscriptionCreateSerializer
-        elif self.action == 'list':
-            return SubscriptionListSerializer
-        return SubscriptionSerializer
-    
-    def perform_create(self, serializer):
-        """Set user from URL when creating."""
-        user_id = self.kwargs.get('user_pk')
-        user = User.objects.get(id=user_id)
-        serializer.save(user=user)
-    
-    @action(detail=True, methods=['post'])
-    def cancel(self, request, user_pk=None, pk=None):
-        """Cancel subscription."""
-        subscription = self.get_object()
-        subscription.status = 'cancelled'
-        subscription.save()
-        
-        serializer = self.get_serializer(subscription)
-        return Response(serializer.data)
-    
-    @action(detail=True, methods=['post'])
-    def renew(self, request, user_pk=None, pk=None):
-        """Renew subscription."""
-        subscription = self.get_object()
-        # TODO: Implement renewal logic
-        return Response({'message': 'Subscription renewed'})
-    
-    @action(detail=False, methods=['get'])
-    def active(self, request, user_pk=None):
-        """Get active subscriptions for user."""
-        queryset = self.get_queryset().filter(status='active')
-        serializer = SubscriptionListSerializer(queryset, many=True)
-        return Response(serializer.data)
-
-
-class SubscriptionViewSet(viewsets.ReadOnlyModelViewSet):
-    """Global subscription ViewSet: /subscriptions/"""
-    
-    queryset = Subscription.objects.all()
-    serializer_class = SubscriptionSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['status', 'tier', 'endpoint_group']
-    
-    def get_queryset(self):
-        """Filter by current user for security."""
-        return Subscription.objects.filter(user=self.request.user).order_by('-created_at')
-    
-    def get_serializer_class(self):
-        """Use list serializer for list action."""
-        if self.action == 'list':
-            return SubscriptionListSerializer
-        return SubscriptionSerializer
-
-
-class EndpointGroupViewSet(viewsets.ReadOnlyModelViewSet):
-    """Endpoint groups ViewSet: /endpoint-groups/"""
-    
-    queryset = EndpointGroup.objects.filter(is_active=True)
-    serializer_class = EndpointGroupSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    @action(detail=True, methods=['get'])
-    def pricing(self, request, pk=None):
-        """Get pricing for endpoint group."""
-        endpoint_group = self.get_object()
-        return Response({
-            'basic_price': endpoint_group.basic_price,
-            'premium_price': endpoint_group.premium_price,
-            'enterprise_price': endpoint_group.enterprise_price,
-            'basic_limit': endpoint_group.basic_limit,
-            'premium_limit': endpoint_group.premium_limit,
-            'enterprise_limit': endpoint_group.enterprise_limit,
-        })
-
-
-# Generic views for specific use cases
-class SubscriptionCreateView(generics.CreateAPIView):
-    """Generic view to create subscription."""
-    
-    serializer_class = SubscriptionCreateSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def perform_create(self, serializer):
-        """Set current user when creating."""
-        serializer.save(user=self.request.user)
-
-
-class ActiveSubscriptionsView(generics.ListAPIView):
-    """Generic view to list active subscriptions."""
-    
-    serializer_class = SubscriptionListSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def get_queryset(self):
-        """Get active subscriptions for current user."""
-        return Subscription.objects.filter(
-            user=self.request.user,
-            status='active'
-        ).order_by('-created_at')

django_cfg/apps/payments/views/tariff_views.py

@@ -1,131 +0,0 @@
-"""
-Tariff ViewSets.
-"""
-
-from rest_framework import viewsets, permissions, generics
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from django_filters.rest_framework import DjangoFilterBackend
-from ..models import Tariff, TariffEndpointGroup
-from ..serializers import (
-    TariffSerializer, TariffEndpointGroupSerializer, TariffListSerializer
-)
-
-
-class TariffViewSet(viewsets.ReadOnlyModelViewSet):
-    """Tariff ViewSet: /tariffs/"""
-    
-    queryset = Tariff.objects.filter(is_active=True)
-    serializer_class = TariffSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['is_active']
-    
-    def get_serializer_class(self):
-        """Use list serializer for list action."""
-        if self.action == 'list':
-            return TariffListSerializer
-        return TariffSerializer
-    
-    def get_queryset(self):
-        """Order by price."""
-        return super().get_queryset().order_by('monthly_price')
-    
-    @action(detail=False, methods=['get'])
-    def free(self, request):
-        """Get free tariffs."""
-        free_tariffs = self.get_queryset().filter(monthly_price=0)
-        serializer = TariffListSerializer(free_tariffs, many=True)
-        return Response(serializer.data)
-    
-    @action(detail=False, methods=['get'])
-    def paid(self, request):
-        """Get paid tariffs."""
-        paid_tariffs = self.get_queryset().filter(monthly_price__gt=0)
-        serializer = TariffListSerializer(paid_tariffs, many=True)
-        return Response(serializer.data)
-    
-    @action(detail=True, methods=['get'])
-    def endpoint_groups(self, request, pk=None):
-        """Get endpoint groups for tariff."""
-        tariff = self.get_object()
-        endpoint_groups = TariffEndpointGroup.objects.filter(
-            tariff=tariff,
-            is_enabled=True
-        )
-        serializer = TariffEndpointGroupSerializer(endpoint_groups, many=True)
-        return Response(serializer.data)
-
-
-class TariffEndpointGroupViewSet(viewsets.ReadOnlyModelViewSet):
-    """Tariff Endpoint Group ViewSet: /tariff-endpoint-groups/"""
-    
-    queryset = TariffEndpointGroup.objects.filter(is_enabled=True)
-    serializer_class = TariffEndpointGroupSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['tariff', 'endpoint_group', 'is_enabled']
-    
-    @action(detail=False, methods=['get'])
-    def by_tariff(self, request):
-        """Get endpoint groups by tariff."""
-        tariff_id = request.query_params.get('tariff_id')
-        if not tariff_id:
-            return Response({'error': 'tariff_id parameter required'}, status=400)
-        
-        groups = self.get_queryset().filter(tariff_id=tariff_id)
-        serializer = self.get_serializer(groups, many=True)
-        return Response(serializer.data)
-    
-    @action(detail=False, methods=['get'])
-    def by_endpoint_group(self, request):
-        """Get tariffs by endpoint group."""
-        endpoint_group_id = request.query_params.get('endpoint_group_id')
-        if not endpoint_group_id:
-            return Response({'error': 'endpoint_group_id parameter required'}, status=400)
-        
-        groups = self.get_queryset().filter(endpoint_group_id=endpoint_group_id)
-        serializer = self.get_serializer(groups, many=True)
-        return Response(serializer.data)
-
-
-# Generic views for specific use cases
-class AvailableTariffsView(generics.ListAPIView):
-    """Generic view to list available tariffs."""
-    
-    serializer_class = TariffListSerializer
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def get_queryset(self):
-        """Get active tariffs ordered by price."""
-        return Tariff.objects.filter(is_active=True).order_by('monthly_price')
-
-
-class TariffComparisonView(generics.GenericAPIView):
-    """Generic view to compare tariffs."""
-    
-    serializer_class = TariffSerializer  # For schema generation
-    permission_classes = [permissions.IsAuthenticated]
-    
-    def get(self, request):
-        """Get tariff comparison data."""
-        tariffs = Tariff.objects.filter(is_active=True).order_by('monthly_price')
-        
-        comparison = []
-        for tariff in tariffs:
-            endpoint_groups_count = TariffEndpointGroup.objects.filter(
-                tariff=tariff, 
-                is_enabled=True
-            ).count()
-            
-            comparison.append({
-                'id': tariff.id,
-                'name': tariff.name,
-                'display_name': tariff.display_name,
-                'monthly_price': tariff.monthly_price,
-                'request_limit': tariff.request_limit,
-                'is_free': tariff.is_free,
-                'endpoint_groups_count': endpoint_groups_count,
-            })
-        
-        return Response(comparison)

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

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