django-cfg 1.2.20__py3-none-any.whl → 1.2.22__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/core/config.py

@@ -97,7 +97,7 @@ class DjangoConfig(BaseModel):
 
     model_config = {
         "validate_assignment": True,
-        "extra": "allow",  # Allow additional fields for extensibility
+        "extra": "forbid",  # Forbid arbitrary fields for type safety
         "env_prefix": "DJANGO_",
         "populate_by_name": True,
         "validate_default": True,
@@ -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")
@@ -232,6 +236,24 @@ class DjangoConfig(BaseModel):
         description="Force SSL redirect on/off (None = auto based on domains and environment)",
     )
 
+    # === CORS Configuration ===
+    cors_allow_headers: List[str] = Field(
+        default_factory=lambda: [
+            "accept",
+            "accept-encoding", 
+            "authorization",
+            "content-type",
+            "dnt",
+            "origin",
+            "user-agent",
+            "x-csrftoken",
+            "x-requested-with",
+            "x-api-key",
+            "x-api-token",
+        ],
+        description="CORS allowed headers with common defaults for API usage",
+    )
+
     # === Services Configuration ===
     email: Optional[EmailConfig] = Field(
         default=None,
@@ -575,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():
@@ -733,6 +757,7 @@ class DjangoConfig(BaseModel):
             return f"{self.site_url.rstrip('/')}/{path}"
         return self.site_url
 
+
     def invalidate_cache(self) -> None:
         """Invalidate cached Django settings to force regeneration."""
         self._django_settings = None

django_cfg/core/generation.py

@@ -242,7 +242,8 @@ class SettingsGenerator:
                     config.security_domains, 
                     config._environment, 
                     config.debug,
-                    config.ssl_redirect
+                    config.ssl_redirect,
+                    config.cors_allow_headers
                 )
                 settings.update(security_defaults)
 

django_cfg/management/commands/check_settings.py

@@ -43,6 +43,7 @@ class Command(BaseCommand):
         if options['verbose']:
             self.show_database_config()
             self.show_app_config()
+            self.show_cors_config()
         
         if options['email_test']:
             self.test_email_connection()
@@ -141,6 +142,59 @@ class Command(BaseCommand):
         if not cfg_apps:
             self.stdout.write("  ❌ No django_cfg apps found")
 
+    def show_cors_config(self):
+        """Show CORS and security configuration."""
+        self.stdout.write(self.style.SUCCESS("\n🌐 CORS & Security Configuration:"))
+        
+        # Get current config
+        try:
+            from django_cfg.core.config import get_current_config
+            config = get_current_config()
+            
+            if config:
+                self.stdout.write(f"  📋 Security Domains: {config.security_domains}")
+                self.stdout.write(f"  🔗 CORS Headers: {config.cors_allow_headers}")
+                self.stdout.write(f"  🔒 SSL Redirect: {config.ssl_redirect}")
+            else:
+                self.stdout.write("  ⚠️  No django-cfg config instance found")
+                
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"  ❌ Error getting config: {e}"))
+        
+        # Show Django settings
+        cors_settings = {
+            'CORS_ALLOW_ALL_ORIGINS': getattr(settings, 'CORS_ALLOW_ALL_ORIGINS', None),
+            'CORS_ALLOWED_ORIGINS': getattr(settings, 'CORS_ALLOWED_ORIGINS', None),
+            'CORS_ALLOW_CREDENTIALS': getattr(settings, 'CORS_ALLOW_CREDENTIALS', None),
+            'CORS_ALLOW_HEADERS': getattr(settings, 'CORS_ALLOW_HEADERS', None),
+            'CSRF_TRUSTED_ORIGINS': getattr(settings, 'CSRF_TRUSTED_ORIGINS', None),
+        }
+        
+        self.stdout.write("\n  🔧 Generated Django Settings:")
+        for key, value in cors_settings.items():
+            if value is not None:
+                icon = "✅"
+                if key == 'CORS_ALLOW_HEADERS' and isinstance(value, list):
+                    # Show first few headers for readability
+                    display_value = value[:3] + ['...'] if len(value) > 3 else value
+                    self.stdout.write(f"  {icon} {key}: {display_value} ({len(value)} total)")
+                elif key in ['CORS_ALLOWED_ORIGINS', 'CSRF_TRUSTED_ORIGINS'] and isinstance(value, list):
+                    self.stdout.write(f"  {icon} {key}: {value}")
+                else:
+                    self.stdout.write(f"  {icon} {key}: {value}")
+            else:
+                self.stdout.write(f"  ⭕ {key}: Not set")
+        
+        # Analysis
+        self.stdout.write("\n  📊 CORS Analysis:")
+        if cors_settings['CORS_ALLOW_ALL_ORIGINS']:
+            self.stdout.write("  🟡 Development mode: All origins allowed")
+        elif cors_settings['CORS_ALLOWED_ORIGINS']:
+            origins_count = len(cors_settings['CORS_ALLOWED_ORIGINS'])
+            self.stdout.write(f"  🟢 Production mode: {origins_count} specific origins allowed")
+        else:
+            self.stdout.write("  🔴 No CORS origins configured")
+
     def test_email_connection(self):
         """Test email connection."""
         self.stdout.write(self.style.SUCCESS("\n🧪 Testing Email Connection:"))

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.enable_payments()
             
             # 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 enable_payments(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__ = [