django-cfg 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

django_cfg/apps/payments/views/overview/views.py

@@ -0,0 +1,231 @@
+"""
+💰 Payments Overview Dashboard Views
+
+API views for payments dashboard data using existing models.
+"""
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+from drf_spectacular.utils import extend_schema, extend_schema_view
+from drf_spectacular.openapi import OpenApiParameter
+
+from .services import (
+    PaymentsDashboardMetricsService,
+    PaymentsUsageChartService,
+    RecentPaymentsService,
+    PaymentsAnalyticsService,
+)
+from .serializers import (
+    PaymentsDashboardOverviewSerializer,
+    PaymentsMetricsSerializer,
+    PaymentsChartResponseSerializer,
+    TimePeriodSerializer,
+    RecentPaymentSerializer,
+    RecentTransactionSerializer,
+    BalanceOverviewSerializer,
+    SubscriptionOverviewSerializer,
+    APIKeysOverviewSerializer,
+)
+
+
+@extend_schema_view(
+    overview=extend_schema(
+        summary="Payments Dashboard Overview",
+        description="Get complete payments dashboard overview with metrics, recent payments, and analytics",
+        responses={200: PaymentsDashboardOverviewSerializer}
+    ),
+    metrics=extend_schema(
+        summary="Payments Dashboard Metrics",
+        description="Get payments dashboard metrics including balance, subscriptions, API keys, and payments",
+        responses={200: PaymentsMetricsSerializer}
+    ),
+    chart_data=extend_schema(
+        summary="Payments Chart Data",
+        description="Get chart data for payments visualization",
+        parameters=[
+            OpenApiParameter(
+                name='period',
+                description='Time period for chart data',
+                required=False,
+                type=str,
+                enum=['7d', '30d', '90d', '1y'],
+                default='30d'
+            )
+        ],
+        responses={200: PaymentsChartResponseSerializer}
+    ),
+    recent_payments=extend_schema(
+        summary="Recent Payments",
+        description="Get recent payments for the user",
+        parameters=[
+            OpenApiParameter(
+                name='limit',
+                description='Number of payments to return',
+                required=False,
+                type=int,
+                default=10
+            )
+        ],
+        responses={200: RecentPaymentSerializer(many=True)}
+    ),
+    recent_transactions=extend_schema(
+        summary="Recent Transactions",
+        description="Get recent balance transactions for the user",
+        parameters=[
+            OpenApiParameter(
+                name='limit',
+                description='Number of transactions to return',
+                required=False,
+                type=int,
+                default=10
+            )
+        ],
+        responses={200: RecentTransactionSerializer(many=True)}
+    ),
+    payment_analytics=extend_schema(
+        summary="Payment Analytics",
+        description="Get analytics for payments by currency and provider",
+        parameters=[
+            OpenApiParameter(
+                name='limit',
+                description='Number of analytics items to return',
+                required=False,
+                type=int,
+                default=10
+            )
+        ],
+        responses={200: 'object'}  # Generic object since it's a dict with currency_analytics and provider_analytics
+    ),
+    balance_overview=extend_schema(
+        summary="Balance Overview",
+        description="Get user balance overview",
+        responses={200: BalanceOverviewSerializer}
+    ),
+    subscription_overview=extend_schema(
+        summary="Subscription Overview",
+        description="Get current subscription overview",
+        responses={200: SubscriptionOverviewSerializer}
+    ),
+    api_keys_overview=extend_schema(
+        summary="API Keys Overview",
+        description="Get API keys overview",
+        responses={200: APIKeysOverviewSerializer}
+    )
+)
+class PaymentsDashboardViewSet(viewsets.GenericViewSet):
+    """
+    Payments dashboard data endpoints
+    """
+    permission_classes = [IsAuthenticated]
+    
+    @action(detail=False, methods=['get'])
+    def overview(self, request):
+        """
+        Get complete payments dashboard overview
+        """
+        # Initialize services
+        metrics_service = PaymentsDashboardMetricsService(request.user)
+        chart_service = PaymentsUsageChartService(request.user)
+        payments_service = RecentPaymentsService(request.user)
+        
+        # Get all data
+        data = {
+            'metrics': metrics_service.get_dashboard_metrics(),
+            'recent_payments': payments_service.get_recent_payments(limit=10),
+            'recent_transactions': payments_service.get_recent_transactions(limit=10),
+            'chart_data': chart_service.get_chart_data(period='30d')
+        }
+        
+        return Response(data)
+    
+    @action(detail=False, methods=['get'])
+    def metrics(self, request):
+        """
+        Get payments dashboard metrics only
+        """
+        service = PaymentsDashboardMetricsService(request.user)
+        metrics = service.get_dashboard_metrics()
+        return Response(metrics)
+    
+    @action(detail=False, methods=['get'])
+    def chart_data(self, request):
+        """
+        Get payments usage chart data
+        """
+        period = request.query_params.get('period', '30d')
+        
+        # Validate period
+        serializer = TimePeriodSerializer(data={'period': period})
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        
+        service = PaymentsUsageChartService(request.user)
+        data = service.get_chart_data(period)
+        return Response(data)
+    
+    @action(detail=False, methods=['get'])
+    def recent_payments(self, request):
+        """
+        Get recent payments
+        """
+        limit = int(request.query_params.get('limit', 10))
+        limit = min(limit, 50)  # Max 50 payments
+        
+        service = RecentPaymentsService(request.user)
+        payments = service.get_recent_payments(limit)
+        return Response(payments)
+    
+    @action(detail=False, methods=['get'])
+    def recent_transactions(self, request):
+        """
+        Get recent balance transactions
+        """
+        limit = int(request.query_params.get('limit', 10))
+        limit = min(limit, 50)  # Max 50 transactions
+        
+        service = RecentPaymentsService(request.user)
+        transactions = service.get_recent_transactions(limit)
+        return Response(transactions)
+    
+    @action(detail=False, methods=['get'])
+    def payment_analytics(self, request):
+        """
+        Get payment analytics
+        """
+        limit = int(request.query_params.get('limit', 10))
+        limit = min(limit, 20)  # Max 20 analytics items
+        
+        service = PaymentsAnalyticsService(request.user)
+        analytics = {
+            'currency_analytics': service.get_payment_analytics(limit),
+            'provider_analytics': service.get_provider_analytics(),
+        }
+        return Response(analytics)
+    
+    @action(detail=False, methods=['get'])
+    def balance_overview(self, request):
+        """
+        Get balance overview only
+        """
+        service = PaymentsDashboardMetricsService(request.user)
+        balance = service.get_balance_overview()
+        return Response(balance)
+    
+    @action(detail=False, methods=['get'])
+    def subscription_overview(self, request):
+        """
+        Get subscription overview only
+        """
+        service = PaymentsDashboardMetricsService(request.user)
+        subscription = service.get_subscription_overview()
+        return Response(subscription)
+    
+    @action(detail=False, methods=['get'])
+    def api_keys_overview(self, request):
+        """
+        Get API keys overview only
+        """
+        service = PaymentsDashboardMetricsService(request.user)
+        api_keys = service.get_api_keys_overview()
+        return Response(api_keys)

django_cfg/apps/payments/views/serializers/api_keys.py

@@ -23,8 +23,8 @@ class APIKeyListSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_valid = serializers.BooleanField(source='is_valid', read_only=True)
+    is_expired = serializers.BooleanField(read_only=True)
+    is_valid = serializers.BooleanField(read_only=True)
     
     class Meta:
         model = APIKey
@@ -51,10 +51,10 @@ class APIKeySerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    key_preview = serializers.CharField(source='key_preview', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_valid = serializers.BooleanField(source='is_valid', read_only=True)
-    days_until_expiry = serializers.IntegerField(source='days_until_expiry', read_only=True)
+    key_preview = serializers.CharField(read_only=True)
+    is_expired = serializers.BooleanField(read_only=True)
+    is_valid = serializers.BooleanField(read_only=True)
+    days_until_expiry = serializers.IntegerField(read_only=True)
     
     class Meta:
         model = APIKey
@@ -361,6 +361,20 @@ class APIKeyValidationSerializer(serializers.Serializer):
             }
 
 
+class APIKeyValidationResponseSerializer(serializers.Serializer):
+    """
+    API key validation response serializer.
+    
+    Defines the structure of API key validation response for OpenAPI schema.
+    """
+    success = serializers.BooleanField(help_text="Whether the validation was successful")
+    valid = serializers.BooleanField(help_text="Whether the API key is valid")
+    api_key = APIKeySerializer(allow_null=True, help_text="API key details if valid")
+    message = serializers.CharField(help_text="Validation message")
+    error = serializers.CharField(required=False, help_text="Error message if validation failed")
+    error_code = serializers.CharField(required=False, help_text="Error code if validation failed")
+
+
 class APIKeyStatsSerializer(serializers.Serializer):
     """
     API key statistics serializer.

django_cfg/apps/payments/views/serializers/balances.py

@@ -25,9 +25,6 @@ class UserBalanceSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    balance_display = serializers.CharField(source='balance_display', read_only=True)
-    is_empty = serializers.BooleanField(source='is_empty', read_only=True)
-    has_transactions = serializers.BooleanField(source='has_transactions', read_only=True)
     
     class Meta:
         model = UserBalance
@@ -51,17 +48,17 @@ class TransactionSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    type_color = serializers.CharField(source='type_color', read_only=True)
-    is_credit = serializers.BooleanField(source='is_credit', read_only=True)
-    is_debit = serializers.BooleanField(source='is_debit', read_only=True)
+    amount_display = serializers.CharField(read_only=True)
+    type_color = serializers.CharField(read_only=True)
+    is_credit = serializers.BooleanField(read_only=True)
+    is_debit = serializers.BooleanField(read_only=True)
     
     class Meta:
         model = Transaction
         fields = [
             'id',
             'user',
-            'amount',
+            'amount_usd',
             'amount_display',
             'transaction_type',
             'type_color',

django_cfg/apps/payments/views/serializers/currencies.py

@@ -22,9 +22,6 @@ class CurrencySerializer(serializers.ModelSerializer):
     """
     
     type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
-    is_crypto = serializers.BooleanField(source='is_crypto', read_only=True)
-    is_fiat = serializers.BooleanField(source='is_fiat', read_only=True)
-    is_stable = serializers.BooleanField(source='is_stable', read_only=True)
     
     class Meta:
         model = Currency
@@ -35,11 +32,10 @@ class CurrencySerializer(serializers.ModelSerializer):
             'symbol',
             'currency_type',
             'type_display',
-            'decimals',
+            'decimal_places',
             'is_active',
             'is_crypto',
             'is_fiat',
-            'is_stable',
             'created_at',
             'updated_at',
         ]
@@ -113,7 +109,7 @@ class ProviderCurrencySerializer(serializers.ModelSerializer):
             'min_amount',
             'max_amount',
             'fee_percentage',
-            'is_active',
+            'is_enabled',
             'created_at',
             'updated_at',
         ]

django_cfg/apps/payments/views/serializers/payments.py

@@ -25,21 +25,22 @@ class PaymentListSerializer(serializers.ModelSerializer):
     """
     
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    crypto_amount_display = serializers.CharField(source='crypto_amount_display', read_only=True)
+    amount_display = serializers.SerializerMethodField(read_only=True)
+    
+    def get_amount_display(self, obj):
+        """Get formatted amount display."""
+        return f"${obj.amount_usd:.2f}"
     
     class Meta:
         model = UniversalPayment
         fields = [
             'id',
             'amount_usd',
-            'crypto_amount',
-            'currency_code',
+            'currency',
             'provider',
             'status',
             'status_display',
             'amount_display',
-            'crypto_amount_display',
             'created_at',
             'expires_at',
         ]
@@ -55,17 +56,33 @@ class PaymentSerializer(serializers.ModelSerializer):
     
     user = serializers.StringRelatedField(read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    status_color = serializers.CharField(source='status_color', read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    crypto_amount_display = serializers.CharField(source='crypto_amount_display', read_only=True)
+    amount_display = serializers.SerializerMethodField(read_only=True)
     
     # Status check methods
-    is_pending = serializers.BooleanField(source='is_pending', read_only=True)
-    is_completed = serializers.BooleanField(source='is_completed', read_only=True)
-    is_failed = serializers.BooleanField(source='is_failed', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    can_be_cancelled = serializers.BooleanField(source='can_be_cancelled', read_only=True)
-    can_be_refunded = serializers.BooleanField(source='can_be_refunded', read_only=True)
+    is_pending = serializers.SerializerMethodField(read_only=True)
+    is_completed = serializers.SerializerMethodField(read_only=True)
+    is_failed = serializers.SerializerMethodField(read_only=True)
+    is_expired = serializers.SerializerMethodField(read_only=True)
+    
+    def get_amount_display(self, obj):
+        """Get formatted amount display."""
+        return f"${obj.amount_usd:.2f}"
+    
+    def get_is_pending(self, obj):
+        """Check if payment is pending."""
+        return obj.status == obj.PaymentStatus.PENDING
+    
+    def get_is_completed(self, obj):
+        """Check if payment is completed."""
+        return obj.status == obj.PaymentStatus.COMPLETED
+    
+    def get_is_failed(self, obj):
+        """Check if payment is failed."""
+        return obj.status == obj.PaymentStatus.FAILED
+    
+    def get_is_expired(self, obj):
+        """Check if payment is expired."""
+        return obj.status == obj.PaymentStatus.EXPIRED
     
     class Meta:
         model = UniversalPayment
@@ -73,24 +90,20 @@ class PaymentSerializer(serializers.ModelSerializer):
             'id',
             'user',
             'amount_usd',
-            'crypto_amount',
-            'currency_code',
+            'currency',
+            'network',
             'provider',
             'status',
             'status_display',
-            'status_color',
             'amount_display',
-            'crypto_amount_display',
             'provider_payment_id',
             'payment_url',
-            'qr_code_url',
-            'wallet_address',
+            'pay_address',
             'callback_url',
             'cancel_url',
             'description',
-            'metadata',
             'transaction_hash',
-            'confirmation_blocks',
+            'confirmations_count',
             'created_at',
             'updated_at',
             'expires_at',
@@ -100,32 +113,24 @@ class PaymentSerializer(serializers.ModelSerializer):
             'is_completed',
             'is_failed',
             'is_expired',
-            'can_be_cancelled',
-            'can_be_refunded',
         ]
         read_only_fields = [
             'id',
             'user',
-            'crypto_amount',
             'provider_payment_id',
             'payment_url',
-            'qr_code_url',
-            'wallet_address',
+            'pay_address',
             'transaction_hash',
-            'confirmation_blocks',
+            'confirmations_count',
             'created_at',
             'updated_at',
             'completed_at',
             'status_display',
-            'status_color',
             'amount_display',
-            'crypto_amount_display',
             'is_pending',
             'is_completed',
             'is_failed',
             'is_expired',
-            'can_be_cancelled',
-            'can_be_refunded',
         ]
 
 

django_cfg/apps/payments/views/serializers/subscriptions.py

@@ -29,7 +29,7 @@ class EndpointGroupSerializer(serializers.ModelSerializer):
             'id',
             'name',
             'description',
-            'is_active',
+            'is_enabled',
             'created_at',
             'updated_at',
         ]
@@ -52,9 +52,9 @@ class TariffSerializer(serializers.ModelSerializer):
             'id',
             'name',
             'description',
-            'monthly_price',
+            'monthly_price_usd',
             'requests_per_month',
-            'requests_per_minute',
+            'requests_per_hour',
             'is_active',
             'endpoint_groups',
             'endpoint_groups_count',
@@ -74,8 +74,6 @@ class SubscriptionListSerializer(serializers.ModelSerializer):
     user = serializers.StringRelatedField(read_only=True)
     tariff_name = serializers.CharField(source='tariff.name', read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    is_active = serializers.BooleanField(source='is_active', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
     
     class Meta:
         model = Subscription
@@ -104,18 +102,8 @@ class SubscriptionSerializer(serializers.ModelSerializer):
     tariff = TariffSerializer(read_only=True)
     endpoint_group = EndpointGroupSerializer(read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    status_color = serializers.CharField(source='status_color', read_only=True)
-    
-    # Status check methods
-    is_active = serializers.BooleanField(source='is_active', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_trial = serializers.BooleanField(source='is_trial', read_only=True)
-    can_be_renewed = serializers.BooleanField(source='can_be_renewed', read_only=True)
-    can_be_cancelled = serializers.BooleanField(source='can_be_cancelled', read_only=True)
     
-    # Usage statistics
-    usage_percentage = serializers.FloatField(source='usage_percentage', read_only=True)
-    requests_remaining = serializers.IntegerField(source='requests_remaining', read_only=True)
+    # Only keep fields that actually exist or are needed
     
     class Meta:
         model = Subscription
@@ -129,16 +117,11 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'status_color',
             'tier',
             'total_requests',
-            'requests_used',
-            'requests_remaining',
             'usage_percentage',
             'last_request_at',
             'expires_at',
             'is_active',
             'is_expired',
-            'is_trial',
-            'can_be_renewed',
-            'can_be_cancelled',
             'created_at',
             'updated_at',
         ]
@@ -146,8 +129,6 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'id',
             'user',
             'total_requests',
-            'requests_used',
-            'requests_remaining',
             'usage_percentage',
             'last_request_at',
             'created_at',
@@ -156,9 +137,6 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'status_color',
             'is_active',
             'is_expired',
-            'is_trial',
-            'can_be_renewed',
-            'can_be_cancelled',
         ]
 
 

django_cfg/apps/urls.py

@@ -52,7 +52,8 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
         # if base_module.is_maintenance_enabled():
         #     patterns.append(path('admin/django_cfg_maintenance/', include('django_cfg.apps.maintenance.urls_admin')))
 
-        if base_module.is_payments_enabled():
+        # if base_module.is_payments_enabled():
+        if True:
             patterns.append(path('admin/django_cfg_payments/admin/', include('django_cfg.apps.payments.urls_admin')))
             
     except Exception:

django_cfg/core/config.py

@@ -336,7 +336,6 @@ class DjangoConfig(BaseModel):
     )
 
     # === Internal State ===
-    _environment: Optional[str] = PrivateAttr(default=None)
     _base_dir: Optional[Path] = PrivateAttr(default=None)
     _django_settings: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
@@ -353,7 +352,7 @@ class DjangoConfig(BaseModel):
         super().__init__(**data)
 
         # Initialize internal state
-        self._detect_environment()
+        self._auto_detect_env_mode()
         self._resolve_paths()
         self._apply_smart_defaults()
         self._load_environment_config()
@@ -448,14 +447,22 @@ class DjangoConfig(BaseModel):
         """Check if running in test mode."""
         return self.env_mode == EnvironmentMode.TEST
 
-    def _detect_environment(self) -> None:
-        """Detect current environment from various sources."""
-        from django_cfg.core.environment import EnvironmentDetector
-
-        try:
-            self._environment = EnvironmentDetector.detect_environment()
-        except Exception as e:
-            raise EnvironmentError(f"Failed to detect environment: {e}", suggestions=["Set DJANGO_ENV environment variable explicitly"]) from e
+    def _auto_detect_env_mode(self) -> None:
+        """Auto-detect environment mode from various sources."""
+        import os
+        
+        # Check environment variables first
+        env_var = os.getenv("DJANGO_ENV", "").lower()
+        if env_var in ["development", "dev"]:
+            self.env_mode = EnvironmentMode.DEVELOPMENT
+        elif env_var in ["production", "prod"]:
+            self.env_mode = EnvironmentMode.PRODUCTION
+        elif env_var in ["test", "testing"]:
+            self.env_mode = EnvironmentMode.TEST
+        elif hasattr(self, 'debug') and self.debug:
+            # Auto-detect from debug flag if no env var set
+            self.env_mode = EnvironmentMode.DEVELOPMENT
+        # Otherwise keep the default (PRODUCTION)
 
     @property
     def base_dir(self) -> Path:
@@ -509,17 +516,17 @@ class DjangoConfig(BaseModel):
         try:
             # Apply cache defaults
             if self.cache_default:
-                self.cache_default = SmartDefaults.configure_cache_backend(self.cache_default, self._environment, self.debug)
+                self.cache_default = SmartDefaults.configure_cache_backend(self.cache_default, self.env_mode, self.debug)
 
             if self.cache_sessions:
-                self.cache_sessions = SmartDefaults.configure_cache_backend(self.cache_sessions, self._environment, self.debug)
+                self.cache_sessions = SmartDefaults.configure_cache_backend(self.cache_sessions, self.env_mode, self.debug)
 
             # Apply email defaults
             if self.email:
-                self.email = SmartDefaults.configure_email_backend(self.email, self._environment, self.debug)
+                self.email = SmartDefaults.configure_email_backend(self.email, self.env_mode, self.debug)
 
         except Exception as e:
-            raise ConfigurationError(f"Failed to apply smart defaults: {e}", context={"environment": self._environment, "debug": self.debug}) from e
+            raise ConfigurationError(f"Failed to apply smart defaults: {e}", context={"environment": self.env_mode, "debug": self.debug}) from e
 
     def _load_environment_config(self) -> None:
         """Load environment-specific configuration from YAML files."""
@@ -775,6 +782,9 @@ class DjangoConfig(BaseModel):
         if self.enable_accounts:
             middleware.append("django_cfg.middleware.UserActivityMiddleware")
 
+        # Add static no-cache middleware (auto-detects development mode)
+        middleware.append("django_cfg.middleware.StaticNoCacheMiddleware")
+
         # Add payments middleware if enabled
         if self.payments and self.payments.enabled:
             middleware.extend(self.payments.get_middleware_classes())
@@ -854,7 +864,7 @@ class DjangoConfig(BaseModel):
         Returns:
             Model data with internal fields excluded
         """
-        return self.model_dump(exclude={"_environment", "_base_dir", "_django_settings"}, exclude_none=True)
+        return self.model_dump(exclude={"_base_dir", "_django_settings"}, exclude_none=True)
 
 
 # Global config instance for access from other modules