django-cfg 1.3.11__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/apps/accounts/views/otp.py

@@ -42,7 +42,7 @@ class OTPViewSet(viewsets.GenericViewSet):
             500: OTPErrorResponseSerializer,
         },
     )
-    @action(detail=False, methods=["post"], url_path="request")
+    @action(detail=False, methods=["post"], url_path="request", url_name="request")
     def request_otp(self, request):
         """Request OTP code to email or phone."""
         serializer = OTPRequestSerializer(data=request.data)
@@ -111,7 +111,7 @@ class OTPViewSet(viewsets.GenericViewSet):
             410: OTPErrorResponseSerializer,
         },
     )
-    @action(detail=False, methods=["post"], url_path="verify")
+    @action(detail=False, methods=["post"], url_path="verify", url_name="verify")
     def verify_otp(self, request):
         """Verify OTP code and return JWT tokens."""
         serializer = OTPVerifySerializer(data=request.data)

django_cfg/apps/accounts/views/webhook.py

@@ -20,7 +20,7 @@ from drf_spectacular.utils import extend_schema, OpenApiParameter
 from drf_spectacular.types import OpenApiTypes
 from twilio.request_validator import RequestValidator
 
-from django_cfg.core.config import get_current_config
+from django_cfg.core.state import get_current_config
 from ..models import TwilioResponse, OTPSecret
 from ..serializers.webhook import TwilioWebhookSerializer
 

django_cfg/apps/agents/core/django_agent.py

@@ -14,7 +14,7 @@ from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.openrouter import OpenRouterProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 
-from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_logging import get_logger
 from django_cfg.modules.base import BaseCfgModule
 from .exceptions import ExecutionError, ConfigurationError
 

django_cfg/apps/api/commands/views.py

@@ -21,13 +21,13 @@ from django.utils import timezone
 logger = logging.getLogger(__name__)
 
 
-def is_superuser(user):
-    """Check if user is superuser."""
-    return user.is_authenticated and user.is_superuser
+def is_staff_user(user):
+    """Check if user is staff member."""
+    return user.is_authenticated and user.is_staff
 
 
 @require_http_methods(["GET"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def list_commands_view(request):
     """
     List all available Django management commands.
@@ -81,7 +81,7 @@ def list_commands_view(request):
 
 @csrf_exempt
 @require_http_methods(["POST"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def execute_command_view(request):
     """
     Execute a Django management command and stream output in real-time.
@@ -117,106 +117,89 @@ def execute_command_view(request):
                 "error": f"Command '{command_name}' not found",
                 "available_commands": list(available_commands.keys()),
             }, status=400)
-        
-        # Security check - block dangerous commands
-        dangerous_commands = [
-            "flush", "sqlflush", "dbshell", "shell", "shell_plus",
-            "reset_db", "migrate", "makemigrations", "loaddata"
-        ]
-        
-        if command_name in dangerous_commands:
+
+        # Security check - use same filtering as dashboard
+        from django_cfg.modules.django_unfold.callbacks.base import is_command_allowed
+
+        app_name = available_commands.get(command_name)
+        if not is_command_allowed(command_name, app_name):
             return JsonResponse({
-                "status": "error", 
-                "error": f"Command '{command_name}' is not allowed via API for security reasons",
-                "suggestion": "Use django_cfg management commands instead: show_config, test_email",
+                "status": "error",
+                "error": f"Command '{command_name}' is not allowed via web interface for security reasons",
+                "suggestion": "Only safe django_cfg commands and whitelisted utilities can be executed via web.",
             }, status=403)
         
         # Create streaming response generator
         def stream_command_execution():
             """Generator that yields command output in SSE format."""
             start_time = time.time()
-            
+
             # Send start event
             yield f"data: {json.dumps({'type': 'start', 'command': command_name, 'args': args})}\n\n"
-            
+
             try:
-                # Execute command with subprocess for real-time output
-                import subprocess
+                # Capture command output using StringIO
+                from io import StringIO
                 import sys
-                import os
-                
-                # Find Django project root and manage.py
-                from django.conf import settings
-                
-                # Try to find manage.py in project root
-                if hasattr(settings, 'BASE_DIR'):
-                    project_root = settings.BASE_DIR
-                    manage_py_path = os.path.join(project_root, 'manage.py')
-                else:
-                    # Fallback: search for manage.py
-                    current_dir = os.path.dirname(os.path.abspath(__file__))
-                    while current_dir != '/':
-                        manage_py_path = os.path.join(current_dir, 'manage.py')
-                        if os.path.exists(manage_py_path):
-                            project_root = current_dir
-                            break
-                        current_dir = os.path.dirname(current_dir)
-                    else:
-                        raise Exception("Could not find manage.py")
-                
-                # Build command
-                cmd = [sys.executable, manage_py_path, command_name] + args
-                
-                # Add options to command
-                for key, value in options.items():
-                    if key.startswith('--'):
-                        cmd.append(key)
-                        if value is not True:  # Boolean flags don't need values
-                            cmd.append(str(value))
-                    else:
-                        cmd.append(f"--{key}")
-                        if value is not True:
-                            cmd.append(str(value))
-                
-                # Start process
-                process = subprocess.Popen(
-                    cmd,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                    universal_newlines=True,
-                    bufsize=1,
-                    cwd=project_root
-                )
-                
+
+                # Create output buffer
+                output_buffer = StringIO()
+
+                # Redirect stdout/stderr to buffer
+                old_stdout = sys.stdout
+                old_stderr = sys.stderr
+                sys.stdout = output_buffer
+                sys.stderr = output_buffer
+
+                try:
+                    # Execute Django command directly using call_command
+                    call_command(command_name, *args, **options)
+                    return_code = 0
+                except Exception as e:
+                    # Command execution failed
+                    output_buffer.write(f"\nError: {str(e)}\n")
+                    return_code = 1
+                finally:
+                    # Restore stdout/stderr
+                    sys.stdout = old_stdout
+                    sys.stderr = old_stderr
+
+                # Get all output
+                output = output_buffer.getvalue()
+
                 # Stream output line by line
-                for line in iter(process.stdout.readline, ''):
-                    if line:
-                        line = line.rstrip('\n\r')
-                        yield f"data: {json.dumps({'type': 'output', 'line': line})}\n\n"
-                
-                # Wait for process to complete
-                return_code = process.wait()
+                if output:
+                    for line in output.split('\n'):
+                        if line.strip():
+                            yield f"data: {json.dumps({'type': 'output', 'line': line})}\n\n"
+
                 execution_time = time.time() - start_time
-                
+
                 # Send completion event
                 yield f"data: {json.dumps({'type': 'complete', 'return_code': return_code, 'execution_time': round(execution_time, 2)})}\n\n"
-                
+
                 # Log command execution
-                logger.info(
-                    f"Command executed: {command_name} {' '.join(args)} "
-                    f"by user {request.user.username} in {execution_time:.2f}s with exit code {return_code}"
-                )
-                
+                if return_code == 0:
+                    logger.info(
+                        f"Command executed: {command_name} {' '.join(args)} "
+                        f"by user {request.user.username} in {execution_time:.2f}s"
+                    )
+                else:
+                    logger.error(
+                        f"Command failed: {command_name} {' '.join(args)} "
+                        f"by user {request.user.username} in {execution_time:.2f}s"
+                    )
+
             except Exception as cmd_error:
                 execution_time = time.time() - start_time
-                
+
                 logger.error(
                     f"Command failed: {command_name} {' '.join(args)} "
                     f"by user {request.user.username}: {cmd_error}"
                 )
-                
+
                 # Send error event
-                yield f"data: {json.dumps({'type': 'error', 'error': str(cmd_error), 'execution_time': round(execution_time, 2)})}\n\n"
+                yield f"data: {json.dumps({'type': 'error', 'message': str(cmd_error), 'execution_time': round(execution_time, 2)})}\n\n"
         
         # Return streaming response
         response = StreamingHttpResponse(
@@ -243,7 +226,7 @@ def execute_command_view(request):
 
 
 @require_http_methods(["GET"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def command_help_view(request, command_name):
     """
     Get help information for a specific command.

django_cfg/apps/api/health/drf_views.py

@@ -0,0 +1,269 @@
+"""
+Django CFG Health Check DRF Views
+
+DRF browsable API views with Tailwind theme support.
+"""
+
+import os
+import time
+import psutil
+from datetime import datetime
+from typing import Dict, Any
+
+from django.conf import settings
+from django.db import connections
+from django.core.cache import cache
+from django.utils import timezone
+
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+
+from django_cfg.core.integration import get_current_version
+from .serializers import HealthCheckSerializer, QuickHealthSerializer
+
+
+class DRFHealthCheckView(APIView):
+    """
+    Django CFG comprehensive health check endpoint with DRF Browsable API.
+
+    Auto-discovers configuration from DjangoConfig and checks:
+    - All configured databases
+    - Cache connectivity
+    - System resources
+    - Configuration status
+
+    This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
+    """
+
+    permission_classes = [AllowAny]  # Public endpoint
+    serializer_class = HealthCheckSerializer  # For schema generation
+
+    def get(self, request):
+        """Return comprehensive health check data."""
+        # Get DjangoConfig instance
+        try:
+            config = getattr(settings, 'config', None)
+
+            health_data = {
+                "status": "healthy",
+                "timestamp": timezone.now(),
+                "service": config.project_name if config else "Django CFG",
+                "version": get_current_version(),
+                "checks": {}
+            }
+        except Exception:
+            health_data = {
+                "status": "healthy",
+                "timestamp": timezone.now(),
+                "service": "Django CFG",
+                "version": get_current_version(),
+                "checks": {}
+            }
+
+        # Database connectivity check
+        try:
+            db_status = self._check_databases()
+            health_data["checks"]["databases"] = db_status
+        except Exception as e:
+            health_data["checks"]["databases"] = {
+                "status": "error",
+                "error": str(e)
+            }
+            health_data["status"] = "unhealthy"
+
+        # Cache availability check
+        try:
+            cache_status = self._check_cache()
+            health_data["checks"]["cache"] = cache_status
+        except Exception as e:
+            health_data["checks"]["cache"] = {
+                "status": "error",
+                "error": str(e)
+            }
+            if health_data["status"] != "unhealthy":
+                health_data["status"] = "degraded"
+
+        # System resources check
+        try:
+            system_status = self._check_system_resources()
+            health_data["checks"]["system"] = system_status
+        except Exception as e:
+            health_data["checks"]["system"] = {
+                "status": "error",
+                "error": str(e)
+            }
+
+        # Environment info
+        health_data["environment"] = {
+            "debug": getattr(settings, 'DEBUG', False),
+            "django_env": os.getenv("DJANGO_ENV", "development"),
+            "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+        }
+
+        # Return appropriate HTTP status
+        http_status = status.HTTP_200_OK
+        if health_data["status"] == "unhealthy":
+            http_status = status.HTTP_503_SERVICE_UNAVAILABLE
+        elif health_data["status"] == "degraded":
+            http_status = status.HTTP_200_OK  # Still operational
+
+        return Response(health_data, status=http_status)
+
+    def _check_databases(self) -> Dict[str, Any]:
+        """Check all configured database connections."""
+        db_results = {}
+
+        # Get all configured databases
+        database_names = list(getattr(settings, 'DATABASES', {}).keys())
+
+        for db_name in database_names:
+            try:
+                start_time = time.time()
+                conn = connections[db_name]
+
+                with conn.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+                    cursor.fetchone()
+
+                response_time = (time.time() - start_time) * 1000  # ms
+
+                db_results[db_name] = {
+                    "status": "healthy",
+                    "response_time_ms": round(response_time, 2),
+                    "engine": conn.settings_dict.get("ENGINE", "unknown"),
+                }
+
+            except Exception as e:
+                db_results[db_name] = {
+                    "status": "error",
+                    "error": str(e)[:100],  # Truncate long errors
+                }
+
+        # Overall database status
+        all_healthy = all(
+            db["status"] == "healthy"
+            for db in db_results.values()
+        ) if db_results else False
+
+        return {
+            "status": "healthy" if all_healthy else "error",
+            "databases": db_results,
+            "total_databases": len(db_results),
+        }
+
+    def _check_cache(self) -> Dict[str, Any]:
+        """Check cache connectivity and performance."""
+        try:
+            test_key = "django_cfg_health_check"
+            test_value = f"test_{int(time.time())}"
+
+            # Test cache write
+            start_time = time.time()
+            cache.set(test_key, test_value, timeout=60)
+            write_time = (time.time() - start_time) * 1000
+
+            # Test cache read
+            start_time = time.time()
+            cached_value = cache.get(test_key)
+            read_time = (time.time() - start_time) * 1000
+
+            # Cleanup
+            cache.delete(test_key)
+
+            if cached_value == test_value:
+                return {
+                    "status": "healthy",
+                    "write_time_ms": round(write_time, 2),
+                    "read_time_ms": round(read_time, 2),
+                    "backend": getattr(settings, "CACHES", {}).get("default", {}).get("BACKEND", "unknown"),
+                }
+            else:
+                return {
+                    "status": "error",
+                    "error": "Cache read/write mismatch"
+                }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+
+    def _check_system_resources(self) -> Dict[str, Any]:
+        """Check system resource usage."""
+        try:
+            # CPU usage
+            cpu_percent = psutil.cpu_percent(interval=1)
+
+            # Memory usage
+            memory = psutil.virtual_memory()
+
+            # Disk usage
+            disk = psutil.disk_usage('/')
+
+            # System uptime
+            boot_time = datetime.fromtimestamp(psutil.boot_time())
+            uptime = datetime.now() - boot_time
+
+            return {
+                "status": "healthy",
+                "cpu": {
+                    "percent": cpu_percent,
+                    "count": psutil.cpu_count(),
+                },
+                "memory": {
+                    "percent": memory.percent,
+                    "used_gb": round(memory.used / (1024**3), 2),
+                    "total_gb": round(memory.total / (1024**3), 2),
+                },
+                "disk": {
+                    "percent": round((disk.used / disk.total) * 100, 2),
+                    "used_gb": round(disk.used / (1024**3), 2),
+                    "total_gb": round(disk.total / (1024**3), 2),
+                },
+                "uptime": {
+                    "days": uptime.days,
+                    "hours": uptime.seconds // 3600,
+                    "boot_time": boot_time.isoformat(),
+                },
+                "process_count": len(psutil.pids()),
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+
+
+class DRFQuickHealthView(APIView):
+    """
+    Quick health check for load balancers with DRF Browsable API.
+
+    This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
+    """
+
+    permission_classes = [AllowAny]  # Public endpoint
+    serializer_class = QuickHealthSerializer  # For schema generation
+
+    def get(self, request):
+        """Return minimal health status."""
+        try:
+            # Just check main database
+            conn = connections["default"]
+            with conn.cursor() as cursor:
+                cursor.execute("SELECT 1")
+
+            return Response({
+                "status": "ok",
+                "timestamp": timezone.now(),
+            })
+
+        except Exception as e:
+            return Response({
+                "status": "error",
+                "error": str(e),
+                "timestamp": timezone.now(),
+            }, status=status.HTTP_503_SERVICE_UNAVAILABLE)

django_cfg/apps/api/health/serializers.py

@@ -0,0 +1,45 @@
+"""
+Django CFG Health Check Serializers
+
+DRF serializers for health check endpoints with Tailwind browsable API.
+"""
+
+from rest_framework import serializers
+
+
+class HealthCheckSerializer(serializers.Serializer):
+    """Serializer for health check response."""
+
+    status = serializers.CharField(
+        help_text="Overall health status: healthy, degraded, or unhealthy"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Timestamp of the health check"
+    )
+    service = serializers.CharField(
+        help_text="Service name"
+    )
+    version = serializers.CharField(
+        help_text="Django-CFG version"
+    )
+    checks = serializers.DictField(
+        help_text="Detailed health checks for databases, cache, and system"
+    )
+    environment = serializers.DictField(
+        help_text="Environment information"
+    )
+
+
+class QuickHealthSerializer(serializers.Serializer):
+    """Serializer for quick health check response."""
+
+    status = serializers.CharField(
+        help_text="Quick health status: ok or error"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Timestamp of the health check"
+    )
+    error = serializers.CharField(
+        required=False,
+        help_text="Error message if health check failed"
+    )

django_cfg/apps/api/health/urls.py

@@ -3,9 +3,14 @@ Django CFG Health Check URLs.
 """
 
 from django.urls import path
-from . import views
+from . import views, drf_views
 
 urlpatterns = [
+    # Original JSON endpoints
     path('', views.HealthCheckView.as_view(), name='django_cfg_health'),
     path('quick/', views.QuickHealthView.as_view(), name='django_cfg_quick_health'),
+
+    # DRF Browsable API endpoints with Tailwind theme
+    path('drf/', drf_views.DRFHealthCheckView.as_view(), name='django_cfg_drf_health'),
+    path('drf/quick/', drf_views.DRFQuickHealthView.as_view(), name='django_cfg_drf_quick_health'),
 ]

django_cfg/apps/knowbase/admin/actions/__init__.py

@@ -0,0 +1,13 @@
+"""
+Shared admin actions for knowbase.
+
+Provides reusable actions for admin interfaces.
+"""
+
+from .visibility_actions import VisibilityActions, mark_as_public, mark_as_private
+
+__all__ = [
+    'VisibilityActions',
+    'mark_as_public',
+    'mark_as_private',
+]

django_cfg/apps/knowbase/admin/actions/visibility_actions.py

@@ -0,0 +1,56 @@
+"""
+Shared admin actions for visibility management.
+
+Provides consistent actions for toggling public/private status across
+all knowbase admin interfaces.
+"""
+
+from django.contrib import messages
+from django_cfg.modules.django_admin import action, ActionVariant
+
+
+class VisibilityActions:
+    """Shared actions for visibility management."""
+
+    @staticmethod
+    @action(description="Mark as public", variant=ActionVariant.SUCCESS)
+    def mark_as_public(modeladmin, request, queryset):
+        """
+        Mark selected items as public.
+
+        Args:
+            modeladmin: Admin class instance
+            request: HTTP request object
+            queryset: Selected items queryset
+
+        Returns:
+            None (displays success message)
+        """
+        updated = queryset.update(is_public=True)
+        messages.success(request, f"Marked {updated} item(s) as public.")
+
+    @staticmethod
+    @action(description="Mark as private", variant=ActionVariant.WARNING)
+    def mark_as_private(modeladmin, request, queryset):
+        """
+        Mark selected items as private.
+
+        Args:
+            modeladmin: Admin class instance
+            request: HTTP request object
+            queryset: Selected items queryset
+
+        Returns:
+            None (displays warning message)
+        """
+        updated = queryset.update(is_public=False)
+        messages.warning(request, f"Marked {updated} item(s) as private.")
+
+
+# Aliases for backward compatibility and consistency
+# DocumentAdmin uses "mark_as_*" while DocumentCategoryAdmin used "make_*"
+# These aliases ensure both naming conventions work
+mark_as_public = VisibilityActions.mark_as_public
+mark_as_private = VisibilityActions.mark_as_private
+make_public = VisibilityActions.mark_as_public
+make_private = VisibilityActions.mark_as_private