django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/management/commands/create_token.py

@@ -10,21 +10,14 @@ from pathlib import Path
 
 import questionary
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import InteractiveCommand
 
 User = get_user_model()
 
 
-logger = get_logger('create_token')
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = False
-
+class Command(InteractiveCommand):
+    command_name = 'create_token'
     help = 'Create API tokens and authentication tokens'
 
     def add_arguments(self, parser):
@@ -52,7 +45,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting create_token command")
+        self.logger.info("Starting create_token command")
         if options['user'] and options['type']:
             self.create_token_for_user(
                 username=options['user'],

django_cfg/management/commands/list_urls.py

@@ -8,7 +8,6 @@ Useful for development and webhook configuration.
 import re
 
 from django.conf import settings
-from django.core.management.base import BaseCommand
 from django.urls import get_resolver
 from rich.align import Align
 
@@ -19,18 +18,13 @@ from rich.table import Table
 from rich.text import Text
 
 from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
-logger = get_logger('list_urls')
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to display all available URLs in the project."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'list_urls'
     help = "Display all available URLs with Rich formatting"
 
     def __init__(self, *args, **kwargs):
@@ -62,7 +56,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting list_urls command")
+        self.logger.info("Starting list_urls command")
         filter_str = options["filter"]
         webhook_only = options["webhook"]
         api_only = options["api"]
@@ -229,69 +223,9 @@ class Command(BaseCommand):
         self.console.print(info_table)
 
     def show_webhook_info(self):
-        """Show webhook-specific information using reverse."""
+        """Show webhook-specific information."""
         self.console.print()
-
-        webhook_table = Table(title="🔔 Webhook Configuration", show_header=True, header_style="bold yellow")
-        webhook_table.add_column("Service", style="white", width=25)
-        webhook_table.add_column("Local URL", style="cyan", width=60)
-        webhook_table.add_column("Ngrok URL", style="magenta", width=60)
-
-        base_url = self.get_base_url()
-        ngrok_url = self.get_ngrok_url()
-
-        # Get webhook URLs using reverse
-        try:
-            from django.urls import reverse
-
-            # Common webhook endpoints with their URL names
-            webhooks = [
-                ("Twilio Message Status", "cfg_accounts:webhook-message-status"),
-                ("Twilio Verification", "cfg_accounts:webhook-verification-status"),
-            ]
-
-            for service, url_name in webhooks:
-                try:
-                    # Get the reversed URL path
-                    url_path = reverse(url_name)
-
-                    # Build full URLs
-                    local_full = f"{base_url.rstrip('/')}{url_path}"
-                    ngrok_full = f"{ngrok_url.rstrip('/')}{url_path}" if ngrok_url else "—"
-
-                    webhook_table.add_row(service, local_full, ngrok_full)
-
-                except Exception as e:
-                    # Fallback if reverse fails
-                    self.console.print(f"[yellow]⚠️  Could not reverse URL for {service}: {e}[/yellow]")
-                    fallback_path = f"/api/accounts/webhook/{service.lower().replace(' ', '-').replace('twilio ', '')}/"
-                    local_full = f"{base_url.rstrip('/')}{fallback_path}"
-                    ngrok_full = f"{ngrok_url.rstrip('/')}{fallback_path}" if ngrok_url else "—"
-                    webhook_table.add_row(service, local_full, ngrok_full)
-
-        except ImportError:
-            # Fallback if Django is not available
-            webhooks = [
-                ("Twilio Message Status", "/api/accounts/webhook/message-status/"),
-                ("Twilio Verification", "/api/accounts/webhook/verification-status/"),
-            ]
-
-            for service, endpoint in webhooks:
-                local_full = f"{base_url.rstrip('/')}{endpoint}"
-                ngrok_full = f"{ngrok_url.rstrip('/')}{endpoint}" if ngrok_url else "—"
-                webhook_table.add_row(service, local_full, ngrok_full)
-
-        self.console.print(webhook_table)
-
-        # Show tips
-        tips = [
-            "💡 Use ngrok URLs for webhook configuration in production services",
-            "🔒 Always validate webhook signatures in production",
-            "📝 Test webhooks using the test_twilio management command",
-        ]
-
-        for tip in tips:
-            self.console.print(f"[dim]{tip}[/dim]")
+        self.console.print("[dim]No webhook endpoints configured.[/dim]")
 
     def get_base_url(self):
         """Get base URL for the application."""

django_cfg/management/commands/migrate_all.py

@@ -3,29 +3,26 @@ Simple Migration Command for Django Config Toolkit
 Migrate all databases based on django-cfg configuration.
 """
 
-from django.apps import apps
-from django.core.management import call_command
-from django.core.management.base import BaseCommand
+from django_cfg.management.utils import AdminCommand, MigrationManager
 
-from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('migrate_all')
+class Command(AdminCommand):
+    """
+    Migrate all databases - destructive but non-interactive admin command.
 
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = False
-    is_destructive = True
+    This command is marked as destructive because it modifies the database schema,
+    but it doesn't require user input during execution.
+    """
+
+    command_name = 'migrate_all'
+
+    # Override AdminCommand defaults
+    web_executable = False  # Too risky for web execution
+    is_destructive = True   # Modifies database schema
 
     help = "Migrate all databases based on django-cfg configuration"
 
     def add_arguments(self, parser):
-        parser.add_argument(
-            "--dry-run",
-            action="store_true",
-            help="Show what would be migrated without executing"
-        )
         parser.add_argument(
             "--skip-makemigrations",
             action="store_true",
@@ -34,98 +31,20 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Run migrations for all configured databases."""
-        logger.info("Starting migrate_all command")
-        dry_run = options.get("dry_run", False)
+        self.logger.info("Starting migrate_all command")
         skip_makemigrations = options.get("skip_makemigrations", False)
 
-        if dry_run:
-            self.stdout.write(self.style.WARNING("🔍 DRY RUN - No changes will be made"))
-
-        self.stdout.write(self.style.SUCCESS("🚀 Migrating all databases..."))
+        # Initialize migration manager
+        manager = MigrationManager(self.stdout, self.style, self.logger)
 
-        # Step 1: Create migrations if needed
+        # Create migrations if needed
         if not skip_makemigrations:
-            self.stdout.write("📝 Creating migrations...")
-            if not dry_run:
-                call_command("makemigrations", verbosity=1)
-            else:
-                self.stdout.write("  Would run: makemigrations")
+            manager.create_migrations()
 
-        # Step 2: Get database configuration
-        try:
-            config = get_current_config()
-            if not config or not hasattr(config, 'databases'):
-                self.stdout.write(self.style.ERROR("❌ No django-cfg configuration found"))
-                return
-        except Exception as e:
-            self.stdout.write(self.style.ERROR(f"❌ Error loading configuration: {e}"))
-            return
+        # Migrate all databases
+        manager.migrate_all_databases()
 
-        # Step 3: Migrate each database
-        for db_name, db_config in config.databases.items():
-            self.stdout.write(f"\n🔄 Migrating database: {db_name}")
-
-            if hasattr(db_config, 'apps') and db_config.apps:
-                # Migrate specific apps for this database
-                for app_path in db_config.apps:
-                    app_label = self._get_app_label(app_path)
-                    if app_label:
-                        self.stdout.write(f"  📦 Migrating {app_label}...")
-                        if not dry_run:
-                            try:
-                                call_command("migrate", app_label, database=db_name, verbosity=1)
-                            except Exception as e:
-                                self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for {app_label} on {db_name}: {e}"))
-                                logger.error(f"Migration failed for {app_label} on {db_name}: {e}")
-                                raise SystemExit(1)
-                        else:
-                            self.stdout.write(f"  Would run: migrate {app_label} --database={db_name}")
-            else:
-                # Migrate all apps for this database (usually default)
-                self.stdout.write("  📦 Migrating all apps...")
-                if not dry_run:
-                    try:
-                        call_command("migrate", database=db_name, verbosity=1)
-                    except Exception as e:
-                        self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for all apps on {db_name}: {e}"))
-                        logger.error(f"Migration failed for all apps on {db_name}: {e}")
-                        raise SystemExit(1)
-                else:
-                    self.stdout.write(f"  Would run: migrate --database={db_name}")
-
-        # Step 4: Migrate constance if needed
-        self.stdout.write("\n🔧 Migrating constance...")
-        if not dry_run:
-            try:
-                call_command("migrate", "constance", database="default", verbosity=1)
-            except Exception as e:
-                self.stdout.write(self.style.ERROR(f"❌ Constance migration failed: {e}"))
-                logger.error(f"Constance migration failed: {e}")
-                raise SystemExit(1)
-        else:
-            self.stdout.write("  Would run: migrate constance --database=default")
+        # Migrate constance
+        manager.migrate_constance_if_needed()
 
         self.stdout.write(self.style.SUCCESS("\n✅ All migrations completed!"))
-
-    def _get_app_label(self, app_path: str) -> str:
-        """Convert full module path to Django app_label."""
-        try:
-            # Try to get app config by full path first
-            try:
-                app_config = apps.get_app_config(app_path)
-                return app_config.label
-            except LookupError:
-                pass
-
-            # Fallback: extract last part of the path as potential app_label
-            potential_label = app_path.split('.')[-1]
-            try:
-                app_config = apps.get_app_config(potential_label)
-                return app_config.label
-            except LookupError:
-                pass
-
-            return app_path
-
-        except Exception:
-            return app_path

django_cfg/management/commands/migrator.py

@@ -3,40 +3,35 @@ Smart Migration Command for Django Config Toolkit
 Simple and reliable migration for all databases.
 """
 
-from pathlib import Path
-
 import questionary
-from django.apps import apps
 from django.conf import settings
 from django.core.management import call_command
-from django.core.management.base import BaseCommand
 from django.db import connections
-from django.db.migrations.recorder import MigrationRecorder
-
-from django_cfg.core.config import DEFAULT_APPS
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('migrator')
+from django_cfg.management.utils import DestructiveCommand, MigrationManager
 
 
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = True
-
+class Command(DestructiveCommand):
+    command_name = 'migrator'
     help = "Smart migration command with interactive menu for multiple databases"
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.manager = None
+
     def add_arguments(self, parser):
         parser.add_argument("--auto", action="store_true", help="Run automatic migration without prompts")
         parser.add_argument("--database", type=str, help="Migrate specific database only")
         parser.add_argument("--app", type=str, help="Migrate specific app only")
 
     def handle(self, *args, **options):
+        # Initialize migration manager
+        self.manager = MigrationManager(self.stdout, self.style, self.logger)
+        
         if options["auto"]:
             self.run_automatic_migration()
         elif options["database"]:
-            self.migrate_database(options["database"])
+            self.manager.migrate_database(options["database"])
         elif options["app"]:
             self.migrate_app(options["app"])
         else:
@@ -46,7 +41,7 @@ class Command(BaseCommand):
         """Show interactive menu with options"""
         self.stdout.write(self.style.SUCCESS("\n🚀 Smart Migration Tool - Django Config Toolkit\n"))
 
-        databases = self.get_all_database_names()
+        databases = self.manager.get_all_database_names()
 
         choices = [
             questionary.Choice("🔄 Run Full Migration (All Databases)", value="full"),
@@ -66,7 +61,7 @@ class Command(BaseCommand):
         if choice == "full":
             self.run_full_migration()
         elif choice == "makemigrations":
-            self.create_migrations()
+            self.manager.create_migrations()
         elif choice == "status":
             self.show_database_status()
         elif choice == "config":
@@ -76,141 +71,49 @@ class Command(BaseCommand):
             return
         elif choice.startswith("migrate_"):
             db_name = choice.replace("migrate_", "")
-            self.migrate_database(db_name)
+            self.manager.migrate_database(db_name)
 
     def run_full_migration(self):
         """Run migration for all databases"""
-        self.stdout.write(self.style.SUCCESS("🔄 Starting full migration..."))
-
-        # First migrate default database
-        self.stdout.write("📊 Migrating default database...")
-        self.migrate_database("default")
-
-        # Then migrate other databases (excluding default)
-        databases = self.get_all_database_names()
-        for db_name in databases:
-            if db_name != "default":
-                self.stdout.write(f"🔄 Migrating {db_name}...")
-                self.migrate_database(db_name)
-
-        self.stdout.write(self.style.SUCCESS("✅ Full migration completed!"))
+        self.manager.migrate_all_databases()
 
     def run_automatic_migration(self):
         """Run automatic migration for all databases"""
         self.stdout.write(self.style.SUCCESS("🚀 Running automatic migration..."))
 
         # Create migrations
-        self.create_migrations()
+        self.manager.create_migrations()
 
         # Run full migration
-        self.run_full_migration()
+        self.manager.migrate_all_databases()
 
         # Always migrate constance (required for django-cfg)
-        self.migrate_constance_if_needed()
-
-    def create_migrations(self):
-        """Create migrations for all apps"""
-        self.stdout.write(self.style.SUCCESS("📝 Creating migrations..."))
-
-        try:
-            # First try global makemigrations
-            call_command("makemigrations", verbosity=1)
-
-            # Then try for each app that has models but no migrations
-            all_apps = self.get_all_installed_apps()
-            for app in all_apps:
-                if self.app_has_models(app) and not self.app_has_migrations(app):
-                    try:
-                        self.stdout.write(f"  📝 Creating migrations for {app}...")
-                        call_command("makemigrations", app, verbosity=1)
-                    except Exception as e:
-                        self.stdout.write(self.style.WARNING(f"  ⚠️  Could not create migrations for {app}: {e}"))
-
-            self.stdout.write(self.style.SUCCESS("✅ Migrations created"))
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Warning creating migrations: {e}"))
-
-    def _raise_system_exit(self, message):
-        self.stdout.write(self.style.ERROR(f"❌ {message}"))
-        logger.error(message)
-        # raise SystemExit(1)
-
-    def migrate_database(self, db_name):
-        """Migrate specific database"""
-        try:
-            self.stdout.write(f"🔄 Migrating {db_name}...")
-
-            # Get apps for this database
-            apps = self.get_apps_for_database(db_name)
-
-            # Debug info
-            self.stdout.write(f"  📋 Apps for {db_name}: {apps}")
-
-            if not apps:
-                self.stdout.write(self.style.WARNING(f"  ⚠️  No apps configured for {db_name}"))
-                return
-
-            # make migrations for all apps
-            self.create_migrations()
-
-            # Migrate each app
-            for app in apps:
-                try:
-                    # Skip apps without migrations
-                    if not self.app_has_migrations(app):
-                        # self.stdout.write(f"  ⚠️  Skipping {app} - no migrations")
-                        continue
+        self.manager.migrate_constance_if_needed()
 
-                    self.stdout.write(f"  📦 Migrating {app}...")
-                    call_command("migrate", app, database=db_name, verbosity=1)
-                except Exception as e:
-                    self._raise_system_exit(f"Migration failed for {app} on {db_name}: {e}")
-
-            self.stdout.write(self.style.SUCCESS(f"✅ {db_name} migration completed!"))
-
-        except Exception as e:
-            self._raise_system_exit(f"Error migrating {db_name}: {e}")
-
-    def migrate_constance_if_needed(self):
-        """Always migrate constance app if it's installed"""
-        try:
-            # Check if constance is in INSTALLED_APPS
-            if 'constance' in settings.INSTALLED_APPS:
-                self.stdout.write(self.style.SUCCESS("🔧 Migrating constance (django-cfg requirement)..."))
-
-                # Try to migrate constance on default database
-                try:
-                    call_command("migrate", "constance", database="default", verbosity=1)
-                    self.stdout.write(self.style.SUCCESS("✅ Constance migration completed!"))
-                except Exception as e:
-                    self._raise_system_exit(f"Constance migration failed: {e}")
-            else:
-                self.stdout.write(self.style.WARNING("⚠️  Constance not found in INSTALLED_APPS"))
-
-        except Exception as e:
-            self._raise_system_exit(f"Could not migrate constance: {e}")
 
     def migrate_app(self, app_name):
         """Migrate specific app across all databases"""
         self.stdout.write(f"🔄 Migrating app {app_name}...")
 
-        databases = self.get_all_database_names()
+        databases = self.manager.get_all_database_names()
         for db_name in databases:
-            apps = self.get_apps_for_database(db_name)
+            apps = self.manager.get_apps_for_database(db_name)
             if app_name in apps:
                 self.stdout.write(f"  📊 Migrating {app_name} on {db_name}...")
                 try:
                     call_command("migrate", app_name, database=db_name, verbosity=1)
                 except Exception as e:
-                    self._raise_system_exit(f"Migration failed for {app_name} on {db_name}: {e}")
+                    self.stdout.write(self.style.ERROR(f"❌ Migration failed for {app_name} on {db_name}: {e}"))
+                    self.logger.error(f"Migration failed for {app_name} on {db_name}: {e}")
+                    raise SystemExit(1)
 
     def show_database_status(self):
         """Show status of all databases and their apps"""
         self.stdout.write(self.style.SUCCESS("\n📊 Database Status Report\n"))
 
         # Get database info from Django settings
-        db_info = self.get_database_info()
-        databases = self.get_all_database_names()
+        db_info = self.manager.get_database_info()
+        databases = self.manager.get_all_database_names()
 
         for db_name in databases:
             self.stdout.write(f"\n🗄️  Database: {db_name}")
@@ -222,15 +125,11 @@ class Command(BaseCommand):
                 self.stdout.write(f'  🔗 Name: {info["name"]}')
 
             # Test connection
-            try:
-                with connections[db_name].cursor() as cursor:
-                    cursor.execute("SELECT 1")
+            if self.manager.check_database_connection(db_name):
                 self.stdout.write("  ✅ Connection: OK")
-            except Exception as e:
-                self.stdout.write(f"  ❌ Connection: FAILED - {e}")
 
             # Show apps
-            apps = self.get_apps_for_database(db_name)
+            apps = self.manager.get_apps_for_database(db_name)
             if apps:
                 self.stdout.write(f'  📦 Apps: {", ".join(apps)}')
             else:
@@ -275,129 +174,5 @@ class Command(BaseCommand):
             self.stdout.write(f"📦 Installed Apps: {len(settings.INSTALLED_APPS)}")
 
         except Exception as e:
-            self._raise_system_exit(f"Error getting Django config info: {e}")
-
-    def get_apps_for_database(self, db_name: str):
-        """Get apps for specific database with smart logic for default"""
-        if db_name == "default":
-            # For default database, get all apps that are not in other databases
-            all_apps = self.get_all_installed_apps()
-            apps_in_other_dbs = self.get_apps_in_other_databases()
-            return [app for app in all_apps if app not in apps_in_other_dbs]
-        else:
-            # For other databases, use configured apps from routing rules
-            routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
-
-            # Routing rules are now in Django settings
-            pass
-
-            return [app for app, db in routing_rules.items() if db == db_name]
-
-    def get_all_installed_apps(self):
-        """Get all installed Django apps by checking for apps.py files."""
-        apps_list = []
-
-        # Get all Django app configs
-        for app_config in apps.get_app_configs():
-            app_label = app_config.label
-            app_path = Path(app_config.path)
-
-            # Check if apps.py exists in the app directory
-            apps_py_path = app_path / "apps.py"
-            if apps_py_path.exists():
-                if app_label not in DEFAULT_APPS:
-                    apps_list.append(app_label)
-                continue
-
-            # Fallback: check if it's a standard Django app (has models.py or admin.py)
-            if (app_path / "models.py").exists() or (app_path / "admin.py").exists():
-                apps_list.append(app_label)
-
-        return apps_list
-
-    def get_apps_in_other_databases(self) -> set:
-        """Get all apps that are configured for non-default databases."""
-        routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
-
-        # Routing rules are now in Django settings
-        pass
-
-        return set(routing_rules.keys())
-
-    def get_all_database_names(self):
-        """Get all database names."""
-        return list(connections.databases.keys())
-
-    def get_database_info(self):
-        """Get database information from Django settings"""
-        try:
-            db_info = {}
-
-            # Get database info from Django settings
-            for db_name, db_config in settings.DATABASES.items():
-                db_info[db_name] = {"name": db_config.get("NAME", "unknown"), "engine": db_config.get("ENGINE", "unknown"), "host": db_config.get("HOST", ""), "port": db_config.get("PORT", ""), "apps": []}  # Will be populated by routing logic
-
-            return db_info
-
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Error getting database info: {e}"))
-            return {}
-
-    def app_has_migrations(self, app_label: str) -> bool:
-        """Simple check if an app has migrations."""
-        try:
-            # Get the app config
-            app_config = apps.get_app_config(app_label)
-            if not app_config:
-                return False
-
-            # Check if migrations directory exists and has files
-            migrations_dir = Path(app_config.path) / "migrations"
-            if not migrations_dir.exists():
-                return False
-
-            # Check if there are any migration files (excluding __init__.py)
-            migration_files = [f for f in migrations_dir.glob("*.py") if f.name != "__init__.py"]
-
-            # Also check if there are any applied migrations in the database
-            # Check all databases for this app's migrations
-            for db_name in connections.databases.keys():
-                try:
-                    recorder = MigrationRecorder(connections[db_name])
-                    applied_migrations = recorder.migration_qs.filter(app=app_label)
-                    if applied_migrations.exists():
-                        return True
-                except Exception:
-                    continue
-
-            # If no applied migrations found, check if there are migration files
-            return len(migration_files) > 0
-
-        except Exception:
-            # Silently return False for apps that don't exist or have issues
-            return False
-
-    def app_has_models(self, app_label: str) -> bool:
-        """Check if an app has models defined."""
-        try:
-            # Get the app config
-            app_config = apps.get_app_config(app_label)
-            if not app_config:
-                return False
-
-            # Check if models.py exists and has content
-            models_file = Path(app_config.path) / "models.py"
-            if models_file.exists():
-                # Read the file and check if it has model definitions
-                content = models_file.read_text()
-                # Simple check for model definitions
-                if "class " in content and "models.Model" in content:
-                    return True
-
-            # Also check if the app has any registered models
-            models = app_config.get_models()
-            return len(models) > 0
-
-        except Exception:
-            # Silently return False for apps that don't exist or have issues
-            return False
+            self.stdout.write(self.style.ERROR(f"❌ Error getting Django config info: {e}"))
+            self.logger.error(f"Error getting Django config info: {e}")