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

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

@@ -0,0 +1,328 @@
+"""
+Create Token Command for Django Config Toolkit
+Generate API tokens and authentication tokens.
+"""
+
+import os
+import secrets
+import string
+from pathlib import Path
+from django.core.management.base import BaseCommand
+from django.contrib.auth import get_user_model
+from django.conf import settings
+import questionary
+from datetime import datetime, timedelta
+from django_cfg.modules.django_logging import get_logger
+
+User = get_user_model()
+
+
+logger = get_logger('create_token')
+
+class Command(BaseCommand):
+    # Web execution metadata
+    web_executable = False
+    requires_input = True
+    is_destructive = False
+
+    help = 'Create API tokens and authentication tokens'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--user',
+            type=str,
+            help='Username to create token for'
+        )
+        parser.add_argument(
+            '--type',
+            type=str,
+            choices=['api', 'auth', 'secret'],
+            help='Type of token to create'
+        )
+        parser.add_argument(
+            '--length',
+            type=int,
+            default=32,
+            help='Token length (default: 32)'
+        )
+        parser.add_argument(
+            '--expires',
+            type=int,
+            help='Token expiration in days'
+        )
+
+    def handle(self, *args, **options):
+        logger.info("Starting create_token command")
+        if options['user'] and options['type']:
+            self.create_token_for_user(
+                username=options['user'],
+                token_type=options['type'],
+                length=options['length'],
+                expires_days=options['expires']
+            )
+        else:
+            self.show_interactive_menu()
+
+    def show_interactive_menu(self):
+        """Show interactive menu with token creation options"""
+        self.stdout.write(self.style.SUCCESS('\n🔑 Token Creation Tool - Django Config Toolkit\n'))
+
+        choices = [
+            questionary.Choice('🔑 Create API Token', value='api'),
+            questionary.Choice('🔐 Create Auth Token', value='auth'),
+            questionary.Choice('🔒 Create Secret Key', value='secret'),
+            questionary.Choice('👤 Create Token for User', value='user'),
+            questionary.Choice('📝 Generate Django Secret Key', value='django_secret'),
+            questionary.Choice('❌ Exit', value='exit')
+        ]
+
+        choice = questionary.select(
+            'Select token type:',
+            choices=choices
+        ).ask()
+
+        if choice == 'api':
+            self.create_api_token()
+        elif choice == 'auth':
+            self.create_auth_token()
+        elif choice == 'secret':
+            self.create_secret_key()
+        elif choice == 'user':
+            self.create_token_for_user_interactive()
+        elif choice == 'django_secret':
+            self.generate_django_secret_key()
+        elif choice == 'exit':
+            self.stdout.write('Goodbye! 👋')
+            return
+
+    def create_api_token(self):
+        """Create API token"""
+        self.stdout.write(self.style.SUCCESS('🔑 Creating API Token...'))
+        
+        # Get token details
+        token_name = questionary.text('Token name:').ask()
+        if not token_name:
+            self.stdout.write(self.style.ERROR('❌ Token name is required'))
+            return
+        
+        token_length = questionary.select(
+            'Token length:',
+            choices=['32', '64', '128', '256']
+        ).ask()
+        
+        expires = questionary.select(
+            'Token expiration:',
+            choices=['Never', '30 days', '90 days', '1 year']
+        ).ask()
+        
+        # Generate token
+        token = self.generate_token(int(token_length))
+        
+        # Calculate expiration
+        expiration_date = None
+        if expires != 'Never':
+            days_map = {
+                '30 days': 30,
+                '90 days': 90,
+                '1 year': 365
+            }
+            expiration_date = datetime.now() + timedelta(days=days_map[expires])
+        
+        # Save token (in a real app, you'd save to database)
+        self.save_token_to_file('api_token', token, token_name, expiration_date)
+        
+        self.stdout.write(self.style.SUCCESS(f'✅ API Token created: {token}'))
+        self.stdout.write(f'📝 Name: {token_name}')
+        if expiration_date:
+            self.stdout.write(f'⏰ Expires: {expiration_date.strftime("%Y-%m-%d %H:%M:%S")}')
+
+    def create_auth_token(self):
+        """Create authentication token"""
+        self.stdout.write(self.style.SUCCESS('🔐 Creating Auth Token...'))
+        
+        # Get token details
+        token_name = questionary.text('Token name:').ask()
+        if not token_name:
+            self.stdout.write(self.style.ERROR('❌ Token name is required'))
+            return
+        
+        token_length = questionary.select(
+            'Token length:',
+            choices=['32', '64', '128']
+        ).ask()
+        
+        # Generate token
+        token = self.generate_token(int(token_length))
+        
+        # Save token
+        self.save_token_to_file('auth_token', token, token_name)
+        
+        self.stdout.write(self.style.SUCCESS(f'✅ Auth Token created: {token}'))
+        self.stdout.write(f'📝 Name: {token_name}')
+
+    def create_secret_key(self):
+        """Create secret key"""
+        self.stdout.write(self.style.SUCCESS('🔒 Creating Secret Key...'))
+        
+        # Get key details
+        key_name = questionary.text('Secret key name:').ask()
+        if not key_name:
+            self.stdout.write(self.style.ERROR('❌ Key name is required'))
+            return
+        
+        key_length = questionary.select(
+            'Key length:',
+            choices=['32', '64', '128', '256']
+        ).ask()
+        
+        # Generate secret key
+        secret_key = self.generate_secret_key(int(key_length))
+        
+        # Save key
+        self.save_token_to_file('secret_key', secret_key, key_name)
+        
+        self.stdout.write(self.style.SUCCESS(f'✅ Secret Key created: {secret_key}'))
+        self.stdout.write(f'📝 Name: {key_name}')
+
+    def create_token_for_user_interactive(self):
+        """Create token for user interactively"""
+        self.stdout.write(self.style.SUCCESS('👤 Creating Token for User...'))
+        
+        # Get user
+        username = questionary.text('Username:').ask()
+        if not username:
+            self.stdout.write(self.style.ERROR('❌ Username is required'))
+            return
+        
+        # Check if user exists
+        try:
+            user = User.objects.get(username=username)
+        except User.DoesNotExist:
+            self.stdout.write(self.style.ERROR(f'❌ User {username} does not exist'))
+            return
+        
+        # Get token type
+        token_type = questionary.select(
+            'Token type:',
+            choices=['API Token', 'Auth Token', 'Secret Key']
+        ).ask()
+        
+        # Get token length
+        token_length = questionary.select(
+            'Token length:',
+            choices=['32', '64', '128']
+        ).ask()
+        
+        # Get expiration
+        expires = questionary.select(
+            'Token expiration:',
+            choices=['Never', '30 days', '90 days', '1 year']
+        ).ask()
+        
+        # Create token
+        self.create_token_for_user(
+            username=username,
+            token_type=token_type.lower().replace(' ', '_'),
+            length=int(token_length),
+            expires_days=None if expires == 'Never' else {
+                '30 days': 30,
+                '90 days': 90,
+                '1 year': 365
+            }[expires]
+        )
+
+    def create_token_for_user(self, username, token_type, length=32, expires_days=None):
+        """Create token for specific user"""
+        try:
+            user = User.objects.get(username=username)
+        except User.DoesNotExist:
+            self.stdout.write(self.style.ERROR(f'❌ User {username} does not exist'))
+            return
+        
+        # Generate token
+        if token_type == 'secret_key':
+            token = self.generate_secret_key(length)
+        else:
+            token = self.generate_token(length)
+        
+        # Calculate expiration
+        expiration_date = None
+        if expires_days:
+            expiration_date = datetime.now() + timedelta(days=expires_days)
+        
+        # Save token
+        token_name = f"{username}_{token_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        self.save_token_to_file(token_type, token, token_name, expiration_date, user)
+        
+        self.stdout.write(self.style.SUCCESS(f'✅ {token_type.title()} created for {username}'))
+        self.stdout.write(f'🔑 Token: {token}')
+        self.stdout.write(f'📝 Name: {token_name}')
+        if expiration_date:
+            self.stdout.write(f'⏰ Expires: {expiration_date.strftime("%Y-%m-%d %H:%M:%S")}')
+
+    def generate_django_secret_key(self):
+        """Generate Django secret key"""
+        self.stdout.write(self.style.SUCCESS('🔐 Generating Django Secret Key...'))
+        
+        # Generate Django-compatible secret key
+        secret_key = self.generate_django_secret()
+        
+        # Save to file
+        self.save_token_to_file('django_secret', secret_key, 'django_secret_key')
+        
+        self.stdout.write(self.style.SUCCESS(f'✅ Django Secret Key generated: {secret_key}'))
+        self.stdout.write('💡 Add this to your .env file as SECRET_KEY=...')
+
+    def generate_token(self, length=32):
+        """Generate random token"""
+        alphabet = string.ascii_letters + string.digits
+        return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+    def generate_secret_key(self, length=64):
+        """Generate secret key"""
+        alphabet = string.ascii_letters + string.digits + string.punctuation
+        # Remove characters that might cause issues in config files
+        alphabet = alphabet.replace('"', '').replace("'", '').replace('\\', '')
+        return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+    def generate_django_secret(self):
+        """Generate Django-compatible secret key"""
+        return ''.join(secrets.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(50))
+
+    def save_token_to_file(self, token_type, token, name, expiration_date=None, user=None):
+        """Save token to file"""
+        # Create tokens directory
+        tokens_dir = Path('tokens')
+        tokens_dir.mkdir(exist_ok=True)
+        
+        # Create token file
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        filename = f"{token_type}_{name}_{timestamp}.txt"
+        filepath = tokens_dir / filename
+        
+        with open(filepath, 'w') as f:
+            f.write(f"Token Type: {token_type}\n")
+            f.write(f"Name: {name}\n")
+            f.write(f"Token: {token}\n")
+            f.write(f"Created: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            if expiration_date:
+                f.write(f"Expires: {expiration_date.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            if user:
+                f.write(f"User: {user.username} ({user.email})\n")
+            f.write(f"\n# Add to your configuration:\n")
+            f.write(f"# {token_type.upper()}_KEY={token}\n")
+        
+        self.stdout.write(f'💾 Token saved to: {filepath}')
+        
+        # Also save to .env format
+        env_filename = f"{token_type}_{name}_{timestamp}.env"
+        env_filepath = tokens_dir / env_filename
+        
+        with open(env_filepath, 'w') as f:
+            f.write(f"# {token_type.title()} - {name}\n")
+            f.write(f"# Created: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            if expiration_date:
+                f.write(f"# Expires: {expiration_date.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"{token_type.upper()}_KEY={token}\n")
+        
+        self.stdout.write(f'💾 Environment file saved to: {env_filepath}')

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

@@ -0,0 +1,313 @@
+"""
+Show URLs Command
+
+Display all available URLs in the Django project with Rich formatting.
+Useful for development and webhook configuration.
+"""
+
+import re
+from django.core.management.base import BaseCommand
+from django.urls import get_resolver
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+
+# Rich imports for beautiful output
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+from rich.align import Align
+
+from django_cfg.core.state import get_current_config
+
+
+logger = get_logger('list_urls')
+
+class Command(BaseCommand):
+    """Command to display all available URLs in the project."""
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Display all available URLs with Rich formatting"
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.console = Console()
+        self.config = None
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--filter",
+            type=str,
+            help="Filter URLs containing this string",
+            default=None
+        )
+        parser.add_argument(
+            "--webhook",
+            action="store_true",
+            help="Show only webhook-related URLs"
+        )
+        parser.add_argument(
+            "--api",
+            action="store_true",
+            help="Show only API URLs"
+        )
+        parser.add_argument(
+            "--with-ngrok",
+            action="store_true",
+            help="Show ngrok URLs alongside local URLs"
+        )
+
+    def handle(self, *args, **options):
+        logger.info("Starting list_urls command")
+        filter_str = options["filter"]
+        webhook_only = options["webhook"]
+        api_only = options["api"]
+        with_ngrok = options["with_ngrok"]
+
+        # Show header
+        self.show_header()
+
+        # Load config
+        self.load_config()
+
+        # Get all URLs
+        urls = self.get_all_urls()
+
+        # Filter URLs
+        if filter_str:
+            urls = [url for url in urls if filter_str.lower() in url['pattern'].lower()]
+        
+        if webhook_only:
+            urls = [url for url in urls if 'webhook' in url['pattern'].lower() or 'hook' in url['pattern'].lower()]
+        
+        if api_only:
+            urls = [url for url in urls if '/api/' in url['pattern'] or url['pattern'].startswith('api/')]
+
+        # Display URLs
+        self.display_urls(urls, with_ngrok)
+
+        # Show webhook info if requested
+        if webhook_only or with_ngrok:
+            self.show_webhook_info()
+
+    def show_header(self):
+        """Show beautiful header with Rich."""
+        title = Text("Django URLs Overview", style="bold cyan")
+        subtitle = Text("All available URLs in your project", style="dim")
+        
+        header_content = Align.center(
+            Text.assemble(
+                title, "\n",
+                subtitle
+            )
+        )
+        
+        self.console.print()
+        self.console.print(Panel(
+            header_content,
+            title="🔗 URL Inspector",
+            border_style="bright_blue",
+            padding=(1, 2)
+        ))
+
+    def load_config(self):
+        """Load Django CFG configuration."""
+        try:
+            self.config = get_current_config()
+        except Exception as e:
+            self.console.print(f"[yellow]⚠️  Failed to load config: {e}[/yellow]")
+            self.config = None
+
+    def get_all_urls(self):
+        """Extract all URLs from Django URL configuration."""
+        urls = []
+        resolver = get_resolver()
+        
+        def extract_urls(url_patterns, prefix=''):
+            for pattern in url_patterns:
+                if hasattr(pattern, 'url_patterns'):
+                    # This is an include() - recurse
+                    new_prefix = prefix + str(pattern.pattern)
+                    extract_urls(pattern.url_patterns, new_prefix)
+                else:
+                    # This is a regular URL pattern
+                    full_pattern = prefix + str(pattern.pattern)
+                    
+                    # Clean up the pattern
+                    clean_pattern = re.sub(r'\^|\$', '', full_pattern)
+                    clean_pattern = re.sub(r'\\/', '/', clean_pattern)
+                    
+                    # Get view info
+                    view_name = getattr(pattern, 'name', None)
+                    view_func = getattr(pattern, 'callback', None)
+                    
+                    if view_func:
+                        if hasattr(view_func, 'view_class'):
+                            # Class-based view
+                            view_info = f"{view_func.view_class.__name__}"
+                            module = view_func.view_class.__module__
+                        elif hasattr(view_func, '__name__'):
+                            # Function-based view
+                            view_info = f"{view_func.__name__}()"
+                            module = getattr(view_func, '__module__', 'unknown')
+                        else:
+                            view_info = str(view_func)
+                            module = 'unknown'
+                    else:
+                        view_info = 'Unknown'
+                        module = 'unknown'
+                    
+                    urls.append({
+                        'pattern': clean_pattern,
+                        'name': view_name,
+                        'view': view_info,
+                        'module': module
+                    })
+        
+        extract_urls(resolver.url_patterns)
+        return urls
+
+    def display_urls(self, urls, with_ngrok=False):
+        """Display URLs in a Rich table."""
+        if not urls:
+            self.console.print("[yellow]No URLs found matching the criteria.[/yellow]")
+            return
+
+        # Create table
+        table = Table(title=f"🔗 Found {len(urls)} URLs", show_header=True, header_style="bold cyan")
+        table.add_column("URL Pattern", style="cyan", width=40)
+        table.add_column("Name", style="white", width=20)
+        table.add_column("View", style="green", width=25)
+        
+        if with_ngrok:
+            table.add_column("Ngrok URL", style="magenta", width=40)
+
+        # Get base URLs
+        base_url = self.get_base_url()
+        ngrok_url = self.get_ngrok_url() if with_ngrok else None
+
+        # Add rows
+        for url in urls[:50]:  # Limit to first 50 URLs
+            pattern = url['pattern']
+            name = url['name'] or '—'
+            view = url['view']
+            
+            # Truncate long view names
+            if len(view) > 23:
+                view = view[:20] + "..."
+            
+            row = [pattern, name, view]
+            
+            if with_ngrok:
+                if ngrok_url:
+                    full_ngrok_url = f"{ngrok_url.rstrip('/')}/{pattern.lstrip('/')}"
+                    row.append(full_ngrok_url)
+                else:
+                    row.append("—")
+            
+            table.add_row(*row)
+
+        if len(urls) > 50:
+            table.caption = f"Showing first 50 of {len(urls)} URLs"
+
+        self.console.print(table)
+
+        # Show base URL info
+        info_table = Table(show_header=False, box=None)
+        info_table.add_column("Info", style="cyan")
+        info_table.add_column("Value", style="white")
+        
+        info_table.add_row("🌐 Base URL:", base_url)
+        if with_ngrok and ngrok_url:
+            info_table.add_row("🔗 Ngrok URL:", ngrok_url)
+        
+        self.console.print()
+        self.console.print(info_table)
+
+    def show_webhook_info(self):
+        """Show webhook-specific information using reverse."""
+        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]")
+
+    def get_base_url(self):
+        """Get base URL for the application."""
+        if self.config:
+            return self.config.api_url
+        else:
+            # Fallback to Django settings
+            debug = getattr(settings, 'DEBUG', True)
+            if debug:
+                return "http://localhost:8000"
+            else:
+                return "https://yourdomain.com"
+
+    def get_ngrok_url(self):
+        """Get ngrok URL if available."""
+        if self.config:
+            return self.config.get_ngrok_url()
+        return None