django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/modules/django_admin/mixins/standalone_actions_mixin.py

@@ -0,0 +1,202 @@
+"""
+Standalone Actions Mixin for Django Admin.
+
+Provides convenient decorators and utilities for creating standalone action buttons
+that work independently of selected items (not bulk actions).
+"""
+
+from typing import Callable, Optional, Any
+from functools import wraps
+from django.contrib import messages
+from django.shortcuts import redirect
+from django.http import HttpResponse
+import threading
+
+from unfold.decorators import action as unfold_action
+from unfold.enums import ActionVariant as UnfoldActionVariant
+from django_cfg.modules.django_logger import get_logger
+from ..models.action_models import ActionVariant
+
+
+logger = get_logger("django_admin.mixins.standalone_actions")
+
+
+def standalone_action(
+    description: str,
+    variant: Optional[ActionVariant] = None,
+    icon: Optional[str] = None,
+    url_path: Optional[str] = None,
+    background: bool = False,
+    success_message: Optional[str] = None,
+    error_message: Optional[str] = None
+):
+    """
+    Decorator for creating standalone action buttons.
+    
+    Args:
+        description: Button text
+        variant: Button style (ActionVariant enum)
+        icon: Material icon name
+        url_path: URL path for the action (auto-generated if not provided)
+        background: Run action in background thread
+        success_message: Success message template (can use {result} placeholder)
+        error_message: Error message template (can use {error} placeholder)
+    
+    Usage:
+        @standalone_action(
+            description="Update Rates",
+            variant=ActionVariant.SUCCESS,
+            icon="sync",
+            background=True,
+            success_message="💱 Rates update started! Refresh in 2-3 minutes.",
+            error_message="❌ Failed to start update: {error}"
+        )
+        def update_rates(self, request):
+            # Your logic here
+            call_command('manage_currencies', '--populate')
+            return "Update completed"
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self, request: Any) -> HttpResponse:
+            try:
+                if background:
+                    # Run in background thread
+                    def background_task():
+                        try:
+                            result = func(self, request)
+                            logger.info(f"Background action {func.__name__} completed: {result}")
+                        except Exception as e:
+                            logger.error(f"Background action {func.__name__} failed: {e}")
+                    
+                    thread = threading.Thread(target=background_task)
+                    thread.daemon = True
+                    thread.start()
+                    
+                    # Show immediate success message
+                    if success_message:
+                        messages.success(request, success_message)
+                    else:
+                        messages.success(request, f"{description} started in background.")
+                        
+                else:
+                    # Run synchronously
+                    result = func(self, request)
+                    
+                    # Show success message
+                    if success_message:
+                        msg = success_message.format(result=result) if result else success_message
+                        messages.success(request, msg)
+                    else:
+                        messages.success(request, f"{description} completed successfully.")
+                
+                logger.info(f"Standalone action {func.__name__} executed by {request.user.username}")
+                
+            except Exception as e:
+                # Show error message
+                if error_message:
+                    msg = error_message.format(error=str(e))
+                    messages.error(request, msg)
+                else:
+                    messages.error(request, f"❌ {description} failed: {str(e)}")
+                
+                logger.error(f"Standalone action {func.__name__} failed: {e}")
+            
+            # Always redirect back
+            return redirect(request.META.get('HTTP_REFERER', '/admin/'))
+        
+        # Convert ActionVariant to UnfoldActionVariant
+        unfold_variant = UnfoldActionVariant.DEFAULT
+        if variant:
+            variant_mapping = {
+                ActionVariant.DEFAULT: UnfoldActionVariant.DEFAULT,
+                ActionVariant.PRIMARY: UnfoldActionVariant.PRIMARY,
+                ActionVariant.SUCCESS: UnfoldActionVariant.SUCCESS,
+                ActionVariant.INFO: UnfoldActionVariant.INFO,
+                ActionVariant.WARNING: UnfoldActionVariant.WARNING,
+                ActionVariant.DANGER: UnfoldActionVariant.DANGER,
+            }
+            unfold_variant = variant_mapping.get(variant, UnfoldActionVariant.DEFAULT)
+        
+        # Auto-generate url_path if not provided
+        final_url_path = url_path or func.__name__.replace('_', '-')
+        
+        # Apply unfold decorator
+        decorator_kwargs = {
+            'description': description,
+            'variant': unfold_variant,
+            'url_path': final_url_path
+        }
+        if icon:
+            decorator_kwargs['icon'] = icon
+        
+        return unfold_action(**decorator_kwargs)(wrapper)
+    
+    return decorator
+
+
+class StandaloneActionsMixin:
+    """
+    Mixin for Django admin classes that provides utilities for standalone actions.
+    
+    Usage:
+        class MyAdmin(OptimizedModelAdmin, DisplayMixin, StandaloneActionsMixin, ModelAdmin):
+            actions_list = ['update_data', 'sync_external']
+            
+            @standalone_action(
+                description="Update Data",
+                variant=ActionVariant.SUCCESS,
+                icon="sync",
+                background=True
+            )
+            def update_data(self, request):
+                # Your update logic
+                return "Data updated"
+    """
+    
+    def get_standalone_actions(self):
+        """Get list of standalone action method names."""
+        return getattr(self, 'actions_list', [])
+    
+    def execute_background_task(self, task_func: Callable, *args, **kwargs):
+        """
+        Utility method to execute tasks in background.
+        
+        Args:
+            task_func: Function to execute
+            *args, **kwargs: Arguments for the function
+        """
+        def background_task():
+            try:
+                result = task_func(*args, **kwargs)
+                logger.info(f"Background task {task_func.__name__} completed: {result}")
+                return result
+            except Exception as e:
+                logger.error(f"Background task {task_func.__name__} failed: {e}")
+                raise
+        
+        thread = threading.Thread(target=background_task)
+        thread.daemon = True
+        thread.start()
+        return thread
+    
+    def send_admin_notification(self, request, message: str, level: str = 'INFO'):
+        """
+        Send notification to admin user.
+        
+        Args:
+            request: Django request object
+            message: Notification message
+            level: Message level (SUCCESS, INFO, WARNING, ERROR)
+        """
+        level_mapping = {
+            'SUCCESS': messages.SUCCESS,
+            'INFO': messages.INFO,
+            'WARNING': messages.WARNING,
+            'ERROR': messages.ERROR,
+        }
+        
+        django_level = level_mapping.get(level.upper(), messages.INFO)
+        messages.add_message(request, django_level, message)
+        
+        logger.info(f"Admin notification sent to {request.user.username}: {message}")

django_cfg/modules/django_admin/models/__init__.py

@@ -0,0 +1,20 @@
+"""
+Pydantic 2 models for configuration.
+"""
+
+from .base import BaseConfig
+from .display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
+from .badge_models import BadgeConfig, BadgeVariant, StatusBadgeConfig
+from .action_models import ActionVariant, ActionConfig
+
+__all__ = [
+    "BaseConfig",
+    "UserDisplayConfig",
+    "MoneyDisplayConfig", 
+    "DateTimeDisplayConfig",
+    "BadgeConfig",
+    "BadgeVariant",
+    "StatusBadgeConfig",
+    "ActionVariant",
+    "ActionConfig",
+]

django_cfg/modules/django_admin/models/action_models.py

@@ -0,0 +1,33 @@
+"""
+Action configuration models.
+"""
+
+from enum import Enum
+from pydantic import Field
+from typing import Optional, List
+from .base import BaseConfig
+
+
+class ActionVariant(str, Enum):
+    """
+    Action variant enum for consistent styling.
+    
+    Based on Unfold ActionVariant but with our own namespace.
+    Matches unfold.enums.ActionVariant exactly.
+    """
+    DEFAULT = "default"
+    PRIMARY = "primary"
+    SUCCESS = "success"
+    INFO = "info"
+    WARNING = "warning"
+    DANGER = "danger"
+
+
+class ActionConfig(BaseConfig):
+    """Action configuration."""
+    variant: ActionVariant = Field(default=ActionVariant.PRIMARY)
+    icon: Optional[str] = Field(default=None)
+    permissions: List[str] = Field(default=[])
+    confirm_message: Optional[str] = Field(default=None)
+    success_message: Optional[str] = Field(default=None)
+    error_message: Optional[str] = Field(default=None)

django_cfg/modules/django_admin/models/badge_models.py

@@ -0,0 +1,20 @@
+"""
+Badge configuration models.
+"""
+
+from pydantic import Field
+from typing import Optional, Dict
+from .base import BaseConfig, BadgeVariant
+
+
+class BadgeConfig(BaseConfig):
+    """Base badge configuration."""
+    variant: BadgeVariant = Field(default=BadgeVariant.INFO)
+    icon: Optional[str] = Field(default=None)
+    css_classes: list = Field(default=[])
+
+
+class StatusBadgeConfig(BadgeConfig):
+    """Status badge configuration."""
+    custom_mappings: Dict[str, str] = Field(default={})
+    show_icons: bool = Field(default=True)

django_cfg/modules/django_admin/models/base.py

@@ -0,0 +1,26 @@
+"""
+Base Pydantic 2 models.
+"""
+
+from pydantic import BaseModel, Field, ConfigDict
+from typing import List
+from enum import Enum
+
+
+class BaseConfig(BaseModel):
+    """Base configuration for all utilities."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    cache_timeout: int = Field(default=300, ge=0, le=3600)
+    enable_icons: bool = Field(default=True)
+    debug_mode: bool = Field(default=False)
+
+
+class BadgeVariant(str, Enum):
+    """Badge color variants."""
+    SUCCESS = "success"
+    WARNING = "warning"
+    DANGER = "danger"
+    INFO = "info"
+    PRIMARY = "primary"
+    SECONDARY = "secondary"

django_cfg/modules/django_admin/models/display_models.py

@@ -0,0 +1,31 @@
+"""
+Display configuration models.
+"""
+
+from pydantic import Field
+from .base import BaseConfig
+
+
+class UserDisplayConfig(BaseConfig):
+    """User display configuration."""
+    show_email: bool = Field(default=True)
+    show_avatar: bool = Field(default=True)
+    avatar_size: int = Field(default=32, ge=16, le=128)
+
+
+class MoneyDisplayConfig(BaseConfig):
+    """Money display configuration."""
+    currency: str = Field(default="USD", min_length=3, max_length=3)
+    show_sign: bool = Field(default=True)
+    decimal_places: int = Field(default=2, ge=0, le=8)
+    thousand_separator: bool = Field(default=True)
+    show_currency_symbol: bool = Field(default=True)
+    smart_decimal_places: bool = Field(default=False)  # Auto-adjust decimal places based on value
+    rate_mode: bool = Field(default=False)  # Special formatting for exchange rates
+
+
+class DateTimeDisplayConfig(BaseConfig):
+    """DateTime display configuration."""
+    show_relative: bool = Field(default=True)
+    show_seconds: bool = Field(default=False)
+    datetime_format: str = Field(default="%Y-%m-%d %H:%M:%S")

django_cfg/modules/django_admin/utils/badges.py

@@ -0,0 +1,159 @@
+"""
+Badge utilities with Material Icons.
+"""
+
+import logging
+from typing import Optional, Union
+from django.utils.html import format_html, escape
+from django.utils.safestring import SafeString
+from django.contrib.humanize.templatetags.humanize import intcomma
+
+from ..models.badge_models import BadgeConfig, StatusBadgeConfig
+from ..models.base import BadgeVariant
+from ..icons import Icons
+
+logger = logging.getLogger(__name__)
+
+
+class StatusBadge:
+    """Status badge utilities."""
+    
+    # Status mappings
+    STATUS_MAPPINGS = {
+        'active': BadgeVariant.SUCCESS,
+        'success': BadgeVariant.SUCCESS,
+        'completed': BadgeVariant.SUCCESS,
+        'pending': BadgeVariant.WARNING,
+        'processing': BadgeVariant.WARNING,
+        'failed': BadgeVariant.DANGER,
+        'error': BadgeVariant.DANGER,
+        'cancelled': BadgeVariant.DANGER,
+        'inactive': BadgeVariant.SECONDARY,
+    }
+    
+    # Variant classes with semantic colors
+    VARIANT_CLASSES = {
+        BadgeVariant.SUCCESS: 'bg-success-100 text-success-800 dark:bg-success-900 dark:text-success-200',
+        BadgeVariant.WARNING: 'bg-warning-100 text-warning-800 dark:bg-warning-900 dark:text-warning-200',
+        BadgeVariant.DANGER: 'bg-danger-100 text-danger-800 dark:bg-danger-900 dark:text-danger-200',
+        BadgeVariant.INFO: 'bg-info-100 text-info-800 dark:bg-info-900 dark:text-info-200',
+        BadgeVariant.PRIMARY: 'bg-primary-100 text-primary-800 dark:bg-primary-900 dark:text-primary-200',
+        BadgeVariant.SECONDARY: 'bg-base-100 text-font-default-light dark:bg-base-800 dark:text-font-default-dark',
+    }
+    
+    @classmethod
+    def auto(cls, status: str, config: Optional[StatusBadgeConfig] = None) -> SafeString:
+        """Auto status badge with color mapping."""
+        config = config or StatusBadgeConfig()
+        
+        if not status:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+        
+        # Determine variant
+        status_lower = status.lower().replace('_', '').replace('-', '')
+        variant = BadgeVariant.INFO
+        
+        for keyword, mapped_variant in cls.STATUS_MAPPINGS.items():
+            if keyword in status_lower:
+                variant = mapped_variant
+                break
+        
+        # Use custom mapping if provided
+        if config.custom_mappings and status in config.custom_mappings:
+            variant_str = config.custom_mappings[status]
+            try:
+                variant = BadgeVariant(variant_str)
+            except ValueError:
+                pass
+        
+        return cls.create(status.replace('_', ' ').title(), variant, config)
+    
+    @classmethod
+    def create(cls, text: str, variant: Union[BadgeVariant, str] = BadgeVariant.INFO, 
+              config: Optional[StatusBadgeConfig] = None, icon: Optional[str] = None) -> SafeString:
+        """Create custom badge."""
+        config = config or StatusBadgeConfig()
+        
+        if isinstance(variant, str):
+            try:
+                variant = BadgeVariant(variant)
+            except ValueError:
+                variant = BadgeVariant.INFO
+        
+        css_classes = cls.VARIANT_CLASSES.get(variant, cls.VARIANT_CLASSES[BadgeVariant.INFO])
+        
+        if config.css_classes:
+            css_classes += ' ' + ' '.join(config.css_classes)
+        
+        # Icon with Material Icons integration
+        icon_html = ""
+        if icon or (config.show_icons and config.icon):
+            icon_to_use = icon or config.icon
+            if icon_to_use:
+                # Use custom icon
+                icon_html = format_html('<span class="material-symbols-outlined text-xs mr-1">{}</span>', icon_to_use)
+            else:
+                # Auto-detect icon based on variant
+                icon_map = {
+                    BadgeVariant.SUCCESS: Icons.CHECK_CIRCLE,
+                    BadgeVariant.WARNING: Icons.WARNING,
+                    BadgeVariant.DANGER: Icons.ERROR,
+                    BadgeVariant.INFO: Icons.INFO,
+                    BadgeVariant.PRIMARY: Icons.STAR,
+                    BadgeVariant.SECONDARY: Icons.INFO,
+                }
+                icon_name = icon_map.get(variant, Icons.INFO)
+                icon_html = format_html('<span class="material-symbols-outlined text-xs mr-1">{}</span>', icon_name)
+        
+        return format_html(
+            '<span class="inline-flex items-center rounded-full px-2.5 py-0.5 text-xs font-medium {}">'
+            '{}{}'
+            '</span>',
+            css_classes, icon_html, escape(text)
+        )
+
+
+class ProgressBadge:
+    """Progress badge utilities."""
+    
+    @classmethod
+    def percentage(cls, percentage: Union[int, float]) -> SafeString:
+        """Progress badge with percentage."""
+        percentage = max(0, min(100, float(percentage)))
+        
+        if percentage >= 100:
+            variant = BadgeVariant.SUCCESS
+        elif percentage >= 75:
+            variant = BadgeVariant.INFO
+        elif percentage >= 50:
+            variant = BadgeVariant.WARNING
+        else:
+            variant = BadgeVariant.SECONDARY
+        
+        return StatusBadge.create(f"{percentage:.0f}%", variant)
+
+
+class CounterBadge:
+    """Counter badge utilities."""
+    
+    @classmethod
+    def simple(cls, count: int, label: str = None) -> SafeString:
+        """Simple counter badge."""
+        if count == 0:
+            variant = BadgeVariant.SECONDARY
+        elif count < 10:
+            variant = BadgeVariant.INFO
+        elif count < 100:
+            variant = BadgeVariant.WARNING
+        else:
+            variant = BadgeVariant.SUCCESS
+        
+        # Format with humanize for large numbers
+        if count >= 1000:
+            count_text = intcomma(count)
+        else:
+            count_text = str(count)
+        
+        display_text = f"{count_text} {label}" if label else count_text
+        
+        return StatusBadge.create(display_text, variant)