django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

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

@@ -0,0 +1,208 @@
+"""
+Clear Constance Command for Django Config Toolkit
+Clear Constance configuration cache and database records.
+"""
+
+from django.core.management.base import BaseCommand
+from django.core.cache import cache
+from django.conf import settings
+from django_cfg.modules.django_logging import get_logger
+
+
+
+
+class Command(BaseCommand):
+    logger = get_logger('clear_constance')
+
+    # Web execution metadata
+    web_executable = False
+    requires_input = True
+    is_destructive = True
+
+    help = 'Clear Constance configuration cache and database records'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--cache-only',
+            action='store_true',
+            help='Clear only cache, not database records'
+        )
+        parser.add_argument(
+            '--db-only',
+            action='store_true',
+            help='Clear only database records, not cache'
+        )
+        parser.add_argument(
+            '--confirm',
+            action='store_true',
+            help='Skip confirmation prompt'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be cleared without actually clearing'
+        )
+
+    def handle(self, *args, **options):
+        """Handle the command execution."""
+        self.logger.info("Starting clear_constance command")
+        self.stdout.write(self.style.SUCCESS('🧹 Constance Clear Tool - Django Config Toolkit\n'))
+        
+        # Check if constance is installed
+        if 'constance' not in settings.INSTALLED_APPS:
+            self.stdout.write(self.style.ERROR('❌ Constance is not installed or not in INSTALLED_APPS'))
+            return
+        
+        # Determine what to clear
+        clear_cache = not options['db_only']
+        clear_db = not options['cache_only']
+        
+        if options['dry_run']:
+            self._show_dry_run(clear_cache, clear_db)
+            return
+        
+        # Confirm action
+        if not options['confirm']:
+            if not self._confirm_clear(clear_cache, clear_db):
+                self.stdout.write('Operation cancelled')
+                return
+        
+        # Perform clearing
+        self._clear_constance(clear_cache, clear_db)
+
+    def _show_dry_run(self, clear_cache, clear_db):
+        """Show what would be cleared in dry run mode."""
+        self.stdout.write(self.style.SUCCESS('=== Dry Run - What would be cleared ==='))
+        
+        if clear_cache:
+            self.stdout.write('🗑️  Cache: All Django cache entries')
+            self.stdout.write('🗑️  Cache: Constance-specific cache entries')
+        
+        if clear_db:
+            self.stdout.write('🗑️  Database: All Constance configuration records')
+            
+            # Try to show current records count
+            try:
+                from django.apps import apps
+                Constance = apps.get_model('constance', 'Constance')
+                count = Constance.objects.count()
+                self.stdout.write(f'    Current records: {count}')
+            except Exception as e:
+                self.stdout.write(f'    Could not count records: {e}')
+        
+        self.stdout.write('\n✅ Dry run completed - nothing was actually cleared')
+
+    def _confirm_clear(self, clear_cache, clear_db) -> bool:
+        """Confirm the clear operation with user."""
+        actions = []
+        if clear_cache:
+            actions.append('cache')
+        if clear_db:
+            actions.append('database records')
+        
+        action_text = ' and '.join(actions)
+        
+        self.stdout.write(
+            self.style.WARNING(f'⚠️  This will clear Constance {action_text}')
+        )
+        self.stdout.write('This action cannot be undone!')
+        
+        response = input('Are you sure? [y/N]: ').lower().strip()
+        return response in ['y', 'yes']
+
+    def _clear_constance(self, clear_cache, clear_db):
+        """Clear Constance cache and/or database records."""
+        cleared_items = []
+        
+        # Clear cache
+        if clear_cache:
+            try:
+                self.stdout.write('🧹 Clearing Django cache...')
+                cache.clear()
+                self.stdout.write(self.style.SUCCESS('✅ Django cache cleared'))
+                cleared_items.append('cache')
+                
+                # Also try to clear specific constance cache keys
+                try:
+                    from constance import config as constance_config
+                    # Force reload of constance configuration
+                    if hasattr(constance_config, '_backend'):
+                        constance_config._backend = None
+                    self.stdout.write(self.style.SUCCESS('✅ Constance cache backend reset'))
+                except Exception as e:
+                    self.stdout.write(self.style.WARNING(f'⚠️  Could not reset Constance backend: {e}'))
+                
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f'❌ Failed to clear cache: {e}'))
+        
+        # Clear database records
+        if clear_db:
+            try:
+                self.stdout.write('🗑️  Clearing Constance database records...')
+                
+                from django.apps import apps
+                Constance = apps.get_model('constance', 'Constance')
+                
+                # Count records before deletion
+                count_before = Constance.objects.count()
+                self.stdout.write(f'   Found {count_before} Constance records')
+                
+                if count_before > 0:
+                    # Delete all records
+                    deleted_info = Constance.objects.all().delete()
+                    deleted_count = deleted_info[0] if deleted_info else 0
+                    
+                    self.stdout.write(self.style.SUCCESS(f'✅ Deleted {deleted_count} Constance records'))
+                    cleared_items.append(f'{deleted_count} database records')
+                else:
+                    self.stdout.write('ℹ️  No Constance records found to delete')
+                
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f'❌ Failed to clear database records: {e}'))
+        
+        # Show summary
+        if cleared_items:
+            self.stdout.write(
+                self.style.SUCCESS(f'\n🎉 Successfully cleared: {", ".join(cleared_items)}')
+            )
+            self.stdout.write('\n💡 Next steps:')
+            self.stdout.write('   1. Restart your Django server')
+            self.stdout.write('   2. Visit Django admin to reconfigure settings')
+            self.stdout.write('   3. Check that boolean fields now work correctly')
+        else:
+            self.stdout.write(self.style.WARNING('⚠️  Nothing was cleared'))
+
+    def _show_current_status(self):
+        """Show current Constance status."""
+        self.stdout.write(self.style.SUCCESS('\n📊 Current Constance Status:'))
+        
+        # Check database records
+        try:
+            from django.apps import apps
+            Constance = apps.get_model('constance', 'Constance')
+            db_count = Constance.objects.count()
+            self.stdout.write(f'   Database records: {db_count}')
+            
+            if db_count > 0:
+                self.stdout.write('   Recent records:')
+                for record in Constance.objects.all()[:5]:
+                    self.stdout.write(f'     - {record.key}: {record.value}')
+                if db_count > 5:
+                    self.stdout.write(f'     ... and {db_count - 5} more')
+        except Exception as e:
+            self.stdout.write(f'   Database: Error - {e}')
+        
+        # Check cache
+        try:
+            from django.core.cache import cache
+            # Try to get a test key to see if cache is working
+            test_key = 'constance_test_key'
+            cache.set(test_key, 'test_value', 1)
+            test_result = cache.get(test_key)
+            
+            if test_result:
+                self.stdout.write('   Cache: Working')
+            else:
+                self.stdout.write('   Cache: Not working or empty')
+        except Exception as e:
+            self.stdout.write(f'   Cache: Error - {e}')

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}')