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

django_cfg/apps/maintenance/services/sync_command_service.py

@@ -1,330 +0,0 @@
-"""
-Cloudflare synchronization command service.
-
-Handles the business logic for synchronizing sites with Cloudflare zones.
-Extracted from management command for better testability and reusability.
-"""
-
-import logging
-from typing import Dict, List, Any, Optional
-from django.db import transaction
-from django.utils import timezone
-from django.contrib.auth import get_user_model
-
-from .site_sync import SiteSyncService
-from ..models import CloudflareSite
-from django_cfg.models.cloudflare import CloudflareConfig
-
-User = get_user_model()
-logger = logging.getLogger(__name__)
-
-
-class SyncCommandService:
-    """
-    Service for handling Cloudflare synchronization command logic.
-    
-    Provides clean separation between command interface and business logic.
-    """
-    
-    def __init__(self, config: CloudflareConfig):
-        """Initialize sync command service."""
-        self.config = config
-        self.sync_service = SiteSyncService(config)
-        
-    def sync_user_sites_command(
-        self,
-        user: User,
-        dry_run: bool = False,
-        force_update: bool = False,
-        environment: str = 'production',
-        project: str = '',
-        tags: List[str] = None,
-        verbose: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Execute site synchronization with command-specific logic.
-        
-        Args:
-            user: User to sync sites for
-            dry_run: If True, only show what would be changed
-            force_update: If True, update existing sites
-            environment: Default environment for new sites
-            project: Default project for new sites
-            tags: Default tags for new sites
-            verbose: Enable verbose logging
-            
-        Returns:
-            Dict with detailed sync results
-        """
-        logger.info(f"Starting command sync for user {user.username}")
-        
-        if verbose:
-            logging.getLogger().setLevel(logging.DEBUG)
-        
-        try:
-            # Use the core sync service
-            core_stats = self.sync_service.sync_user_sites(
-                user=user,
-                dry_run=dry_run,
-                force_update=force_update,
-                environment=environment,
-                project=project,
-                tags=tags or []
-            )
-            
-            # Transform results for command output
-            command_stats = self._transform_stats_for_command(core_stats)
-            
-            logger.info(f"Command sync completed: {command_stats}")
-            return {
-                'success': True,
-                'stats': command_stats,
-                'core_stats': core_stats,
-                'dry_run': dry_run
-            }
-            
-        except Exception as e:
-            logger.error(f"Command sync failed: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'stats': {'created': 0, 'updated': 0, 'skipped': 0, 'errors': 1}
-            }
-    
-    def get_user_by_identifier(self, user_identifier: str) -> User:
-        """
-        Get user by username or email.
-        
-        Args:
-            user_identifier: Username or email address
-            
-        Returns:
-            User instance
-            
-        Raises:
-            User.DoesNotExist: If user not found
-        """
-        try:
-            # Try by email first
-            if '@' in user_identifier:
-                return User.objects.get(email=user_identifier)
-            else:
-                return User.objects.get(username=user_identifier)
-        except User.DoesNotExist:
-            raise User.DoesNotExist(f"User not found: {user_identifier}")
-    
-    def get_api_token_for_user(self, user: User, provided_token: Optional[str] = None) -> str:
-        """
-        Get Cloudflare API token for user.
-        
-        Args:
-            user: User to get token for
-            provided_token: Explicitly provided token
-            
-        Returns:
-            API token string
-            
-        Raises:
-            ValueError: If no token available
-        """
-        if provided_token:
-            return provided_token
-        
-        # Try to get from user's existing sites
-        existing_site = CloudflareSite.objects.filter(owner=user).first()
-        if existing_site and existing_site.api_token:
-            return existing_site.api_token
-        
-        raise ValueError(
-            "No API token available. Provide --api-token or ensure user has existing sites with tokens."
-        )
-    
-    def validate_sync_parameters(
-        self,
-        user_identifier: str,
-        api_token: Optional[str] = None,
-        environment: str = 'production',
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Validate synchronization parameters.
-        
-        Args:
-            user_identifier: Username or email
-            api_token: Cloudflare API token
-            environment: Target environment
-            **kwargs: Additional parameters
-            
-        Returns:
-            Dict with validation results
-        """
-        validation_result = {
-            'valid': True,
-            'errors': [],
-            'warnings': []
-        }
-        
-        # Validate user
-        try:
-            user = self.get_user_by_identifier(user_identifier)
-            validation_result['user'] = user
-        except User.DoesNotExist as e:
-            validation_result['valid'] = False
-            validation_result['errors'].append(str(e))
-            return validation_result
-        
-        # Validate API token
-        try:
-            token = self.get_api_token_for_user(user, api_token)
-            validation_result['api_token'] = token
-        except ValueError as e:
-            validation_result['valid'] = False
-            validation_result['errors'].append(str(e))
-        
-        # Validate environment
-        valid_environments = ['production', 'staging', 'development', 'testing']
-        if environment not in valid_environments:
-            validation_result['valid'] = False
-            validation_result['errors'].append(
-                f"Invalid environment '{environment}'. Must be one of: {valid_environments}"
-            )
-        
-        # Check if user has existing sites
-        existing_sites_count = CloudflareSite.objects.filter(owner=user).count()
-        if existing_sites_count == 0:
-            validation_result['warnings'].append(
-                f"User {user.username} has no existing sites. All zones will be created as new sites."
-            )
-        else:
-            validation_result['warnings'].append(
-                f"User {user.username} has {existing_sites_count} existing sites."
-            )
-        
-        return validation_result
-    
-    def get_sync_preview(
-        self,
-        user: User,
-        verbose: bool = False
-    ) -> Dict[str, Any]:
-        """
-        Get a preview of what would be synchronized without making changes.
-        
-        Args:
-            user: User to preview sync for
-            verbose: Include detailed information
-            
-        Returns:
-            Dict with preview information
-        """
-        try:
-            # Get current sync status
-            sync_status = self.sync_service.get_sync_status(user)
-            
-            # Get zones from Cloudflare (this requires API call)
-            cf_zones = self.sync_service.client.list_zones()
-            
-            # Get existing sites
-            existing_sites = CloudflareSite.objects.for_user(user)
-            existing_domains = set(existing_sites.values_list('domain', flat=True))
-            
-            # Analyze what would happen
-            cf_domains = {zone.name for zone in cf_zones}
-            
-            preview = {
-                'cloudflare_zones': len(cf_zones),
-                'existing_sites': existing_sites.count(),
-                'would_create': len(cf_domains - existing_domains),
-                'would_update': len(cf_domains & existing_domains),
-                'would_skip': len(existing_domains - cf_domains),
-                'sync_status': sync_status
-            }
-            
-            if verbose:
-                preview.update({
-                    'new_domains': list(cf_domains - existing_domains),
-                    'existing_domains': list(cf_domains & existing_domains),
-                    'orphaned_domains': list(existing_domains - cf_domains),
-                    'cloudflare_zones_details': [
-                        {
-                            'name': zone.name,
-                            'id': zone.id,
-                            'status': zone.status
-                        }
-                        for zone in cf_zones
-                    ]
-                })
-            
-            return {
-                'success': True,
-                'preview': preview
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to get sync preview: {e}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
-    
-    def _transform_stats_for_command(self, core_stats: Dict[str, Any]) -> Dict[str, int]:
-        """
-        Transform core sync stats to command-compatible format.
-        
-        Args:
-            core_stats: Stats from SiteSyncService
-            
-        Returns:
-            Dict with command-compatible stats
-        """
-        # Map core stats to command stats
-        command_stats = {
-            'created': core_stats.get('created', 0),
-            'updated': core_stats.get('updated', 0),
-            'skipped': core_stats.get('skipped', 0),
-            'errors': core_stats.get('errors', 0)
-        }
-        
-        return command_stats
-    
-    def create_config_from_params(
-        self,
-        api_token: str,
-        domain: str = "dummy.com"
-    ) -> CloudflareConfig:
-        """
-        Create CloudflareConfig from parameters.
-        
-        Args:
-            api_token: Cloudflare API token
-            domain: Domain (not used for zone listing)
-            
-        Returns:
-            CloudflareConfig instance
-        """
-        return CloudflareConfig(
-            api_token=api_token,
-            domain=domain
-        )
-    
-    @classmethod
-    def create_from_params(
-        cls,
-        api_token: str,
-        domain: str = "dummy.com"
-    ) -> 'SyncCommandService':
-        """
-        Create service instance from parameters.
-        
-        Args:
-            api_token: Cloudflare API token
-            domain: Domain (not used for zone listing)
-            
-        Returns:
-            SyncCommandService instance
-        """
-        config = CloudflareConfig(
-            api_token=api_token,
-            domain=domain
-        )
-        return cls(config)

django_cfg/apps/maintenance/services/worker_manager.py

@@ -1,264 +0,0 @@
-"""
-Cloudflare Workers management using official library.
-
-Provides clean interface for managing Workers scripts and routes.
-"""
-
-import logging
-from typing import Dict, List, Optional, Any
-from datetime import datetime
-
-from .cloudflare_client import CloudflareClient
-from django_cfg.models.cloudflare import CloudflareConfig
-
-logger = logging.getLogger(__name__)
-
-
-class WorkerManager:
-    """
-    Cloudflare Workers management service.
-    
-    Provides high-level interface for Workers operations.
-    """
-    
-    def __init__(self, config: CloudflareConfig):
-        """Initialize worker manager."""
-        self.config = config
-        self.client = CloudflareClient(config)
-        
-    def deploy_worker(
-        self,
-        account_id: str,
-        script_name: str,
-        script_content: str,
-        routes: Optional[List[Dict[str, str]]] = None
-    ) -> Dict[str, Any]:
-        """
-        Deploy a Worker script with optional routes.
-        
-        Args:
-            account_id: Cloudflare account ID
-            script_name: Name for the Worker script
-            script_content: JavaScript code for the Worker
-            routes: List of route configurations [{'zone_id': '...', 'pattern': '...'}]
-            
-        Returns:
-            Dict with deployment results
-        """
-        logger.info(f"Deploying Worker script: {script_name}")
-        
-        try:
-            # Deploy the Worker script
-            worker_result = self.client.create_worker(
-                account_id=account_id,
-                script_name=script_name,
-                script_content=script_content
-            )
-            
-            deployed_routes = []
-            
-            # Create routes if provided
-            if routes:
-                for route_config in routes:
-                    try:
-                        route_result = self.client.create_worker_route(
-                            zone_id=route_config['zone_id'],
-                            pattern=route_config['pattern'],
-                            script_name=script_name
-                        )
-                        deployed_routes.append({
-                            'zone_id': route_config['zone_id'],
-                            'pattern': route_config['pattern'],
-                            'route_id': route_result.get('id'),
-                            'success': True
-                        })
-                    except Exception as e:
-                        logger.error(f"Failed to create route {route_config['pattern']}: {e}")
-                        deployed_routes.append({
-                            'zone_id': route_config['zone_id'],
-                            'pattern': route_config['pattern'],
-                            'success': False,
-                            'error': str(e)
-                        })
-            
-            logger.info(f"Successfully deployed Worker: {script_name}")
-            
-            return {
-                'success': True,
-                'worker_id': worker_result.id,
-                'script_name': script_name,
-                'routes': deployed_routes,
-                'deployed_at': datetime.now().isoformat()
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to deploy Worker {script_name}: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'script_name': script_name
-            }
-    
-    def update_worker(
-        self,
-        account_id: str,
-        script_name: str,
-        script_content: str
-    ) -> Dict[str, Any]:
-        """
-        Update an existing Worker script.
-        
-        Args:
-            account_id: Cloudflare account ID
-            script_name: Name of the Worker script to update
-            script_content: New JavaScript code
-            
-        Returns:
-            Dict with update results
-        """
-        logger.info(f"Updating Worker script: {script_name}")
-        
-        try:
-            worker_result = self.client.create_worker(
-                account_id=account_id,
-                script_name=script_name,
-                script_content=script_content
-            )
-            
-            logger.info(f"Successfully updated Worker: {script_name}")
-            
-            return {
-                'success': True,
-                'worker_id': worker_result.id,
-                'script_name': script_name,
-                'updated_at': datetime.now().isoformat()
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to update Worker {script_name}: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'script_name': script_name
-            }
-    
-    def delete_worker(
-        self,
-        account_id: str,
-        script_name: str,
-        cleanup_routes: bool = True
-    ) -> Dict[str, Any]:
-        """
-        Delete a Worker script and optionally its routes.
-        
-        Args:
-            account_id: Cloudflare account ID
-            script_name: Name of the Worker script to delete
-            cleanup_routes: Whether to delete associated routes
-            
-        Returns:
-            Dict with deletion results
-        """
-        logger.info(f"Deleting Worker script: {script_name}")
-        
-        try:
-            # TODO: If cleanup_routes is True, we'd need to find and delete routes
-            # This would require additional API calls to list routes and filter by script
-            
-            success = self.client.delete_worker(account_id, script_name)
-            
-            if success:
-                logger.info(f"Successfully deleted Worker: {script_name}")
-                return {
-                    'success': True,
-                    'script_name': script_name,
-                    'deleted_at': datetime.now().isoformat()
-                }
-            else:
-                return {
-                    'success': False,
-                    'error': 'Delete operation returned False',
-                    'script_name': script_name
-                }
-                
-        except Exception as e:
-            logger.error(f"Failed to delete Worker {script_name}: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'script_name': script_name
-            }
-    
-    def list_workers(self, account_id: str) -> Dict[str, Any]:
-        """
-        List all Workers in an account.
-        
-        Args:
-            account_id: Cloudflare account ID
-            
-        Returns:
-            Dict with workers list
-        """
-        logger.info("Listing Workers scripts")
-        
-        try:
-            workers = self.client.list_workers(account_id)
-            
-            workers_data = []
-            for worker in workers:
-                workers_data.append({
-                    'id': worker.id,
-                    'script_name': getattr(worker, 'script_name', ''),
-                    'created_on': getattr(worker, 'created_on', ''),
-                    'modified_on': getattr(worker, 'modified_on', ''),
-                    'size': getattr(worker, 'size', 0)
-                })
-            
-            logger.info(f"Found {len(workers_data)} Workers")
-            
-            return {
-                'success': True,
-                'workers': workers_data,
-                'count': len(workers_data)
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to list Workers: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'workers': [],
-                'count': 0
-            }
-    
-    def get_worker_analytics(
-        self,
-        account_id: str,
-        script_name: str,
-        since: Optional[datetime] = None,
-        until: Optional[datetime] = None
-    ) -> Dict[str, Any]:
-        """
-        Get analytics for a Worker script.
-        
-        Note: This would require additional API calls to Cloudflare Analytics API
-        which might not be available in the basic cloudflare library.
-        
-        Args:
-            account_id: Cloudflare account ID
-            script_name: Worker script name
-            since: Start date for analytics
-            until: End date for analytics
-            
-        Returns:
-            Dict with analytics data
-        """
-        logger.info(f"Getting analytics for Worker: {script_name}")
-        
-        # This is a placeholder - actual implementation would require
-        # additional API calls to Cloudflare Analytics API
-        return {
-            'success': False,
-            'error': 'Analytics API not implemented yet',
-            'script_name': script_name
-        }

django_cfg/apps/maintenance/signals.py

@@ -1,38 +0,0 @@
-"""
-Maintenance app signals.
-
-Signal handlers for maintenance events and site management.
-"""
-
-from django.db.models.signals import post_save, pre_delete
-from django.dispatch import receiver
-import logging
-
-from .models import MaintenanceEvent, CloudflareSite
-
-logger = logging.getLogger(__name__)
-
-
-@receiver(post_save, sender=MaintenanceEvent)
-def maintenance_event_created(sender, instance, created, **kwargs):
-    """Handle maintenance event creation."""
-    if created:
-        logger.info(f"Maintenance event created: {instance.title}")
-
-
-@receiver(post_save, sender=CloudflareSite)
-def cloudflare_site_updated(sender, instance, created, **kwargs):
-    """Handle Cloudflare site updates."""
-    if created:
-        logger.info(f"New Cloudflare site added: {instance.domain}")
-    else:
-        logger.debug(f"Cloudflare site updated: {instance.domain}")
-
-
-@receiver(pre_delete, sender=CloudflareSite)
-def cloudflare_site_cleanup(sender, instance, **kwargs):
-    """Clean up before deleting Cloudflare site."""
-    logger.info(f"Cleaning up Cloudflare site: {instance.domain}")
-    
-    # Note: In a full implementation, this would clean up
-    # any active Workers or Page Rules in Cloudflare

django_cfg/apps/maintenance/urls.py

@@ -1,36 +0,0 @@
-"""
-URL configuration for maintenance app.
-
-RESTful API endpoints using nested routers for multi-site maintenance management.
-"""
-
-from django.urls import path, include
-from rest_framework_nested import routers
-from .views import (
-    CloudflareSiteViewSet, SiteGroupViewSet, MaintenanceEventViewSet,
-    MonitoringTargetViewSet, CloudflareDeploymentViewSet
-)
-
-app_name = 'maintenance'
-
-# Main router for primary resources
-router = routers.SimpleRouter()
-router.register(r'sites', CloudflareSiteViewSet, basename='site')
-router.register(r'groups', SiteGroupViewSet, basename='group')
-router.register(r'events', MaintenanceEventViewSet, basename='event')
-router.register(r'deployments', CloudflareDeploymentViewSet, basename='deployment')
-
-# Nested routers for related resources
-sites_router = routers.NestedSimpleRouter(router, r'sites', lookup='site')
-sites_router.register(r'monitoring', MonitoringTargetViewSet, basename='site-monitoring')
-
-events_router = routers.NestedSimpleRouter(router, r'events', lookup='event')
-# events_router.register(r'logs', MaintenanceLogViewSet, basename='event-logs')  # Future
-
-# API endpoints
-urlpatterns = [
-    # RESTful API routes
-    path('api/', include(router.urls)),
-    path('api/', include(sites_router.urls)),
-    path('api/', include(events_router.urls)),
-]

django_cfg/apps/maintenance/views/__init__.py

@@ -1,18 +0,0 @@
-"""
-Maintenance app views.
-
-RESTful API views for multi-site maintenance management.
-"""
-
-from .sites import CloudflareSiteViewSet, SiteGroupViewSet
-from .events import MaintenanceEventViewSet
-from .monitoring import MonitoringTargetViewSet
-from .deployments import CloudflareDeploymentViewSet
-
-__all__ = [
-    'CloudflareSiteViewSet',
-    'SiteGroupViewSet',
-    'MaintenanceEventViewSet',
-    'MonitoringTargetViewSet',
-    'CloudflareDeploymentViewSet'
-]