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

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

@@ -0,0 +1,429 @@
+"""
+Subscription serializers for the Universal Payment System v2.0.
+
+DRF serializers for subscription operations with service integration.
+"""
+
+from rest_framework import serializers
+from typing import Dict, Any
+from django.contrib.auth import get_user_model
+
+from ...models import Subscription, EndpointGroup, Tariff
+from ...services import get_subscription_service, SubscriptionCreateRequest, SubscriptionUpdateRequest
+from django_cfg.modules.django_logger import get_logger
+
+User = get_user_model()
+logger = get_logger("subscription_serializers")
+
+
+class EndpointGroupSerializer(serializers.ModelSerializer):
+    """
+    Endpoint group serializer for API access management.
+    
+    Used for subscription endpoint group configuration.
+    """
+    
+    class Meta:
+        model = EndpointGroup
+        fields = [
+            'id',
+            'name',
+            'description',
+            'is_active',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class TariffSerializer(serializers.ModelSerializer):
+    """
+    Tariff serializer for subscription pricing.
+    
+    Used for tariff information and selection.
+    """
+    
+    endpoint_groups = EndpointGroupSerializer(many=True, read_only=True)
+    endpoint_groups_count = serializers.IntegerField(source='endpoint_groups.count', read_only=True)
+    
+    class Meta:
+        model = Tariff
+        fields = [
+            'id',
+            'name',
+            'description',
+            'monthly_price',
+            'requests_per_month',
+            'requests_per_minute',
+            'is_active',
+            'endpoint_groups',
+            'endpoint_groups_count',
+            'created_at',
+            'updated_at',
+        ]
+        read_only_fields = fields
+
+
+class SubscriptionListSerializer(serializers.ModelSerializer):
+    """
+    Lightweight subscription serializer for lists.
+    
+    Optimized for subscription lists with minimal data.
+    """
+    
+    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
+        fields = [
+            'id',
+            'user',
+            'tariff_name',
+            'status',
+            'status_display',
+            'is_active',
+            'is_expired',
+            'expires_at',
+            'created_at',
+        ]
+        read_only_fields = fields
+
+
+class SubscriptionSerializer(serializers.ModelSerializer):
+    """
+    Complete subscription serializer with full details.
+    
+    Used for subscription detail views and updates.
+    """
+    
+    user = serializers.StringRelatedField(read_only=True)
+    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)
+    
+    class Meta:
+        model = Subscription
+        fields = [
+            'id',
+            'user',
+            'tariff',
+            'endpoint_group',
+            'status',
+            'status_display',
+            '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',
+        ]
+        read_only_fields = [
+            'id',
+            'user',
+            'total_requests',
+            'requests_used',
+            'requests_remaining',
+            'usage_percentage',
+            'last_request_at',
+            'created_at',
+            'updated_at',
+            'status_display',
+            'status_color',
+            'is_active',
+            'is_expired',
+            'is_trial',
+            'can_be_renewed',
+            'can_be_cancelled',
+        ]
+
+
+class SubscriptionCreateSerializer(serializers.Serializer):
+    """
+    Subscription creation serializer with service integration.
+    
+    Validates input and delegates to SubscriptionService.
+    """
+    
+    tariff_id = serializers.IntegerField(
+        min_value=1,
+        help_text="Tariff ID for the subscription"
+    )
+    endpoint_group_id = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        min_value=1,
+        help_text="Endpoint group ID (optional)"
+    )
+    duration_days = serializers.IntegerField(
+        default=30,
+        min_value=1,
+        max_value=365,
+        help_text="Subscription duration in days"
+    )
+    
+    def validate_tariff_id(self, value: int) -> int:
+        """Validate tariff exists and is active."""
+        if not Tariff.objects.filter(id=value, is_active=True).exists():
+            raise serializers.ValidationError(f"Tariff {value} not found or inactive")
+        return value
+    
+    def validate_endpoint_group_id(self, value: int) -> int:
+        """Validate endpoint group exists and is active."""
+        if value and not EndpointGroup.objects.filter(id=value, is_active=True).exists():
+            raise serializers.ValidationError(f"Endpoint group {value} not found or inactive")
+        return value
+    
+    def validate(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate subscription creation data."""
+        try:
+            # Get user from context
+            user_id = self.context.get('user_pk') or self.context['request'].user.id
+            
+            # Create Pydantic request for validation
+            request = SubscriptionCreateRequest(
+                user_id=user_id,
+                **attrs
+            )
+            
+            # Store validated request for create method
+            self._validated_request = request
+            return attrs
+            
+        except Exception as e:
+            logger.error(f"Subscription validation failed: {e}")
+            raise serializers.ValidationError(f"Invalid subscription data: {e}")
+    
+    def create(self, validated_data: Dict[str, Any]) -> Subscription:
+        """Create subscription using SubscriptionService."""
+        try:
+            subscription_service = get_subscription_service()
+            result = subscription_service.create_subscription(self._validated_request)
+            
+            if result.success:
+                # Get the created subscription from database
+                subscription = Subscription.objects.get(id=result.subscription_id)
+                
+                logger.info(f"Subscription created successfully", extra={
+                    'subscription_id': result.subscription_id,
+                    'user_id': self._validated_request.user_id,
+                    'tariff_id': self._validated_request.tariff_id
+                })
+                
+                return subscription
+            else:
+                logger.error(f"Subscription creation failed: {result.message}")
+                raise serializers.ValidationError(result.message)
+                
+        except Exception as e:
+            logger.error(f"Subscription creation error: {e}")
+            raise serializers.ValidationError(f"Subscription creation failed: {e}")
+    
+    def to_representation(self, instance: Subscription) -> Dict[str, Any]:
+        """Return full subscription data after creation."""
+        return SubscriptionSerializer(instance, context=self.context).data
+
+
+class SubscriptionUpdateSerializer(serializers.Serializer):
+    """
+    Subscription update serializer with service integration.
+    
+    Handles subscription modifications through SubscriptionService.
+    """
+    
+    action = serializers.ChoiceField(
+        choices=[
+            ('activate', 'Activate'),
+            ('suspend', 'Suspend'),
+            ('cancel', 'Cancel'),
+            ('renew', 'Renew'),
+        ],
+        help_text="Action to perform on subscription"
+    )
+    reason = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        max_length=500,
+        help_text="Reason for the action"
+    )
+    duration_days = serializers.IntegerField(
+        required=False,
+        min_value=1,
+        max_value=365,
+        help_text="Duration for renewal (required for renew action)"
+    )
+    
+    def validate(self, attrs: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate subscription update data."""
+        action = attrs.get('action')
+        duration_days = attrs.get('duration_days')
+        
+        if action == 'renew' and not duration_days:
+            raise serializers.ValidationError("duration_days is required for renew action")
+        
+        return attrs
+    
+    def save(self) -> Dict[str, Any]:
+        """Update subscription using SubscriptionService."""
+        try:
+            subscription_id = self.context.get('subscription_id')
+            if not subscription_id:
+                raise serializers.ValidationError("Subscription ID is required")
+            
+            subscription_service = get_subscription_service()
+            action = self.validated_data['action']
+            reason = self.validated_data.get('reason')
+            duration_days = self.validated_data.get('duration_days')
+            
+            # Call appropriate service method based on action
+            if action == 'activate':
+                result = subscription_service.activate_subscription(subscription_id)
+            elif action == 'suspend':
+                result = subscription_service.suspend_subscription(subscription_id, reason)
+            elif action == 'cancel':
+                result = subscription_service.cancel_subscription(subscription_id, reason)
+            elif action == 'renew':
+                result = subscription_service.renew_subscription(subscription_id, duration_days)
+            else:
+                raise serializers.ValidationError(f"Unknown action: {action}")
+            
+            if result.success:
+                # Get updated subscription
+                subscription = Subscription.objects.get(id=result.subscription_id)
+                
+                return {
+                    'success': True,
+                    'message': result.message,
+                    'subscription': SubscriptionSerializer(subscription, context=self.context).data
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Subscription update error: {e}")
+            return {
+                'success': False,
+                'error': f"Subscription update failed: {e}",
+                'error_code': 'subscription_update_error'
+            }
+
+
+class SubscriptionUsageSerializer(serializers.Serializer):
+    """
+    Subscription usage tracking serializer.
+    
+    Used for incrementing usage counters.
+    """
+    
+    endpoint = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        max_length=200,
+        help_text="API endpoint used"
+    )
+    
+    def save(self) -> Dict[str, Any]:
+        """Increment subscription usage using SubscriptionService."""
+        try:
+            subscription_id = self.context.get('subscription_id')
+            if not subscription_id:
+                raise serializers.ValidationError("Subscription ID is required")
+            
+            subscription_service = get_subscription_service()
+            result = subscription_service.increment_usage(
+                subscription_id=subscription_id,
+                endpoint=self.validated_data.get('endpoint')
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'message': result.message,
+                    'usage': result.data
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Usage increment error: {e}")
+            return {
+                'success': False,
+                'error': f"Usage increment failed: {e}",
+                'error_code': 'usage_increment_error'
+            }
+
+
+class SubscriptionStatsSerializer(serializers.Serializer):
+    """
+    Subscription statistics serializer.
+    
+    Used for subscription analytics and reporting.
+    """
+    
+    days = serializers.IntegerField(
+        default=30,
+        min_value=1,
+        max_value=365,
+        help_text="Number of days to analyze"
+    )
+    
+    def save(self) -> Dict[str, Any]:
+        """Get subscription statistics using SubscriptionService."""
+        try:
+            subscription_service = get_subscription_service()
+            result = subscription_service.get_subscription_stats(
+                days=self.validated_data['days']
+            )
+            
+            if result.success:
+                return {
+                    'success': True,
+                    'stats': result.data,
+                    'message': result.message
+                }
+            else:
+                return {
+                    'success': False,
+                    'error': result.message,
+                    'error_code': result.error_code
+                }
+                
+        except Exception as e:
+            logger.error(f"Subscription stats error: {e}")
+            return {
+                'success': False,
+                'error': f"Stats generation failed: {e}",
+                'error_code': 'stats_error'
+            }

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

@@ -0,0 +1,137 @@
+"""
+Webhook serializers for the Universal Payment System v2.0.
+
+DRF serializers for webhook endpoints and data validation.
+"""
+
+from rest_framework import serializers
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class WebhookSerializer(serializers.Serializer):
+    """
+    Generic webhook serializer.
+    
+    Base serializer for all webhook types.
+    """
+    
+    provider = serializers.CharField(max_length=50, help_text="Payment provider name")
+    success = serializers.BooleanField(help_text="Processing success status")
+    message = serializers.CharField(max_length=500, help_text="Processing message")
+    
+    class Meta:
+        fields = ['provider', 'success', 'message']
+
+
+class WebhookDataSerializer(serializers.Serializer):
+    """
+    Serializer for incoming webhook data.
+    
+    Generic webhook data structure for all providers.
+    """
+    
+    provider = serializers.CharField(max_length=50, help_text="Payment provider name")
+    payment_id = serializers.CharField(max_length=256, help_text="Provider payment ID")
+    status = serializers.CharField(max_length=50, help_text="Payment status")
+    amount = serializers.DecimalField(max_digits=20, decimal_places=8, required=False, help_text="Payment amount")
+    currency = serializers.CharField(max_length=10, required=False, help_text="Payment currency")
+    transaction_hash = serializers.CharField(max_length=256, required=False, help_text="Blockchain transaction hash")
+    confirmations = serializers.IntegerField(required=False, help_text="Number of confirmations")
+    
+    # Raw webhook data
+    raw_data = serializers.JSONField(help_text="Raw webhook payload")
+    
+    class Meta:
+        fields = [
+            'provider', 'payment_id', 'status', 'amount', 
+            'currency', 'transaction_hash', 'confirmations', 'raw_data'
+        ]
+
+
+class WebhookResponseSerializer(serializers.Serializer):
+    """
+    Serializer for webhook processing response.
+    
+    Standard response format for all webhook endpoints.
+    """
+    
+    success = serializers.BooleanField(help_text="Whether webhook was processed successfully")
+    message = serializers.CharField(max_length=500, help_text="Processing result message")
+    payment_id = serializers.CharField(max_length=256, required=False, help_text="Internal payment ID")
+    provider_payment_id = serializers.CharField(max_length=256, required=False, help_text="Provider payment ID")
+    processed_at = serializers.DateTimeField(required=False, help_text="Processing timestamp")
+    
+    class Meta:
+        fields = ['success', 'message', 'payment_id', 'provider_payment_id', 'processed_at']
+
+
+class WebhookHealthSerializer(serializers.Serializer):
+    """
+    Serializer for webhook health check response.
+    """
+    
+    status = serializers.CharField(max_length=20, help_text="Health status")
+    timestamp = serializers.DateTimeField(help_text="Check timestamp")
+    providers = serializers.JSONField(help_text="Provider health status")
+    
+    class Meta:
+        fields = ['status', 'timestamp', 'providers']
+
+
+class WebhookStatsSerializer(serializers.Serializer):
+    """
+    Serializer for webhook statistics response.
+    """
+    
+    total_webhooks = serializers.IntegerField(help_text="Total webhooks processed")
+    successful_webhooks = serializers.IntegerField(help_text="Successfully processed webhooks")
+    failed_webhooks = serializers.IntegerField(help_text="Failed webhook processing attempts")
+    success_rate = serializers.FloatField(help_text="Success rate percentage")
+    providers = serializers.JSONField(help_text="Per-provider statistics")
+    
+    class Meta:
+        fields = ['total_webhooks', 'successful_webhooks', 'failed_webhooks', 'success_rate', 'providers']
+
+
+class SupportedProvidersSerializer(serializers.Serializer):
+    """
+    Serializer for supported providers response.
+    """
+    
+    success = serializers.BooleanField(help_text="Request success status")
+    providers = serializers.JSONField(help_text="List of supported providers")
+    total_count = serializers.IntegerField(help_text="Total number of providers")
+    timestamp = serializers.DateTimeField(help_text="Response timestamp")
+    
+    class Meta:
+        fields = ['success', 'providers', 'total_count', 'timestamp']
+
+
+class NowPaymentsWebhookSerializer(serializers.Serializer):
+    """
+    Serializer for NowPayments webhook data.
+    
+    Specific to NowPayments IPN format.
+    """
+    
+    payment_id = serializers.CharField(max_length=256, help_text="NowPayments payment ID")
+    payment_status = serializers.CharField(max_length=50, help_text="Payment status")
+    pay_address = serializers.CharField(max_length=256, required=False, help_text="Payment address")
+    price_amount = serializers.DecimalField(max_digits=20, decimal_places=8, required=False, help_text="Price amount")
+    price_currency = serializers.CharField(max_length=10, required=False, help_text="Price currency")
+    pay_amount = serializers.DecimalField(max_digits=20, decimal_places=8, required=False, help_text="Pay amount")
+    pay_currency = serializers.CharField(max_length=10, required=False, help_text="Pay currency")
+    order_id = serializers.CharField(max_length=256, required=False, help_text="Order ID")
+    order_description = serializers.CharField(max_length=500, required=False, help_text="Order description")
+    purchase_id = serializers.CharField(max_length=256, required=False, help_text="Purchase ID")
+    outcome_amount = serializers.DecimalField(max_digits=20, decimal_places=8, required=False, help_text="Outcome amount")
+    outcome_currency = serializers.CharField(max_length=10, required=False, help_text="Outcome currency")
+    
+    class Meta:
+        fields = [
+            'payment_id', 'payment_status', 'pay_address', 'price_amount', 'price_currency',
+            'pay_amount', 'pay_currency', 'order_id', 'order_description', 'purchase_id',
+            'outcome_amount', 'outcome_currency'
+        ]

django_cfg/config.py

@@ -10,7 +10,7 @@ from .modules.django_unfold.models.dropdown import SiteDropdownItem
 
 
 # Library configuration
-LIB_NAME = "Django CFG"
+LIB_NAME = "django-cfg"
 LIB_SITE_URL = "https://djangocfg.com"
 LIB_DOCS_URL = "https://docs.djangocfg.com"
 LIB_GITHUB_URL = "https://github.com/django-cfg/django-cfg"

django_cfg/core/config.py

@@ -79,6 +79,13 @@ class EnvironmentMode(str, Enum):
         return cls.DEVELOPMENT if debug else cls.PRODUCTION
 
 
+class StartupInfoMode(str, Enum):
+    """Startup information display mode."""
+    NONE = "none"        # Minimal info only (version, environment, critical errors)
+    SHORT = "short"      # Essential info (apps, endpoints, status, updates)
+    FULL = "full"        # Complete info (everything from old system)
+
+
 class DjangoConfig(BaseModel):
     """
     Base configuration class for Django projects.
@@ -150,6 +157,11 @@ class DjangoConfig(BaseModel):
     )
 
     # === Django CFG Features ===
+    startup_info_mode: StartupInfoMode = Field(
+        default=StartupInfoMode.FULL,
+        description="Startup information display mode: none (minimal), short (essential), full (complete)",
+    )
+    
     enable_support: bool = Field(
         default=True,
         description="Enable django-cfg Support application (tickets, messages, chat interface)",
@@ -601,16 +613,40 @@ class DjangoConfig(BaseModel):
         if self.enable_knowbase or self.enable_agents:
             return True
         
-        # Check if payments module requires tasks
-        if self.payments and self.payments.should_enable_tasks():
-            return True
-
         # Check if agents module requires tasks
         if self.enable_agents:
             return True
         
         return False
 
+    def get_enabled_apps(self) -> List[str]:
+        """
+        Get list of enabled django-cfg apps.
+        """
+        
+        apps = [
+            "django_cfg.apps.api.health",
+            "django_cfg.apps.api.commands",
+        ]
+        
+        if self.enable_support:
+            apps.append("django_cfg.apps.support")
+        if self.enable_accounts:
+            apps.append("django_cfg.apps.accounts")
+        if self.enable_newsletter:
+            apps.append("django_cfg.apps.newsletter")
+        if self.enable_leads:
+            apps.append("django_cfg.apps.leads")
+        if self.enable_knowbase:
+            apps.append("django_cfg.apps.knowbase")
+        if self.enable_agents:
+            apps.append("django_cfg.apps.agents")
+        if self.enable_maintenance:
+            apps.append("django_cfg.apps.maintenance")
+        if self.payments and self.payments.enabled:
+            apps.append("django_cfg.apps.payments")
+        return apps
+
     def get_installed_apps(self) -> List[str]:
         """
         Get complete list of installed Django apps.

django_cfg/core/generation.py

@@ -114,13 +114,34 @@ class SettingsGenerator:
 
             # Add templates configuration
             django_cfg_templates = Path(__file__).parent.parent / "templates"
+            
+            # Collect all django-cfg template directories
+            template_dirs = [
+                config.base_dir / "templates",
+                django_cfg_templates,  # Add django_cfg templates
+            ]
+            
+            # Auto-discover app template directories
+            django_cfg_dir = Path(__file__).parent.parent
+            apps_dir = django_cfg_dir / 'apps'
+            if apps_dir.exists():
+                for app_dir in apps_dir.iterdir():
+                    if app_dir.is_dir() and not app_dir.name.startswith(('@', '_', '.')):
+                        # Look for common template directory patterns
+                        possible_template_dirs = [
+                            app_dir / 'templates',
+                            app_dir / 'admin_interface' / 'templates',
+                            app_dir / 'frontend' / 'templates',
+                        ]
+                        
+                        for template_dir in possible_template_dirs:
+                            if template_dir.exists():
+                                template_dirs.append(template_dir)
+            
             settings["TEMPLATES"] = [
                 {
                     "BACKEND": "django.template.backends.django.DjangoTemplates",
-                    "DIRS": [
-                        config.base_dir / "templates",
-                        django_cfg_templates,  # Add django_cfg templates
-                    ],
+                    "DIRS": template_dirs,
                     "APP_DIRS": True,
                     "OPTIONS": {
                         "context_processors": [