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

django_cfg/apps/maintenance/management/commands/maintenance.py

@@ -1,375 +1,261 @@
 """
-Multi-site maintenance management command.
+Simplified maintenance management command.
 
-Provides CLI interface for managing maintenance mode across multiple sites
-with ORM-like syntax and bulk operations.
+Single command instead of 2+ complex commands.
+Usage: python manage.py maintenance enable/disable/status/sync domain.com
 """
 
-import asyncio
 from django.core.management.base import BaseCommand, CommandError
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-from typing import List, Optional
+from django.db import transaction
+from typing import Any, Optional
 
-from django_cfg.apps.maintenance.services import MaintenanceManager
-from django_cfg.apps.maintenance.models import CloudflareSite
-
-User = get_user_model()
+from ...models import CloudflareSite, MaintenanceLog
+from ...services import MaintenanceService
 
 
 class Command(BaseCommand):
-    """
-    Multi-site maintenance management command.
-    
-    Examples:
-        # Enable maintenance for all production sites
-        python manage.py maintenance enable --environment production
-        
-        # Disable maintenance for specific project
-        python manage.py maintenance disable --project myproject
-        
-        # Check status of all sites
-        python manage.py maintenance status
-        
-        # Enable maintenance with custom message
-        python manage.py maintenance enable --domain example.com --message "Upgrading database"
-        
-        # Bulk operations with filters
-        python manage.py maintenance enable --tag critical --reason "Security patch"
-    """
+    """Simple maintenance management command."""
     
-    help = 'Manage maintenance mode for multiple Cloudflare sites'
+    help = 'Manage maintenance mode for Cloudflare sites'
     
-    def add_arguments(self, parser):
+    def add_arguments(self, parser) -> None:
         """Add command arguments."""
-        # Main action
         parser.add_argument(
             'action',
-            choices=['enable', 'disable', 'status', 'list', 'discover'],
+            choices=['enable', 'disable', 'status', 'sync', 'list'],
             help='Action to perform'
         )
         
-        # Site filters
-        parser.add_argument(
-            '--domain',
-            help='Specific domain to target'
-        )
-        parser.add_argument(
-            '--environment',
-            choices=['production', 'staging', 'development', 'testing'],
-            help='Filter by environment'
-        )
         parser.add_argument(
-            '--project',
-            help='Filter by project name'
-        )
-        parser.add_argument(
-            '--tag',
-            help='Filter by tag'
-        )
-        parser.add_argument(
-            '--owner',
-            help='Filter by owner username'
+            'domain',
+            nargs='?',
+            help='Domain to operate on (required for enable/disable/status/sync)'
         )
         
-        # Maintenance options
         parser.add_argument(
             '--reason',
-            default='Manual maintenance via CLI',
-            help='Reason for maintenance'
-        )
-        parser.add_argument(
-            '--message',
-            help='Custom maintenance message'
+            default='Maintenance via CLI',
+            help='Reason for enabling maintenance (default: "Maintenance via CLI")'
         )
         
-        # Operation options
-        parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be done without actually doing it'
-        )
         parser.add_argument(
             '--force',
             action='store_true',
-            help='Force operation without confirmation'
+            help='Skip confirmation prompts'
         )
         
-        # Discovery options
-        parser.add_argument(
-            '--api-token',
-            help='Cloudflare API token for site discovery'
-        )
-        
-        # Output options
-        parser.add_argument(
-            '--format',
-            choices=['table', 'json', 'csv'],
-            default='table',
-            help='Output format'
-        )
         parser.add_argument(
             '--verbose',
             action='store_true',
-            help='Verbose output'
+            help='Show detailed output'
         )
     
-    def handle(self, *args, **options):
-        """Handle command execution."""
-        self.options = options
-        self.verbosity = options.get('verbosity', 1)
+    def handle(self, *args: Any, **options: Any) -> None:
+        """Handle the command."""
+        action = options['action']
+        domain = options['domain']
+        reason = options['reason']
+        force = options['force']
+        verbose = options['verbose']
+        
+        # Validate arguments
+        if action in ['enable', 'disable', 'status', 'sync'] and not domain:
+            raise CommandError(f"Domain is required for '{action}' action")
         
         try:
-            # Get user for operations
-            user = self._get_user(options.get('owner'))
-            
-            # Execute action
-            if options['action'] == 'enable':
-                asyncio.run(self._handle_enable(user))
-            elif options['action'] == 'disable':
-                asyncio.run(self._handle_disable(user))
-            elif options['action'] == 'status':
-                asyncio.run(self._handle_status(user))
-            elif options['action'] == 'list':
-                self._handle_list(user)
-            elif options['action'] == 'discover':
-                asyncio.run(self._handle_discover(user))
-            
+            if action == 'list':
+                self._handle_list(verbose)
+            elif action == 'status':
+                self._handle_status(domain, verbose)
+            elif action == 'enable':
+                self._handle_enable(domain, reason, force, verbose)
+            elif action == 'disable':
+                self._handle_disable(domain, force, verbose)
+            elif action == 'sync':
+                self._handle_sync(domain, verbose)
+                
+        except CloudflareSite.DoesNotExist:
+            raise CommandError(f"Site '{domain}' not found. Use 'list' action to see available sites.")
         except Exception as e:
-            raise CommandError(f"Command failed: {str(e)}")
+            raise CommandError(f"Operation failed: {str(e)}")
     
-    def _get_user(self, username: Optional[str] = None) -> User:
-        """Get user for operations."""
-        if username:
-            try:
-                return User.objects.get(username=username)
-            except User.DoesNotExist:
-                raise CommandError(f"User '{username}' not found")
-        else:
-            # Use first superuser if no user specified
-            superuser = User.objects.filter(is_superuser=True).first()
-            if not superuser:
-                raise CommandError("No superuser found. Please specify --owner or create a superuser.")
-            return superuser
-    
-    def _get_sites_queryset(self, user: User):
-        """Get filtered sites queryset based on command options."""
-        sites = multi_site_manager.sites(user)
-        
-        # Apply filters
-        if self.options.get('domain'):
-            sites = sites.filter(domain=self.options['domain'])
+    def _handle_list(self, verbose: bool) -> None:
+        """List all sites."""
+        sites = CloudflareSite.objects.all().order_by('name')
         
-        if self.options.get('environment'):
-            sites = sites.filter(environment=self.options['environment'])
-        
-        if self.options.get('project'):
-            sites = sites.filter(project=self.options['project'])
-        
-        if self.options.get('tag'):
-            sites = sites.with_tag(self.options['tag'])
-        
-        return sites
-    
-    async def _handle_enable(self, user: User):
-        """Handle enable maintenance action."""
-        sites = self._get_sites_queryset(user)
-        
-        if sites.count() == 0:
-            self.stdout.write(self.style.WARNING("No sites match the specified filters."))
+        if not sites:
+            self.stdout.write(self.style.WARNING("No sites configured"))
             return
         
-        # Show what will be affected
-        self.stdout.write(f"Will enable maintenance for {sites.count()} sites:")
-        for site in sites.all()[:10]:  # Show first 10
-            self.stdout.write(f"  - {site.domain} ({site.environment})")
+        self.stdout.write(self.style.SUCCESS(f"Found {sites.count()} sites:"))
+        self.stdout.write("")
         
-        if sites.count() > 10:
-            self.stdout.write(f"  ... and {sites.count() - 10} more sites")
-        
-        # Confirm unless forced
-        if not self.options.get('force') and not self.options.get('dry_run'):
-            confirm = input("\nProceed? (y/N): ")
-            if confirm.lower() != 'y':
-                self.stdout.write("Operation cancelled.")
-                return
-        
-        # Execute operation
-        result = await sites.enable_maintenance(
-            reason=self.options['reason'],
-            message=self.options.get('message'),
-            user=user,
-            dry_run=self.options.get('dry_run', False)
-        )
-        
-        # Display results
-        self._display_bulk_result("Enable Maintenance", result)
+        for site in sites:
+            status_style = self.style.WARNING if site.maintenance_active else self.style.SUCCESS
+            status_text = "🔧 MAINTENANCE" if site.maintenance_active else "🟢 ACTIVE"
+            
+            self.stdout.write(f"  {status_style(status_text)} {site.name} ({site.domain})")
+            
+            if verbose:
+                self.stdout.write(f"    Zone ID: {site.zone_id}")
+                self.stdout.write(f"    Account ID: {site.account_id}")
+                self.stdout.write(f"    Created: {site.created_at.strftime('%Y-%m-%d %H:%M')}")
+                if site.last_maintenance_at:
+                    self.stdout.write(f"    Last Maintenance: {site.last_maintenance_at.strftime('%Y-%m-%d %H:%M')}")
+                
+                # Show recent logs
+                recent_logs = site.logs.all()[:3]
+                if recent_logs:
+                    self.stdout.write("    Recent logs:")
+                    for log in recent_logs:
+                        status_emoji = {
+                            MaintenanceLog.Status.SUCCESS: "✅",
+                            MaintenanceLog.Status.FAILED: "❌",
+                            MaintenanceLog.Status.PENDING: "⏳"
+                        }.get(log.status, "❓")
+                        
+                        self.stdout.write(f"      {status_emoji} {log.get_action_display()} - {log.created_at.strftime('%m-%d %H:%M')}")
+                
+                self.stdout.write("")
     
-    async def _handle_disable(self, user: User):
-        """Handle disable maintenance action."""
-        sites = self._get_sites_queryset(user).in_maintenance()
+    def _handle_status(self, domain: str, verbose: bool) -> None:
+        """Show status for specific site."""
+        site = CloudflareSite.objects.get(domain=domain)
         
-        if sites.count() == 0:
-            self.stdout.write(self.style.WARNING("No sites in maintenance match the specified filters."))
-            return
-        
-        # Show what will be affected
-        self.stdout.write(f"Will disable maintenance for {sites.count()} sites:")
-        for site in sites.all()[:10]:
-            duration = site.maintenance_duration
-            duration_str = f" ({duration})" if duration else ""
-            self.stdout.write(f"  - {site.domain}{duration_str}")
+        status_style = self.style.WARNING if site.maintenance_active else self.style.SUCCESS
+        status_text = "🔧 MAINTENANCE ACTIVE" if site.maintenance_active else "🟢 ACTIVE"
         
-        if sites.count() > 10:
-            self.stdout.write(f"  ... and {sites.count() - 10} more sites")
+        self.stdout.write(f"Status for {site.name} ({domain}):")
+        self.stdout.write(f"  {status_style(status_text)}")
         
-        # Confirm unless forced
-        if not self.options.get('force') and not self.options.get('dry_run'):
-            confirm = input("\nProceed? (y/N): ")
-            if confirm.lower() != 'y':
-                self.stdout.write("Operation cancelled.")
-                return
-        
-        # Execute operation
-        result = await sites.disable_maintenance(
-            user=user,
-            dry_run=self.options.get('dry_run', False)
-        )
-        
-        # Display results
-        self._display_bulk_result("Disable Maintenance", result)
+        if verbose:
+            self.stdout.write(f"  Zone ID: {site.zone_id}")
+            self.stdout.write(f"  Account ID: {site.account_id}")
+            self.stdout.write(f"  Created: {site.created_at.strftime('%Y-%m-%d %H:%M')}")
+            self.stdout.write(f"  Updated: {site.updated_at.strftime('%Y-%m-%d %H:%M')}")
+            
+            if site.last_maintenance_at:
+                self.stdout.write(f"  Last Maintenance: {site.last_maintenance_at.strftime('%Y-%m-%d %H:%M')}")
+            
+            # Show recent logs
+            recent_logs = site.logs.all()[:5]
+            if recent_logs:
+                self.stdout.write("  Recent activity:")
+                for log in recent_logs:
+                    status_emoji = {
+                        MaintenanceLog.Status.SUCCESS: "✅",
+                        MaintenanceLog.Status.FAILED: "❌",
+                        MaintenanceLog.Status.PENDING: "⏳"
+                    }.get(log.status, "❓")
+                    
+                    duration_text = f" ({log.duration_seconds}s)" if log.duration_seconds else ""
+                    self.stdout.write(f"    {status_emoji} {log.get_action_display()}{duration_text} - {log.created_at.strftime('%Y-%m-%d %H:%M')}")
+                    
+                    if log.error_message and verbose:
+                        self.stdout.write(f"      Error: {log.error_message[:100]}")
     
-    async def _handle_status(self, user: User):
-        """Handle status check action."""
-        sites = self._get_sites_queryset(user)
+    def _handle_enable(self, domain: str, reason: str, force: bool, verbose: bool) -> None:
+        """Enable maintenance for site."""
+        site = CloudflareSite.objects.get(domain=domain)
         
-        if sites.count() == 0:
-            self.stdout.write(self.style.WARNING("No sites match the specified filters."))
+        if site.maintenance_active:
+            self.stdout.write(self.style.WARNING(f"Maintenance is already active for {domain}"))
             return
         
-        self.stdout.write(f"Checking status of {sites.count()} sites...")
-        
-        result = await sites.check_status()
-        
-        # Display status summary
-        self.stdout.write(self.style.SUCCESS(f"\n✅ Status check completed for {result['total']} sites"))
+        # Confirmation
+        if not force:
+            confirm = input(f"Enable maintenance for {site.name} ({domain})? [y/N]: ")
+            if confirm.lower() not in ['y', 'yes']:
+                self.stdout.write("Cancelled")
+                return
         
-        status_summary = result.get('status_summary', {})
-        if status_summary:
-            self.stdout.write("\nStatus Summary:")
-            for status, count in status_summary.items():
-                self.stdout.write(f"  {status.title()}: {count} sites")
+        self.stdout.write(f"Enabling maintenance for {domain}...")
+        if verbose:
+            self.stdout.write(f"Reason: {reason}")
         
-        # Display individual site status if verbose
-        if self.options.get('verbose'):
-            self.stdout.write("\nIndividual Site Status:")
-            for site_info in result.get('sites', []):
-                status_icon = {
-                    'active': '🟢',
-                    'maintenance': '🔧',
-                    'offline': '🔴',
-                    'unknown': '❓',
-                    'error': '❌'
-                }.get(site_info['status'], '❓')
+        try:
+            with transaction.atomic():
+                service = MaintenanceService(site)
+                log_entry = service.enable_maintenance(reason)
+            
+            if log_entry.status == MaintenanceLog.Status.SUCCESS:
+                duration_text = f" ({log_entry.duration_seconds}s)" if log_entry.duration_seconds else ""
+                self.stdout.write(self.style.SUCCESS(f"✅ Maintenance enabled successfully{duration_text}"))
                 
-                self.stdout.write(
-                    f"  {status_icon} {site_info['domain']}: {site_info['status']}"
-                )
+                if verbose and log_entry.cloudflare_response:
+                    self.stdout.write("Cloudflare response:")
+                    import json
+                    self.stdout.write(json.dumps(log_entry.cloudflare_response, indent=2))
+            else:
+                self.stdout.write(self.style.ERROR(f"❌ Failed to enable maintenance: {log_entry.error_message}"))
+                
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Error: {str(e)}"))
     
-    def _handle_list(self, user: User):
-        """Handle list sites action."""
-        sites = self._get_sites_queryset(user)
+    def _handle_disable(self, domain: str, force: bool, verbose: bool) -> None:
+        """Disable maintenance for site."""
+        site = CloudflareSite.objects.get(domain=domain)
         
-        if sites.count() == 0:
-            self.stdout.write(self.style.WARNING("No sites match the specified filters."))
+        if not site.maintenance_active:
+            self.stdout.write(self.style.WARNING(f"Maintenance is not active for {domain}"))
             return
         
-        # Display sites in table format
-        self.stdout.write(f"\nFound {sites.count()} sites:\n")
+        # Confirmation
+        if not force:
+            confirm = input(f"Disable maintenance for {site.name} ({domain})? [y/N]: ")
+            if confirm.lower() not in ['y', 'yes']:
+                self.stdout.write("Cancelled")
+                return
         
-        # Header
-        self.stdout.write(
-            f"{'Domain':<30} {'Environment':<12} {'Status':<12} {'Project':<20} {'Maintenance':<12}"
-        )
-        self.stdout.write("-" * 86)
+        self.stdout.write(f"Disabling maintenance for {domain}...")
         
-        # Sites
-        for site in sites.all():
-            maintenance_status = "Active" if site.maintenance_active else "Inactive"
+        try:
+            with transaction.atomic():
+                service = MaintenanceService(site)
+                log_entry = service.disable_maintenance()
             
-            self.stdout.write(
-                f"{site.domain:<30} {site.environment:<12} {site.current_status:<12} "
-                f"{(site.project or 'None'):<20} {maintenance_status:<12}"
-            )
+            if log_entry.status == MaintenanceLog.Status.SUCCESS:
+                duration_text = f" ({log_entry.duration_seconds}s)" if log_entry.duration_seconds else ""
+                self.stdout.write(self.style.SUCCESS(f"✅ Maintenance disabled successfully{duration_text}"))
+                
+                if verbose and log_entry.cloudflare_response:
+                    self.stdout.write("Cloudflare response:")
+                    import json
+                    self.stdout.write(json.dumps(log_entry.cloudflare_response, indent=2))
+            else:
+                self.stdout.write(self.style.ERROR(f"❌ Failed to disable maintenance: {log_entry.error_message}"))
+                
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Error: {str(e)}"))
     
-    async def _handle_discover(self, user: User):
-        """Handle site discovery action."""
-        api_token = self.options.get('api_token')
-        if not api_token:
-            raise CommandError("--api-token is required for site discovery")
+    def _handle_sync(self, domain: str, verbose: bool) -> None:
+        """Sync site from Cloudflare."""
+        site = CloudflareSite.objects.get(domain=domain)
         
-        self.stdout.write("Discovering Cloudflare sites...")
+        self.stdout.write(f"Syncing {domain} from Cloudflare...")
         
         try:
-            discovered_sites = await multi_site_manager.discover_sites(api_token, user)
+            service = MaintenanceService(site)
+            log_entry = service.sync_site_from_cloudflare()
             
-            if discovered_sites:
-                self.stdout.write(
-                    self.style.SUCCESS(f"✅ Discovered {len(discovered_sites)} new sites:")
-                )
-                for site in discovered_sites:
-                    self.stdout.write(f"  - {site.domain} ({site.environment})")
+            if log_entry.status == MaintenanceLog.Status.SUCCESS:
+                duration_text = f" ({log_entry.duration_seconds}s)" if log_entry.duration_seconds else ""
+                self.stdout.write(self.style.SUCCESS(f"✅ Sync completed successfully{duration_text}"))
+                
+                if verbose and log_entry.cloudflare_response:
+                    response = log_entry.cloudflare_response
+                    if 'updated_fields' in response and response['updated_fields']:
+                        self.stdout.write(f"Updated fields: {', '.join(response['updated_fields'])}")
+                    
+                    maintenance_status = response.get('maintenance_active', 'unknown')
+                    self.stdout.write(f"Current maintenance status: {maintenance_status}")
+                    
+                    if verbose:
+                        import json
+                        self.stdout.write("Full Cloudflare response:")
+                        self.stdout.write(json.dumps(response, indent=2))
             else:
-                self.stdout.write(self.style.WARNING("No new sites discovered."))
+                self.stdout.write(self.style.ERROR(f"❌ Sync failed: {log_entry.error_message}"))
                 
         except Exception as e:
-            raise CommandError(f"Site discovery failed: {str(e)}")
-    
-    def _display_bulk_result(self, operation: str, result):
-        """Display bulk operation results."""
-        if result.dry_run:
-            self.stdout.write(self.style.WARNING(f"\n🔍 DRY RUN - {operation}"))
-            self.stdout.write(f"Would affect {len(result.would_affect)} sites:")
-            for domain in result.would_affect[:10]:
-                self.stdout.write(f"  - {domain}")
-            if len(result.would_affect) > 10:
-                self.stdout.write(f"  ... and {len(result.would_affect) - 10} more")
-            return
-        
-        # Real operation results
-        self.stdout.write(f"\n{operation} Results:")
-        self.stdout.write(f"Total sites: {result.total}")
-        
-        if result.successful:
-            self.stdout.write(
-                self.style.SUCCESS(f"✅ Successful: {len(result.successful)} sites")
-            )
-            if self.options.get('verbose'):
-                for domain in result.successful:
-                    self.stdout.write(f"  ✅ {domain}")
-        
-        if result.failed:
-            self.stdout.write(
-                self.style.ERROR(f"❌ Failed: {len(result.failed)} sites")
-            )
-            for failure in result.failed:
-                self.stdout.write(f"  ❌ {failure['site']}: {failure['reason']}")
-        
-        if result.skipped:
-            self.stdout.write(
-                self.style.WARNING(f"⏭️  Skipped: {len(result.skipped)} sites")
-            )
-            if self.options.get('verbose'):
-                for skip in result.skipped:
-                    self.stdout.write(f"  ⏭️  {skip['site']}: {skip['reason']}")
-        
-        # Success rate
-        success_rate = result.success_rate
-        if success_rate == 100.0:
-            style = self.style.SUCCESS
-        elif success_rate >= 80.0:
-            style = self.style.WARNING
-        else:
-            style = self.style.ERROR
-        
-        self.stdout.write(style(f"\nSuccess rate: {success_rate:.1f}%"))
+            self.stdout.write(self.style.ERROR(f"❌ Error: {str(e)}"))