django-cfg 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/modules/django_admin/management/commands/superuser.py

@@ -0,0 +1,302 @@
+"""
+Superuser Command for Django Config Toolkit
+Enhanced superuser creation with validation and configuration.
+"""
+
+import os
+import getpass
+from pathlib import Path
+from django.core.management.base import BaseCommand
+from django.core.management import call_command
+from django.contrib.auth import get_user_model
+from django.core.validators import validate_email
+from django.core.exceptions import ValidationError
+from django.conf import settings
+import questionary
+from datetime import datetime
+from django_cfg.modules.django_logging import get_logger
+
+User = get_user_model()
+
+
+logger = get_logger('superuser')
+
+class Command(BaseCommand):
+    # Web execution metadata
+    web_executable = False
+    requires_input = True
+    is_destructive = False
+
+    help = 'Create a superuser with enhanced validation and configuration'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--username',
+            type=str,
+            help='Username for superuser'
+        )
+        parser.add_argument(
+            '--email',
+            type=str,
+            help='Email for superuser'
+        )
+        parser.add_argument(
+            '--password',
+            type=str,
+            help='Password for superuser'
+        )
+        parser.add_argument(
+            '--first-name',
+            type=str,
+            help='First name for superuser'
+        )
+        parser.add_argument(
+            '--last-name',
+            type=str,
+            help='Last name for superuser'
+        )
+        parser.add_argument(
+            '--interactive',
+            action='store_true',
+            help='Run in interactive mode'
+        )
+
+    def handle(self, *args, **options):
+        logger.info("Starting superuser command")
+        if options['interactive'] or not any([options['username'], options['email'], options['password']]):
+            self.create_superuser_interactive()
+        else:
+            self.create_superuser_non_interactive(options)
+
+    def create_superuser_interactive(self):
+        """Create superuser interactively"""
+        self.stdout.write(self.style.SUCCESS('\n👑 Superuser Creation Tool - Django Config Toolkit\n'))
+        
+        # Check if superuser already exists
+        if User.objects.filter(is_superuser=True).exists():
+            self.stdout.write(self.style.WARNING('⚠️  Superuser already exists'))
+            overwrite = questionary.confirm('Do you want to create another superuser?').ask()
+            if not overwrite:
+                self.stdout.write('Goodbye! 👋')
+                return
+
+        # Get user details
+        user_data = self.get_user_details_interactive()
+        
+        # Validate data
+        if not self.validate_user_data(user_data):
+            return
+        
+        # Create superuser
+        self.create_superuser(user_data)
+
+    def create_superuser_non_interactive(self, options):
+        """Create superuser non-interactively"""
+        user_data = {
+            'username': options['username'],
+            'email': options['email'],
+            'password': options['password'],
+            'first_name': options['first_name'] or '',
+            'last_name': options['last_name'] or '',
+        }
+        
+        # Validate required fields
+        if not all([user_data['username'], user_data['email'], user_data['password']]):
+            self.stdout.write(self.style.ERROR('❌ Username, email, and password are required'))
+            return
+        
+        # Validate data
+        if not self.validate_user_data(user_data):
+            return
+        
+        # Create superuser
+        self.create_superuser(user_data)
+
+    def get_user_details_interactive(self):
+        """Get user details interactively"""
+        user_data = {}
+        
+        # Username
+        while True:
+            username = questionary.text('Username:').ask()
+            if not username:
+                self.stdout.write(self.style.ERROR('❌ Username is required'))
+                continue
+            
+            if User.objects.filter(username=username).exists():
+                self.stdout.write(self.style.ERROR('❌ Username already exists'))
+                continue
+            
+            user_data['username'] = username
+            break
+        
+        # Email
+        while True:
+            email = questionary.text('Email:').ask()
+            if not email:
+                self.stdout.write(self.style.ERROR('❌ Email is required'))
+                continue
+            
+            try:
+                validate_email(email)
+            except ValidationError:
+                self.stdout.write(self.style.ERROR('❌ Invalid email format'))
+                continue
+            
+            if User.objects.filter(email=email).exists():
+                self.stdout.write(self.style.ERROR('❌ Email already exists'))
+                continue
+            
+            user_data['email'] = email
+            break
+        
+        # Password
+        while True:
+            password = questionary.password('Password:').ask()
+            if not password:
+                self.stdout.write(self.style.ERROR('❌ Password is required'))
+                continue
+            
+            if len(password) < 8:
+                self.stdout.write(self.style.WARNING('⚠️  Password should be at least 8 characters'))
+                confirm = questionary.confirm('Continue with weak password?').ask()
+                if not confirm:
+                    continue
+            
+            confirm_password = questionary.password('Confirm password:').ask()
+            if password != confirm_password:
+                self.stdout.write(self.style.ERROR('❌ Passwords do not match'))
+                continue
+            
+            user_data['password'] = password
+            break
+        
+        # Optional fields
+        user_data['first_name'] = questionary.text('First name (optional):').ask() or ''
+        user_data['last_name'] = questionary.text('Last name (optional):').ask() or ''
+        
+        return user_data
+
+    def validate_user_data(self, user_data):
+        """Validate user data"""
+        errors = []
+        
+        # Check required fields
+        if not user_data.get('username'):
+            errors.append('Username is required')
+        
+        if not user_data.get('email'):
+            errors.append('Email is required')
+        
+        if not user_data.get('password'):
+            errors.append('Password is required')
+        
+        # Validate email format
+        if user_data.get('email'):
+            try:
+                validate_email(user_data['email'])
+            except ValidationError:
+                errors.append('Invalid email format')
+        
+        # Check if user already exists
+        if user_data.get('username') and User.objects.filter(username=user_data['username']).exists():
+            errors.append('Username already exists')
+        
+        if user_data.get('email') and User.objects.filter(email=user_data['email']).exists():
+            errors.append('Email already exists')
+        
+        # Password strength
+        if user_data.get('password') and len(user_data['password']) < 8:
+            errors.append('Password should be at least 8 characters')
+        
+        if errors:
+            self.stdout.write(self.style.ERROR('❌ Validation errors:'))
+            for error in errors:
+                self.stdout.write(f'   - {error}')
+            return False
+        
+        return True
+
+    def create_superuser(self, user_data):
+        """Create the superuser"""
+        try:
+            # Create user
+            user = User.objects.create_user(
+                username=user_data['username'],
+                email=user_data['email'],
+                password=user_data['password'],
+                first_name=user_data['first_name'],
+                last_name=user_data['last_name'],
+                is_staff=True,
+                is_superuser=True,
+                is_active=True
+            )
+            
+            # Save user details to file
+            self.save_superuser_details(user, user_data['password'])
+            
+            self.stdout.write(self.style.SUCCESS(f'✅ Superuser created successfully!'))
+            self.stdout.write(f'👤 Username: {user.username}')
+            self.stdout.write(f'📧 Email: {user.email}')
+            self.stdout.write(f'👑 Is Superuser: {user.is_superuser}')
+            self.stdout.write(f'🔧 Is Staff: {user.is_staff}')
+            self.stdout.write(f'✅ Is Active: {user.is_active}')
+            
+            # Show next steps
+            self.show_next_steps()
+            
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f'❌ Error creating superuser: {e}'))
+
+    def save_superuser_details(self, user, password):
+        """Save superuser details to file"""
+        # Create superusers directory
+        superusers_dir = Path('superusers')
+        superusers_dir.mkdir(exist_ok=True)
+        
+        # Create details file
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        filename = f"superuser_{user.username}_{timestamp}.txt"
+        filepath = superusers_dir / filename
+        
+        with open(filepath, 'w') as f:
+            f.write(f"Superuser Details\n")
+            f.write(f"================\n\n")
+            f.write(f"Username: {user.username}\n")
+            f.write(f"Email: {user.email}\n")
+            f.write(f"First Name: {user.first_name}\n")
+            f.write(f"Is Superuser: {user.is_superuser}\n")
+            f.write(f"Is Staff: {user.is_staff}\n")
+            f.write(f"Is Active: {user.is_active}\n")
+            f.write(f"Date Created: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"\n⚠️  IMPORTANT: Store this password securely!\n")
+            f.write(f"Password: {password}\n")
+        
+        self.stdout.write(f'💾 Superuser details saved to: {filepath}')
+
+    def show_next_steps(self):
+        """Show next steps after creating superuser"""
+        self.stdout.write(self.style.SUCCESS('\n🎉 Next Steps:'))
+        self.stdout.write('1. 🚀 Start your Django server: python manage.py runserver')
+        self.stdout.write('2. 🌐 Visit Django admin: http://localhost:8000/admin/')
+        self.stdout.write('3. 🔑 Login with your superuser credentials')
+        self.stdout.write('4. ⚙️  Configure your application settings')
+        self.stdout.write('5. 📚 Read the Django Config Toolkit documentation')
+        
+        # Show health check
+        self.stdout.write('\n🔍 Health Check:')
+        try:
+            call_command('check', verbosity=0)
+            self.stdout.write('✅ Django configuration is valid')
+        except Exception as e:
+            self.stdout.write(f'⚠️  Django configuration issues: {e}')
+
+    def check_existing_superusers(self):
+        """Check existing superusers"""
+        superusers = User.objects.filter(is_superuser=True)
+        if superusers.exists():
+            self.stdout.write(self.style.WARNING(f'⚠️  Found {superusers.count()} existing superuser(s):'))
+            for user in superusers:
+                self.stdout.write(f'   - {user.username} ({user.email})')
+            return True
+        return False

django_cfg/modules/django_admin/management/commands/tree.py

@@ -0,0 +1,390 @@
+"""
+🌳 Django CFG Tree Command
+
+Display Django project structure in a tree format based on configuration.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+
+from django_cfg.core.state import get_current_config
+from django_cfg.utils.path_resolution import PathResolver
+
+
+logger = get_logger('tree')
+
+class Command(BaseCommand):
+    """Display Django project structure in tree format."""
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Display Django project structure based on django-cfg configuration"
+    
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--depth', '-L',
+            type=int,
+            default=5,
+            help='Maximum depth to display (default: 5)'
+        )
+        parser.add_argument(
+            '--all', '-a',
+            action='store_true',
+            help='Show all files including hidden ones'
+        )
+        parser.add_argument(
+            '--dirs-only', '-d',
+            action='store_true',
+            help='Show directories only'
+        )
+        parser.add_argument(
+            '--no-ignore', '-n',
+            action='store_true',
+            help='Do not ignore common directories (node_modules, .git, etc.)'
+        )
+        parser.add_argument(
+            '--custom-ignore',
+            type=str,
+            help='Custom ignore pattern (pipe-separated, e.g., "*.pyc|temp|logs")'
+        )
+        parser.add_argument(
+            '--include-docs',
+            action='store_true',
+            help='Legacy option - @docs directories are now included by default'
+        )
+        parser.add_argument(
+            '--include-docker',
+            action='store_true', 
+            help='Include Docker configuration and volumes'
+        )
+        parser.add_argument(
+            '--include-logs',
+            action='store_true',
+            help='Include log files and directories'
+        )
+        parser.add_argument(
+            '--output', '-o',
+            type=str,
+            help='Output to file instead of stdout'
+        )
+        parser.add_argument(
+            '--format',
+            choices=['tree', 'json', 'xml'],
+            default='tree',
+            help='Output format (default: tree)'
+        )
+    
+    def handle(self, *args, **options):
+        """Execute the command."""
+        logger.info("Starting tree command")
+        try:
+            # Get django-cfg configuration
+            config = get_current_config()
+            
+            # Determine base directory
+            base_dir = self.get_base_directory(config)
+            
+            self.stdout.write(
+                self.style.SUCCESS(f"📁 Django Project Structure: {base_dir}")
+            )
+            
+            # Try to get environment info
+            try:
+                env_info = getattr(config, 'env_mode', 'unknown')
+                self.stdout.write(
+                    self.style.HTTP_INFO(f"🔧 Environment: {env_info}")
+                )
+            except Exception:
+                pass
+                
+            self.stdout.write("")
+            
+            # Check if tree command is available
+            if not self.is_tree_available():
+                self.stdout.write(
+                    self.style.WARNING("⚠️  'tree' command not found. Using fallback implementation.")
+                )
+                self.display_fallback_tree(base_dir, options)
+            else:
+                self.display_tree(base_dir, options)
+                
+        except Exception as e:
+            raise CommandError(f"Failed to display project tree: {e}")
+    
+    def get_base_directory(self, config) -> Path:
+        """Get the base directory for the Django project tree."""
+        try:
+            # First try to use PathResolver to find the actual Django project root
+            return PathResolver.find_project_root()
+        except Exception:
+            try:
+                # Try to get from config
+                if hasattr(config, 'base_dir') and config.base_dir:
+                    return Path(config.base_dir)
+                
+                # Fallback to Django BASE_DIR
+                if hasattr(settings, 'BASE_DIR'):
+                    return Path(settings.BASE_DIR)
+                
+                # Last resort: current working directory
+                return Path.cwd()
+                
+            except Exception as e:
+                self.stdout.write(
+                    self.style.WARNING(f"Could not determine base directory: {e}")
+                )
+                return Path.cwd()
+    
+    def is_tree_available(self) -> bool:
+        """Check if tree command is available."""
+        try:
+            subprocess.run(['tree', '--version'], 
+                         capture_output=True, 
+                         check=True)
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+    
+    def build_ignore_pattern(self, options) -> str:
+        """Build ignore pattern for tree command."""
+        if options['no_ignore']:
+            return ""
+        
+        # Default ignore patterns
+        default_ignores = [
+            'node_modules',
+            '.git',
+            '.venv',
+            'venv',
+            '.env',
+            '.DS_Store',
+            '__pycache__',
+            '*.pyc',
+            '*.pyo',
+            '*.pyd',
+            '.pytest_cache',
+            '.coverage',
+            'htmlcov',
+            'coverage',
+            '.tox',
+            'dist',
+            'build',
+            '*.egg-info',
+            'staticfiles',
+            'media',
+            '@old*',
+            'parsers',
+            'openapi',
+            'modules',
+            'django_cfg',
+            # Package manager files
+            'package-lock.json',
+            'pnpm-lock.yaml', 
+            'poetry.lock',
+            'yarn.lock',
+            # Empty/system directories
+            'db',
+            'static'
+        ]
+        
+        # Conditionally add patterns based on options
+        # Note: @docs folders are now included by default to show documentation
+            
+        if not options.get('include_docker'):
+            default_ignores.extend([
+                'docker',
+                'devops'
+            ])
+            
+        if not options.get('include_logs'):
+            default_ignores.extend([
+                'logs',
+                '*.log',
+                'log'
+            ])
+        
+        # Add custom ignores
+        if options['custom_ignore']:
+            custom_ignores = options['custom_ignore'].split('|')
+            default_ignores.extend(custom_ignores)
+        
+        return '|'.join(default_ignores)
+    
+    def display_tree(self, base_dir: Path, options):
+        """Display tree using system tree command."""
+        try:
+            # Build tree command
+            cmd = ['tree']
+            
+            # Add ignore pattern
+            ignore_pattern = self.build_ignore_pattern(options)
+            if ignore_pattern:
+                cmd.extend(['-I', ignore_pattern])
+            
+            # Add options
+            cmd.append('--dirsfirst')  # Directories first
+            
+            if options['depth']:
+                cmd.extend(['-L', str(options['depth'])])
+            
+            if options['dirs_only']:
+                cmd.append('-d')
+            
+            if options['all']:
+                cmd.append('-a')
+            
+            # Add format options
+            if options['format'] == 'json':
+                cmd.append('-J')
+            elif options['format'] == 'xml':
+                cmd.append('-X')
+            
+            # Add base directory
+            cmd.append(str(base_dir))
+            
+            # Execute command
+            if options['output']:
+                with open(options['output'], 'w') as f:
+                    result = subprocess.run(cmd, stdout=f, stderr=subprocess.PIPE, text=True)
+                if result.returncode == 0:
+                    self.stdout.write(
+                        self.style.SUCCESS(f"✅ Tree output saved to: {options['output']}")
+                    )
+                else:
+                    self.stdout.write(
+                        self.style.ERROR(f"❌ Tree command failed: {result.stderr}")
+                    )
+            else:
+                result = subprocess.run(cmd, text=True)
+                if result.returncode != 0:
+                    self.stdout.write(
+                        self.style.ERROR("❌ Tree command failed")
+                    )
+                    
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(f"❌ Failed to execute tree command: {e}")
+            )
+            self.display_fallback_tree(base_dir, options)
+    
+    def display_fallback_tree(self, base_dir: Path, options):
+        """Fallback tree implementation using Python."""
+        self.stdout.write("🐍 Using Python fallback implementation:")
+        self.stdout.write("")
+        
+        ignore_patterns = self.build_ignore_pattern(options).split('|') if not options['no_ignore'] else []
+        
+        def should_ignore(path: Path) -> bool:
+            """Check if path should be ignored."""
+            name = path.name
+            for pattern in ignore_patterns:
+                if pattern.startswith('*'):
+                    if name.endswith(pattern[1:]):
+                        return True
+                elif pattern.endswith('*'):
+                    if name.startswith(pattern[:-1]):
+                        return True
+                elif pattern == name:
+                    return True
+            return False
+        
+        def print_tree(directory: Path, prefix: str = "", depth: int = 0):
+            """Recursively print directory tree."""
+            if options['depth'] and depth >= options['depth']:
+                return
+            
+            try:
+                items = []
+                for item in directory.iterdir():
+                    if not options['all'] and item.name.startswith('.'):
+                        continue
+                    if should_ignore(item):
+                        continue
+                    items.append(item)
+                
+                # Sort: directories first, then files
+                items.sort(key=lambda x: (not x.is_dir(), x.name.lower()))
+                
+                for i, item in enumerate(items):
+                    is_last = i == len(items) - 1
+                    current_prefix = "└── " if is_last else "├── "
+                    
+                    if item.is_dir():
+                        self.stdout.write(f"{prefix}{current_prefix}📁 {item.name}/")
+                        if not options['dirs_only']:
+                            next_prefix = prefix + ("    " if is_last else "│   ")
+                            print_tree(item, next_prefix, depth + 1)
+                    elif not options['dirs_only']:
+                        # Add file type emoji
+                        emoji = self.get_file_emoji(item)
+                        self.stdout.write(f"{prefix}{current_prefix}{emoji} {item.name}")
+                        
+            except PermissionError:
+                self.stdout.write(f"{prefix}❌ Permission denied")
+        
+        print_tree(base_dir)
+    
+    def get_file_emoji(self, file_path: Path) -> str:
+        """Get emoji for file type."""
+        suffix = file_path.suffix.lower()
+        
+        emoji_map = {
+            '.py': '🐍',
+            '.js': '📜',
+            '.ts': '📘',
+            '.html': '🌐',
+            '.css': '🎨',
+            '.scss': '🎨',
+            '.json': '📋',
+            '.yaml': '📄',
+            '.yml': '📄',
+            '.toml': '⚙️',
+            '.ini': '⚙️',
+            '.cfg': '⚙️',
+            '.conf': '⚙️',
+            '.md': '📝',
+            '.txt': '📄',
+            '.log': '📊',
+            '.sql': '🗄️',
+            '.db': '🗄️',
+            '.sqlite': '🗄️',
+            '.sqlite3': '🗄️',
+            '.png': '🖼️',
+            '.jpg': '🖼️',
+            '.jpeg': '🖼️',
+            '.gif': '🖼️',
+            '.svg': '🖼️',
+            '.ico': '🖼️',
+            '.pdf': '📕',
+            '.zip': '📦',
+            '.tar': '📦',
+            '.gz': '📦',
+            '.requirements': '📋',
+            'requirements.txt': '📋',
+            'Dockerfile': '🐳',
+            'docker-compose.yml': '🐳',
+            'manage.py': '⚙️',
+            'setup.py': '⚙️',
+            'pyproject.toml': '📦',
+            'poetry.lock': '🔒',
+            'Pipfile': '📦',
+            'Pipfile.lock': '🔒',
+        }
+        
+        # Check full filename first
+        if file_path.name in emoji_map:
+            return emoji_map[file_path.name]
+        
+        # Then check extension
+        return emoji_map.get(suffix, '📄')