django-cfg 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

django_cfg/apps/maintenance/views/sites.py

@@ -0,0 +1,338 @@
+"""
+Site management views.
+
+ViewSets for CloudflareSite and SiteGroup management.
+"""
+
+import logging
+from datetime import datetime
+
+from django.shortcuts import get_object_or_404
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from drf_spectacular.utils import (
+    extend_schema, extend_schema_view, OpenApiResponse, OpenApiParameter, OpenApiTypes
+)
+
+from ..models import CloudflareSite, SiteGroup
+from ..serializers import (
+    CloudflareSiteSerializer, CloudflareSiteCreateSerializer, CloudflareSiteListSerializer,
+    SiteGroupSerializer, SiteGroupCreateSerializer,
+    BulkMaintenanceActionSerializer, APIResponseSerializer
+)
+from ..services import MaintenanceManager
+from .base import MaintenancePermissionMixin, MaintenanceResponseMixin
+
+logger = logging.getLogger(__name__)
+
+
+@extend_schema_view(
+    list=extend_schema(
+        summary="List Cloudflare sites",
+        description="Get list of Cloudflare sites with filtering options",
+        parameters=[
+            OpenApiParameter('environment', OpenApiTypes.STR, description='Filter by environment'),
+            OpenApiParameter('project', OpenApiTypes.STR, description='Filter by project'),
+            OpenApiParameter('status', OpenApiTypes.STR, description='Filter by status'),
+            OpenApiParameter('maintenance_active', OpenApiTypes.BOOL, description='Filter by maintenance status'),
+            OpenApiParameter('search', OpenApiTypes.STR, description='Search in name and domain'),
+        ]
+    ),
+    create=extend_schema(
+        summary="Create Cloudflare site",
+        description="Create a new Cloudflare site configuration"
+    ),
+    retrieve=extend_schema(
+        summary="Get Cloudflare site",
+        description="Get detailed information about a specific Cloudflare site"
+    ),
+    update=extend_schema(
+        summary="Update Cloudflare site",
+        description="Update Cloudflare site configuration"
+    ),
+    destroy=extend_schema(
+        summary="Delete Cloudflare site",
+        description="Delete a Cloudflare site configuration"
+    )
+)
+class CloudflareSiteViewSet(MaintenancePermissionMixin, MaintenanceResponseMixin, viewsets.ModelViewSet):
+    """ViewSet for managing Cloudflare sites."""
+    
+    serializer_class = CloudflareSiteSerializer
+    lookup_field = 'id'
+    filterset_fields = ['environment', 'project', 'current_status', 'maintenance_active']
+    search_fields = ['name', 'domain', 'project']
+    ordering_fields = ['name', 'domain', 'created_at', 'last_maintenance_at']
+    ordering = ['-created_at']
+    
+    def get_queryset(self):
+        """Get queryset filtered by user permissions."""
+        return self.get_user_queryset(CloudflareSite)
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return CloudflareSiteCreateSerializer
+        elif self.action == 'list':
+            return CloudflareSiteListSerializer
+        elif self.action == 'bulk_action':
+            return BulkMaintenanceActionSerializer
+        return CloudflareSiteSerializer
+    
+    def perform_create(self, serializer):
+        """Set owner when creating site."""
+        serializer.save(owner=self.request.user)
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Enable maintenance mode",
+        description="Enable maintenance mode for this site",
+        request=None,
+        responses={
+            200: OpenApiResponse(response=APIResponseSerializer, description="Maintenance enabled successfully"),
+            400: OpenApiResponse(response=APIResponseSerializer, description="Bad request"),
+            500: OpenApiResponse(response=APIResponseSerializer, description="Internal server error")
+        }
+    )
+    def enable_maintenance(self, request, id=None):
+        """Enable maintenance mode for a site."""
+        try:
+            site = self.get_object()
+            reason = request.data.get('reason', 'Manual maintenance')
+            message = request.data.get('message', 'Site is under maintenance')
+            
+            # Use multi-site manager for consistency
+            manager = MaintenanceManager(self.request.user)
+            success = manager._enable_site_maintenance(site, reason, message)
+            
+            if success:
+                return self.success_response(f'Maintenance enabled for {site.domain}')
+            else:
+                return self.error_response('Failed to enable maintenance mode')
+                
+        except Exception as e:
+            return self.error_response(f"Enable maintenance error for site {id}: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Disable maintenance mode",
+        description="Disable maintenance mode for this site",
+        responses={
+            200: OpenApiResponse(response=APIResponseSerializer, description="Maintenance disabled successfully"),
+            500: OpenApiResponse(response=APIResponseSerializer, description="Internal server error")
+        }
+    )
+    def disable_maintenance(self, request, id=None):
+        """Disable maintenance mode for a site."""
+        try:
+            site = self.get_object()
+            
+            # Use multi-site manager for consistency
+            manager = MaintenanceManager(self.request.user)
+            success = manager._disable_site_maintenance(site)
+            
+            if success:
+                return self.success_response(f'Maintenance disabled for {site.domain}')
+            else:
+                return self.error_response('Failed to disable maintenance mode')
+                
+        except Exception as e:
+            return self.error_response(f"Disable maintenance error for site {id}: {e}")
+    
+    @action(detail=True, methods=['get'])
+    @extend_schema(
+        summary="Check site status",
+        description="Check current status of the site",
+        responses={
+            200: OpenApiResponse(response=APIResponseSerializer, description="Status checked successfully")
+        }
+    )
+    def check_status(self, request, id=None):
+        """Check current status of a site."""
+        try:
+            site = self.get_object()
+            
+            # Use multi-site manager for consistency
+            manager = MaintenanceManager(self.request.user)
+            site_status = manager._check_site_status(site)
+            
+            return self.success_response(
+                'Status checked successfully',
+                data={
+                    'site_id': site.id,
+                    'domain': site.domain,
+                    'status': site_status,
+                    'maintenance_active': site.maintenance_active,
+                    'last_check': datetime.now().isoformat()
+                }
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Status check error for site {id}: {e}")
+    
+    @action(detail=False, methods=['post'])
+    @extend_schema(
+        summary="Bulk maintenance actions",
+        description="Perform bulk maintenance actions on multiple sites",
+        request=BulkMaintenanceActionSerializer,
+        responses={
+            200: OpenApiResponse(response=APIResponseSerializer, description="Bulk action completed"),
+            400: OpenApiResponse(response=APIResponseSerializer, description="Invalid request data")
+        }
+    )
+    def bulk_action(self, request):
+        """Perform bulk maintenance actions."""
+        serializer = BulkMaintenanceActionSerializer(data=request.data)
+        if not serializer.is_valid():
+            return self.validation_error_response(serializer.errors)
+        
+        try:
+            action_type = serializer.validated_data['action']
+            site_ids = serializer.validated_data['site_ids']
+            dry_run = serializer.validated_data.get('dry_run', False)
+            
+            # Get sites (filtered by user permissions)
+            sites = self.get_queryset().filter(id__in=site_ids)
+            
+            if dry_run:
+                return self.success_response(
+                    f'Dry run: would {action_type} maintenance for {sites.count()} sites',
+                    data={
+                        'dry_run': True,
+                        'would_affect': [site.domain for site in sites]
+                    }
+                )
+            
+            # Use multi-site manager for bulk operations
+            manager = MaintenanceManager(self.request.user).sites(request.user).filter(id__in=site_ids)
+            
+            if action_type == 'enable':
+                reason = serializer.validated_data.get('reason', 'Bulk maintenance')
+                result = manager.enable_maintenance(
+                    reason=reason,
+                    user=request.user,
+                    message=serializer.validated_data.get('maintenance_message')
+                )
+            elif action_type == 'disable':
+                result = manager.disable_maintenance(user=request.user)
+            elif action_type == 'status_check':
+                result = manager.check_status()
+            else:
+                return self.error_response(f'Unknown action: {action_type}', status.HTTP_400_BAD_REQUEST)
+            
+            return self.success_response(f'Bulk {action_type} completed', data=result)
+            
+        except Exception as e:
+            return self.error_response(f"Bulk action error: {e}")
+
+
+@extend_schema_view(
+    list=extend_schema(
+        summary="List site groups",
+        description="Get list of site groups"
+    ),
+    create=extend_schema(
+        summary="Create site group",
+        description="Create a new site group"
+    )
+)
+class SiteGroupViewSet(MaintenancePermissionMixin, MaintenanceResponseMixin, viewsets.ModelViewSet):
+    """ViewSet for managing site groups."""
+    
+    serializer_class = SiteGroupSerializer
+    lookup_field = 'id'
+    
+    def get_queryset(self):
+        """Get queryset filtered by user permissions."""
+        return self.get_user_queryset(SiteGroup)
+    
+    def get_serializer_class(self):
+        """Return appropriate serializer based on action."""
+        if self.action == 'create':
+            return SiteGroupCreateSerializer
+        return SiteGroupSerializer
+    
+    def perform_create(self, serializer):
+        """Set owner when creating group."""
+        serializer.save(owner=self.request.user)
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Add sites to group",
+        description="Add sites to this group"
+    )
+    def add_sites(self, request, id=None):
+        """Add sites to group."""
+        try:
+            group = self.get_object()
+            site_ids = request.data.get('site_ids', [])
+            
+            # Get sites (filtered by user permissions)
+            sites = self.get_user_queryset(CloudflareSite).filter(id__in=site_ids)
+            group.sites.add(*sites)
+            
+            return self.success_response(f'Added {sites.count()} sites to group {group.name}')
+            
+        except Exception as e:
+            return self.error_response(f"Add sites to group error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Remove sites from group",
+        description="Remove sites from this group"
+    )
+    def remove_sites(self, request, id=None):
+        """Remove sites from group."""
+        try:
+            group = self.get_object()
+            site_ids = request.data.get('site_ids', [])
+            
+            # Get sites (filtered by user permissions)
+            sites = self.get_user_queryset(CloudflareSite).filter(id__in=site_ids)
+            group.sites.remove(*sites)
+            
+            return self.success_response(f'Removed {sites.count()} sites from group {group.name}')
+            
+        except Exception as e:
+            return self.error_response(f"Remove sites from group error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Enable maintenance for group",
+        description="Enable maintenance mode for all sites in this group"
+    )
+    def enable_maintenance(self, request, id=None):
+        """Enable maintenance for all sites in group."""
+        try:
+            group = self.get_object()
+            reason = request.data.get('reason', f'Group maintenance: {group.name}')
+            
+            result = group.enable_maintenance_for_all(request.user, reason)
+            
+            return self.success_response(
+                f'Group maintenance enabled for {group.name}',
+                data=result
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Group maintenance enable error: {e}")
+    
+    @action(detail=True, methods=['post'])
+    @extend_schema(
+        summary="Disable maintenance for group",
+        description="Disable maintenance mode for all sites in this group"
+    )
+    def disable_maintenance(self, request, id=None):
+        """Disable maintenance for all sites in group."""
+        try:
+            group = self.get_object()
+            
+            result = group.disable_maintenance_for_all()
+            
+            return self.success_response(
+                f'Group maintenance disabled for {group.name}',
+                data=result
+            )
+            
+        except Exception as e:
+            return self.error_response(f"Group maintenance disable error: {e}")

django_cfg/apps/urls.py

@@ -45,8 +45,12 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
         #     patterns.append(path('leads/', include('django_cfg.apps.leads.urls')))
         
         # Tasks app - enabled when knowbase or agents are enabled
-        if base_module.is_tasks_enabled():
+        if base_module.should_enable_tasks():
             patterns.append(path('tasks/', include('django_cfg.apps.tasks.urls')))
+        
+        # Maintenance app - multi-site maintenance mode with Cloudflare
+        if base_module.is_maintenance_enabled():
+            patterns.append(path('maintenance/', include('django_cfg.apps.maintenance.urls')))
             
     except Exception:
         # Fallback: include all URLs if config is not available

django_cfg/core/config.py

@@ -58,7 +58,7 @@ DEFAULT_APPS = [
     "django_extensions",
     "constance",
     "constance.backends.database",
-    "django_dramatiq",
+    # Note: django_dramatiq is added conditionally when tasks are enabled
     # Django CFG
     "django_cfg",
     "django_revolution",
@@ -270,6 +270,12 @@ class DjangoConfig(BaseModel):
         description="Application limits configuration (file uploads, requests, etc.)",
     )
 
+    # === Maintenance Mode Configuration ===
+    enable_maintenance: bool = Field(
+        default=False,
+        description="Enable django-cfg Maintenance application (multi-site maintenance mode with Cloudflare)",
+    )
+
     # === Middleware Configuration ===
     custom_middleware: List[str] = Field(
         default_factory=list,
@@ -518,6 +524,28 @@ class DjangoConfig(BaseModel):
             code=otp_code
         )
 
+    def should_enable_tasks(self) -> bool:
+        """
+        Determine if background tasks should be enabled.
+        
+        Tasks are enabled if:
+        1. Explicitly configured via tasks field
+        2. Knowledge base is enabled (requires background processing)
+        3. Agents are enabled (requires background processing)
+        
+        Returns:
+            True if tasks should be enabled, False otherwise
+        """
+        # Check if explicitly configured
+        if hasattr(self, 'tasks') and self.tasks and self.tasks.enabled:
+            return True
+        
+        # Check if features that require tasks are enabled
+        if self.enable_knowbase or self.enable_agents:
+            return True
+        
+        return False
+
     def get_installed_apps(self) -> List[str]:
         """
         Get complete list of installed Django apps.
@@ -547,9 +575,12 @@ class DjangoConfig(BaseModel):
             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")
         
-        # Auto-enable tasks if knowbase or agents are enabled
-        if self.enable_knowbase or self.enable_agents:
+        # Auto-enable tasks if needed
+        if self.should_enable_tasks():
+            apps.append("django_dramatiq")  # Add django_dramatiq first
             apps.append("django_cfg.apps.tasks")
 
         # Auto-detect dashboard apps from Unfold callback

django_cfg/core/generation.py

@@ -418,16 +418,21 @@ class SettingsGenerator:
 
             # Check for Tasks/Dramatiq configuration
             try:
-                from django_cfg.models.tasks import TaskConfig
-                from django_cfg.modules.django_tasks import generate_dramatiq_settings_from_config
-
-                # Auto-initialize TaskConfig if needed and generate settings
-                task_config = TaskConfig.auto_initialize_if_needed()
-                if task_config is not None:
-                    dramatiq_settings = generate_dramatiq_settings_from_config()
-                    if dramatiq_settings:
-                        settings.update(dramatiq_settings)
-                        integrations.append("dramatiq")
+                # Use the config's computed method to determine if tasks should be enabled
+                if config.should_enable_tasks():
+                    from django_cfg.models.tasks import TaskConfig
+                    from django_cfg.modules.django_tasks import generate_dramatiq_settings_from_config
+
+                    # Auto-initialize TaskConfig if needed and generate settings
+                    task_config = TaskConfig.auto_initialize_if_needed()
+                    if task_config is not None:
+                        dramatiq_settings = generate_dramatiq_settings_from_config()
+                        if dramatiq_settings:
+                            settings.update(dramatiq_settings)
+                            integrations.append("dramatiq")
+                            logger.info("✅ Dramatiq enabled (tasks/knowbase/agents required)")
+                else:
+                    logger.debug("⏭️  Dramatiq disabled (no tasks/knowbase/agents)")
                         
             except ImportError as e:
                 logger.warning(f"Failed to import django_tasks module: {e}")