django-cfg 1.4.10__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/models/django/openapi.py

@@ -0,0 +1,238 @@
+"""
+Django Client (OpenAPI) Configuration with DRF Integration
+
+Extended configuration model that integrates openapi_client for automatic
+TypeScript and Python client generation from Django REST Framework endpoints.
+
+This replaces django-revolution with a cleaner, faster, type-safe implementation.
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field
+from django_cfg.modules.django_client.core.config import OpenAPIConfig, OpenAPIGroupConfig
+
+
+class ExtendedOpenAPIConfig(OpenAPIConfig):
+    """
+    Extended OpenAPI configuration with DRF parameters for django-cfg integration.
+
+    This extends the base OpenAPIConfig to include DRF-specific
+    parameters and django-cfg integration helpers.
+
+    Example:
+        ```python
+        from django_cfg import ExtendedOpenAPIConfig, OpenAPIGroupConfig
+
+        config = ExtendedOpenAPIConfig(
+            enabled=True,
+            groups=[
+                OpenAPIGroupConfig(
+                    name='api',
+                    apps=['users', 'posts'],
+                    title='Main API',
+                    version='v1',
+                ),
+            ],
+            drf_title='My API',
+            drf_description='REST API for my project',
+        )
+        ```
+    """
+
+    # DRF Configuration parameters for automatic DRF setup
+    drf_title: str = Field(
+        default="API",
+        description="API title for DRF Spectacular"
+    )
+    drf_description: str = Field(
+        default="RESTful API",
+        description="API description for DRF Spectacular"
+    )
+    drf_version: str = Field(
+        default="1.0.0",
+        description="API version for DRF Spectacular"
+    )
+    drf_schema_path_prefix: Optional[str] = Field(
+        default=None,  # Will default to "/api/" if None
+        description="Schema path prefix for DRF Spectacular"
+    )
+    drf_enable_browsable_api: bool = Field(
+        default=False,
+        description="Enable DRF browsable API"
+    )
+    drf_enable_throttling: bool = Field(
+        default=False,
+        description="Enable DRF throttling"
+    )
+    drf_serve_include_schema: bool = Field(
+        default=False,
+        description="Include schema in Spectacular UI"
+    )
+
+    # Django-cfg specific integration
+    api_prefix: str = Field(
+        default="api",
+        description="API prefix for URL routing (e.g., 'api' -> /api/...)"
+    )
+
+    def get_drf_schema_path_prefix(self) -> str:
+        """Get the schema path prefix, defaulting to api_prefix if not set."""
+        if self.drf_schema_path_prefix:
+            return self.drf_schema_path_prefix
+        return f"/{self.api_prefix}/"
+
+    def get_drf_config_kwargs(self) -> Dict[str, Any]:
+        """
+        Get kwargs for DRF configuration from this config.
+
+        Returns:
+            Dict of parameters for DRF + Spectacular setup
+        """
+        return {
+            "title": self.drf_title,
+            "description": self.drf_description,
+            "version": self.drf_version,
+            "schema_path_prefix": self.get_drf_schema_path_prefix(),
+            "enable_browsable_api": self.drf_enable_browsable_api,
+            "enable_throttling": self.drf_enable_throttling,
+            "serve_include_schema": self.drf_serve_include_schema,
+            # REQUIRED by django-client for correct Request/Response split
+            "component_split_request": True,
+            "component_split_patch": True,
+        }
+
+    def get_groups_with_defaults(self) -> Dict[str, OpenAPIGroupConfig]:
+        """
+        Get groups with django-cfg default groups automatically added.
+
+        Returns:
+            Dict of groups including default django-cfg groups
+        """
+        # Convert list to dict for compatibility
+        groups_dict = {group.name: group for group in self.groups}
+
+        # Add default django-cfg groups if enabled
+        try:
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
+
+            support_enabled = base_module.is_support_enabled()
+            accounts_enabled = base_module.is_accounts_enabled()
+            newsletter_enabled = base_module.is_newsletter_enabled()
+            leads_enabled = base_module.is_leads_enabled()
+            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()
+
+            # Collect all enabled django-cfg apps for unified group
+            enabled_cfg_apps = []
+            if support_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.support")
+            if accounts_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.accounts")
+            if newsletter_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.newsletter")
+            if leads_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.leads")
+            if knowbase_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.knowbase")
+            if agents_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.agents")
+            if tasks_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.tasks")
+            if payments_enabled:
+                enabled_cfg_apps.append("django_cfg.apps.payments")
+
+            # Add unified 'cfg' group with all enabled apps
+            if enabled_cfg_apps and 'cfg' not in groups_dict:
+                groups_dict['cfg'] = OpenAPIGroupConfig(
+                    name="cfg",
+                    apps=enabled_cfg_apps,
+                    title="Django-CFG API",
+                    description="All django-cfg built-in applications",
+                )
+
+            # Skip individual cfg_* groups - use unified 'cfg' instead
+            return groups_dict
+
+            # Add Support group if enabled
+            if support_enabled and 'cfg_support' not in groups_dict:
+                groups_dict['cfg_support'] = OpenAPIGroupConfig(
+                    name="cfg_support",
+                    apps=["django_cfg.apps.support"],
+                    title="Support API",
+                    description="Support tickets and messages API",
+                )
+
+            # Add Accounts group if enabled
+            if accounts_enabled and 'cfg_accounts' not in groups_dict:
+                groups_dict['cfg_accounts'] = OpenAPIGroupConfig(
+                    name="cfg_accounts",
+                    apps=["django_cfg.apps.accounts"],
+                    title="Accounts API",
+                    description="User management, OTP, profiles, and activity tracking API",
+                )
+
+            # Add Newsletter group if enabled
+            if newsletter_enabled and 'cfg_newsletter' not in groups_dict:
+                groups_dict['cfg_newsletter'] = OpenAPIGroupConfig(
+                    name="cfg_newsletter",
+                    apps=["django_cfg.apps.newsletter"],
+                    title="Newsletter API",
+                    description="Email campaigns, subscriptions, and newsletter management API",
+                )
+
+            # Add Leads group if enabled
+            if leads_enabled and 'cfg_leads' not in groups_dict:
+                groups_dict['cfg_leads'] = OpenAPIGroupConfig(
+                    name="cfg_leads",
+                    apps=["django_cfg.apps.leads"],
+                    title="Leads API",
+                    description="Lead collection, contact forms, and CRM integration API",
+                )
+
+            # Add Knowbase group if enabled
+            if knowbase_enabled and 'cfg_knowbase' not in groups_dict:
+                groups_dict['cfg_knowbase'] = OpenAPIGroupConfig(
+                    name="cfg_knowbase",
+                    apps=["django_cfg.apps.knowbase"],
+                    title="Knowbase API",
+                    description="Knowledge base, AI chat, embeddings, and search API",
+                )
+
+            # Add Agents group if enabled
+            if agents_enabled and 'cfg_agents' not in groups_dict:
+                groups_dict['cfg_agents'] = OpenAPIGroupConfig(
+                    name="cfg_agents",
+                    apps=["django_cfg.apps.agents"],
+                    title="Agents API",
+                    description="Agent definitions, executions, workflows, and tools API",
+                )
+
+            # Add Tasks group if enabled
+            if tasks_enabled and 'cfg_tasks' not in groups_dict:
+                groups_dict['cfg_tasks'] = OpenAPIGroupConfig(
+                    name="cfg_tasks",
+                    apps=["django_cfg.apps.tasks"],
+                    title="Tasks API",
+                    description="Tasks, workflows, and automation API",
+                )
+
+            # Add Payments group if enabled
+            if payments_enabled and 'cfg_payments' not in groups_dict:
+                groups_dict['cfg_payments'] = OpenAPIGroupConfig(
+                    name="cfg_payments",
+                    apps=["django_cfg.apps.payments"],
+                    title="Payments API",
+                    description="Payments, subscriptions, and billing API",
+                )
+
+        except Exception:
+            pass
+
+        return groups_dict
+
+
+# Alias for easier import
+OpenAPIClientConfig = ExtendedOpenAPIConfig

django_cfg/modules/django_admin/management/commands/check_endpoints.py

@@ -0,0 +1,169 @@
+"""
+Django management command to check all API endpoints status.
+
+Usage:
+    python manage.py check_endpoints
+    python manage.py check_endpoints --include-unnamed
+    python manage.py check_endpoints --timeout 10
+    python manage.py check_endpoints --json
+"""
+
+from django.core.management.base import BaseCommand
+from django.urls import reverse
+from django_cfg.apps.api.endpoints.checker import check_all_endpoints
+import json
+
+
+class Command(BaseCommand):
+    help = 'Check status of all Django CFG API endpoints'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--include-unnamed',
+            action='store_true',
+            help='Include unnamed URL patterns in the check',
+        )
+        parser.add_argument(
+            '--timeout',
+            type=int,
+            default=5,
+            help='Request timeout in seconds (default: 5)',
+        )
+        parser.add_argument(
+            '--json',
+            action='store_true',
+            help='Output results as JSON',
+        )
+        parser.add_argument(
+            '--url',
+            type=str,
+            help='Check specific endpoint by URL name (e.g., "endpoints_status")',
+        )
+        parser.add_argument(
+            '--no-auth',
+            action='store_true',
+            help='Disable automatic JWT authentication retry (default: enabled)',
+        )
+
+    def handle(self, *args, **options):
+        include_unnamed = options['include_unnamed']
+        timeout = options['timeout']
+        output_json = options['json']
+        url_name = options.get('url')
+        auto_auth = not options['no_auth']  # Auto-auth enabled by default
+
+        # If specific URL requested, just resolve and display it
+        if url_name:
+            try:
+                url = reverse(url_name)
+                self.stdout.write(self.style.SUCCESS(f'✅ URL name "{url_name}" resolves to: {url}'))
+                return
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f'❌ Error resolving URL "{url_name}": {e}'))
+                return
+
+        # Check all endpoints
+        auth_msg = "with auto-auth" if auto_auth else "without auth"
+        self.stdout.write(self.style.WARNING(f'🔍 Checking endpoints (timeout: {timeout}s, {auth_msg})...'))
+
+        status_data = check_all_endpoints(
+            include_unnamed=include_unnamed,
+            timeout=timeout,
+            auto_auth=auto_auth
+        )
+
+        # Output as JSON if requested
+        if output_json:
+            self.stdout.write(json.dumps(status_data, indent=2))
+            return
+
+        # Pretty print results
+        self._print_results(status_data)
+
+    def _print_results(self, data):
+        """Print formatted results to console."""
+
+        # Overall status
+        status = data['status']
+        if status == 'healthy':
+            status_style = self.style.SUCCESS
+            emoji = '✅'
+        elif status == 'degraded':
+            status_style = self.style.WARNING
+            emoji = '⚠️'
+        else:
+            status_style = self.style.ERROR
+            emoji = '❌'
+
+        self.stdout.write('')
+        self.stdout.write(status_style(f'{emoji} Overall Status: {status.upper()}'))
+        self.stdout.write('')
+
+        # Summary
+        self.stdout.write(self.style.HTTP_INFO('📊 Summary:'))
+        self.stdout.write(f'  Total endpoints: {data["total_endpoints"]}')
+        self.stdout.write(self.style.SUCCESS(f'  ✅ Healthy: {data["healthy"]}'))
+        self.stdout.write(self.style.WARNING(f'  ⚠️  Warnings: {data["warnings"]}'))
+        self.stdout.write(self.style.ERROR(f'  ❌ Unhealthy: {data["unhealthy"]}'))
+        self.stdout.write(self.style.ERROR(f'  ❌ Errors: {data["errors"]}'))
+        self.stdout.write(f'  ⏭️  Skipped: {data["skipped"]}')
+        self.stdout.write('')
+
+        # Endpoints details
+        self.stdout.write(self.style.HTTP_INFO('🔗 Endpoints:'))
+
+        for endpoint in data['endpoints']:
+            name = endpoint.get('url_name') or 'unnamed'
+            url = endpoint['url']
+            status = endpoint['status']
+
+            if status == 'healthy':
+                icon = '✅'
+                style = self.style.SUCCESS
+            elif status == 'degraded':
+                icon = '⚠️'
+                style = self.style.WARNING
+            else:
+                icon = '❌'
+                style = self.style.ERROR
+
+            self.stdout.write(f'  {icon} {name}')
+
+            # Show both pattern and resolved URL for parametrized endpoints
+            if endpoint.get('has_parameters') and endpoint.get('url_pattern'):
+                self.stdout.write(f'     Pattern: {endpoint["url_pattern"]}')
+                self.stdout.write(f'     Resolved: {url}')
+            else:
+                self.stdout.write(f'     URL: {url}')
+
+            # Show status with status code
+            status_code = endpoint.get('status_code')
+            if status_code:
+                self.stdout.write(style(f'     Status: {status} ({status_code})'))
+            else:
+                self.stdout.write(style(f'     Status: {status}'))
+
+            if endpoint.get('response_time_ms'):
+                self.stdout.write(f'     Response time: {endpoint["response_time_ms"]:.2f}ms')
+
+            if endpoint.get('error'):
+                error_type = endpoint.get('error_type', 'general')
+                if error_type == 'database':
+                    self.stdout.write(self.style.WARNING(f'     ⚠️  DB Error (multi-db): {endpoint["error"]}'))
+                else:
+                    self.stdout.write(self.style.ERROR(f'     Error: {endpoint["error"]}'))
+
+            # Show reason for warnings (e.g., 404 explanations)
+            if endpoint.get('reason') and status == 'warning':
+                self.stdout.write(self.style.WARNING(f'     ⚠️  {endpoint["reason"]}'))
+
+            if endpoint.get('required_auth'):
+                self.stdout.write(f'     🔐 Required JWT authentication')
+
+            if endpoint.get('rate_limited'):
+                self.stdout.write(f'     ⏱️  Rate limited (429)')
+
+            self.stdout.write('')
+
+        # Timestamp
+        self.stdout.write(self.style.HTTP_INFO(f'🕐 Checked at: {data["timestamp"]}'))