django-cfg 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

django_cfg/apps/payments/views/currency_views.py

@@ -0,0 +1,111 @@
+"""
+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, CurrencyNetwork
+from ..serializers import (
+    CurrencySerializer, CurrencyNetworkSerializer, CurrencyListSerializer
+)
+
+
+class CurrencyViewSet(viewsets.ReadOnlyModelViewSet):
+    """Currency ViewSet: /currencies/"""
+    
+    queryset = Currency.objects.filter(is_active=True)
+    serializer_class = CurrencySerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['currency_type', 'is_active']
+    
+    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()
+        networks = CurrencyNetwork.objects.filter(
+            currency=currency, 
+            is_active=True
+        )
+        serializer = CurrencyNetworkSerializer(networks, many=True)
+        return Response(serializer.data)
+
+
+class CurrencyNetworkViewSet(viewsets.ReadOnlyModelViewSet):
+    """Currency Network ViewSet: /currency-networks/"""
+    
+    queryset = CurrencyNetwork.objects.filter(is_active=True)
+    serializer_class = CurrencyNetworkSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [DjangoFilterBackend]
+    filterset_fields = ['currency', 'network_code', 'is_active']
+    
+    @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, is_active=True)
+            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.filter(is_active=True).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.filter(is_active=True)
+        
+        rates = {}
+        for currency in currencies:
+            rates[currency.code] = {
+                'usd_rate': currency.usd_rate,
+                'updated_at': currency.rate_updated_at,
+                'type': currency.currency_type,
+            }
+        
+        return Response(rates)

django_cfg/apps/payments/views/payment_views.py

@@ -0,0 +1,111 @@
+"""
+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()
+        # TODO: Implement provider status check
+        return Response({'status': payment.status})
+    
+    @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

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

@@ -0,0 +1,131 @@
+"""
+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/support/signals.py

@@ -2,6 +2,8 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 import traceback
 import logging
+import socket
+from smtplib import SMTPException
 
 from .models import Message, Ticket
 from .utils.support_email_service import SupportEmailService
@@ -10,7 +12,7 @@ from django_cfg.modules.django_telegram import DjangoTelegram
 logger = logging.getLogger(__name__)
 
 @receiver(post_save, sender=Message)
-def notify_on_message(sender, instance, created, **kwargs):
+def notify_on_message(sender, instance: Message, created: bool, **kwargs):
     """Send notifications when a new message is created."""
     logger.info(f"🔔 Signal triggered: Message {instance.uuid} created={created}")
     
@@ -32,9 +34,14 @@ def notify_on_message(sender, instance, created, **kwargs):
             email_service = SupportEmailService(user)
             email_service.send_support_reply_email(instance)
             logger.info(f"   📬 Email sent successfully!")
+        except (socket.timeout, TimeoutError, SMTPException) as e:
+            logger.warning(f"   ⚠️ Email service timeout/error: {e}")
+            logger.info(f"   📝 Message processed successfully, email notification failed")
+            # Do not re-raise to prevent blocking the main process
         except Exception as e:
             logger.error(f"   ❌ Failed to send email notification: {e}")
-            traceback.print_exc()
+            logger.debug(f"   🔍 Exception details: {traceback.format_exc()}")
+            # Do not re-raise to prevent blocking the main process
     else:
         logger.info(f"   ⏭️ Not sending email (staff: {instance.sender.is_staff}, from_author: {instance.is_from_author})")
 
@@ -60,7 +67,7 @@ def notify_on_message(sender, instance, created, **kwargs):
 
 
 @receiver(post_save, sender=Ticket)
-def notify_on_ticket_created(sender, instance, created, **kwargs):
+def notify_on_ticket_created(sender, instance: Ticket, created: bool, **kwargs):
     """Send notification when a new ticket is created."""
     if not created:
         return
@@ -68,5 +75,10 @@ def notify_on_ticket_created(sender, instance, created, **kwargs):
     try:
         email_service = SupportEmailService(instance.user)
         email_service.send_ticket_created_email(instance)
+        logger.info(f"   📬 Ticket creation email sent successfully!")
+    except (socket.timeout, TimeoutError, SMTPException) as e:
+        logger.warning(f"   ⚠️ Email service timeout/error for ticket creation: {e}")
+        logger.info(f"   📝 Ticket created successfully, email notification failed")
     except Exception as e:
-        logger.error(f"Failed to send ticket creation email: {e}")
+        logger.error(f"   ❌ Failed to send ticket creation email: {e}")
+        logger.debug(f"   🔍 Exception details: {traceback.format_exc()}")

django_cfg/apps/support/templates/support/chat/ticket_chat.html

@@ -197,7 +197,7 @@
             submitBtn.disabled = true;
 
             try {
-                const response = await fetch(`{% url 'send-message-ajax' ticket_uuid=ticket.uuid %}`, {
+                const response = await fetch(`{% url 'cfg_support:send-message-ajax' ticket_uuid=ticket.uuid %}`, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',

django_cfg/core/config.py

@@ -158,6 +158,10 @@ class DjangoConfig(BaseModel):
         default=False,
         description="Enable django-cfg Maintenance application (multi-site maintenance mode with Cloudflare)",
     )
+    enable_payments: bool = Field(
+        default=False,
+        description="Enable django-cfg Payments application (universal payment system, subscriptions, API keys, billing)",
+    )
 
     # === URLs ===
     site_url: str = Field(default="http://localhost:3000", description="Frontend site URL")
@@ -593,6 +597,8 @@ class DjangoConfig(BaseModel):
             apps.append("django_cfg.apps.agents")
         if self.enable_maintenance:
             apps.append("django_cfg.apps.maintenance")
+        if self.enable_payments:
+            apps.append("django_cfg.apps.payments")
         
         # Auto-enable tasks if needed
         if self.should_enable_tasks():

django_cfg/models/revolution.py

@@ -93,6 +93,7 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
             knowbase_enabled = base_module.is_knowbase_enabled()
             agents_enabled = base_module.is_agents_enabled()
             tasks_enabled = base_module.should_enable_tasks()
+            payments_enabled = base_module.is_payments_enabled()
             
             # Add Support zone if enabled
             default_support_zone = 'cfg_support'
@@ -177,6 +178,19 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
                     auth_required=True,
                     version="v1",
                 )
+
+            # Add Payments zone if enabled
+            default_payments_zone = 'cfg_payments'
+            if payments_enabled and default_payments_zone not in zones:
+                zones[default_payments_zone] = ZoneConfig(
+                    apps=["django_cfg.apps.payments"],
+                    title="Payments API",
+                    description="Payments, subscriptions, and billing API",
+                    public=False,
+                    auth_required=True,
+                    version="v1",
+                )
+
         except Exception:
             pass
             

django_cfg/modules/base.py

@@ -175,6 +175,15 @@ class BaseCfgModule(ABC):
         """
         return self._get_config_key('enable_maintenance', False)
 
+    def is_payments_enabled(self) -> bool:
+        """
+        Check if django-cfg Payments is enabled.
+        
+        Returns:
+            True if Payments is enabled, False otherwise
+        """
+        return self._get_config_key('enable_payments', False)
+
 
 # Export the base class
 __all__ = [