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

django_cfg/management/commands/clear_constance.py

@@ -1,208 +1,20 @@
 """
-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
-
-
-
+Django-CFG wrapper for clear_constance command.
 
-class Command(BaseCommand):
-    logger = get_logger('clear_constance')
+This is a simple alias for django_admin.management.commands.clear_constance.
+All logic is in django_admin module.
 
-    # 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)
+Usage:
+    python manage.py clear_constance
+"""
 
-    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')
+from django_cfg.modules.django_admin.management.commands.clear_constance import Command as ClearConstanceCommand
 
-    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'))
+class Command(ClearConstanceCommand):
+    """
+    Alias for clear_constance command.
 
-    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}')
+    Simply inherits from ClearConstanceCommand without any changes.
+    """
+    pass

django_cfg/management/commands/create_token.py

@@ -1,328 +1,20 @@
 """
-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()
+Django-CFG wrapper for create_token command.
 
-    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'))
+This is a simple alias for django_admin.management.commands.create_token.
+All logic is in django_admin module.
 
-        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=...')
+Usage:
+    python manage.py create_token
+"""
 
-    def generate_token(self, length=32):
-        """Generate random token"""
-        alphabet = string.ascii_letters + string.digits
-        return ''.join(secrets.choice(alphabet) for _ in range(length))
+from django_cfg.modules.django_admin.management.commands.create_token import Command as CreateTokenCommand
 
-    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))
+class Command(CreateTokenCommand):
+    """
+    Alias for create_token command.
 
-    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}')
+    Simply inherits from CreateTokenCommand without any changes.
+    """
+    pass

django_cfg/management/commands/generate_clients.py

@@ -0,0 +1,23 @@
+"""
+Django-CFG wrapper for generate_client command.
+
+This is a simple alias for django_client.management.commands.generate_client.
+All logic is in django_client module.
+
+Usage:
+    python manage.py generate_clients --groups blog shop
+    python manage.py generate_clients --python
+    python manage.py generate_clients --list-groups
+"""
+
+from django_cfg.modules.django_client.management.commands.generate_client import Command as DjangoClientCommand
+
+
+class Command(DjangoClientCommand):
+    """
+    Alias for generate_client command.
+
+    Simply inherits from DjangoClientCommand without any changes.
+    This allows both 'generate_client' and 'generate_clients' to work.
+    """
+    pass