django-cfg 1.4.58__py3-none-any.whl → 1.4.60__py3-none-any.whl

django_cfg/core/backends/smtp.py

@@ -0,0 +1,69 @@
+"""
+Custom SMTP Email Backend for Django CFG.
+
+Supports SMTP with unverified SSL certificates for development environments.
+"""
+
+import smtplib
+import ssl
+
+from django.core.mail.backends.smtp import EmailBackend as DjangoSMTPBackend
+
+
+class UnverifiedSSLEmailBackend(DjangoSMTPBackend):
+    """
+    SMTP backend that accepts self-signed SSL certificates.
+
+    WARNING: Only use in development! In production, use proper SSL certificates
+    with the standard Django SMTP backend.
+
+    This backend disables SSL certificate verification, which makes it vulnerable
+    to man-in-the-middle attacks. It's designed for dev environments where you
+    control the mail server and use self-signed certificates.
+    """
+
+    def open(self):
+        """
+        Open connection with unverified SSL context.
+
+        Overrides parent to use unverified SSL context for self-signed certs.
+        """
+        if self.connection:
+            # Already have a connection
+            return False
+
+        connection_params = {'timeout': self.timeout}
+        if self.ssl_keyfile:
+            connection_params['keyfile'] = self.ssl_keyfile
+        if self.ssl_certfile:
+            connection_params['certfile'] = self.ssl_certfile
+
+        if self.use_ssl:
+            # Create unverified SSL context (accepts self-signed certs)
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+
+            connection_params['context'] = ssl_context
+            self.connection = smtplib.SMTP_SSL(
+                self.host, self.port, **connection_params
+            )
+        else:
+            self.connection = smtplib.SMTP(
+                self.host, self.port, **connection_params
+            )
+
+            if self.use_tls:
+                # Create unverified SSL context for STARTTLS too
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+
+                self.connection.ehlo()
+                self.connection.starttls(context=ssl_context)
+                self.connection.ehlo()
+
+        if self.username and self.password:
+            self.connection.login(self.username, self.password)
+
+        return True

django_cfg/middleware/authentication.py

@@ -0,0 +1,157 @@
+"""
+Custom JWT Authentication for Django CFG.
+
+Extends rest_framework_simplejwt.authentication.JWTAuthentication to automatically
+update user's last_login field on successful authentication.
+"""
+
+import logging
+
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+logger = logging.getLogger(__name__)
+
+User = get_user_model()
+
+
+class JWTAuthenticationWithLastLogin(JWTAuthentication):
+    """
+    JWT Authentication that updates last_login on successful authentication.
+
+    Updates last_login field with intelligent throttling to avoid database spam.
+    Only updates if last_login is None or older than the configured interval.
+
+    Features:
+    - Automatic last_login tracking for all JWT-authenticated requests
+    - Built-in throttling (default: 5 minutes) to minimize database writes
+    - In-memory cache for tracking last update times
+    - Automatic cache cleanup to prevent memory leaks
+    - Error handling to prevent authentication failures
+
+    Usage:
+        Add to REST_FRAMEWORK settings:
+        'DEFAULT_AUTHENTICATION_CLASSES': [
+            'django_cfg.apps.accounts.authentication.JWTAuthenticationWithLastLogin',
+        ]
+    """
+
+    # Class-level cache to track last update times (shared across all instances)
+    _last_updates = {}
+
+    # Update interval in seconds (5 minutes by default, same as UserActivityMiddleware)
+    UPDATE_INTERVAL = 300
+
+    # Maximum cache size before cleanup (prevents memory leaks)
+    MAX_CACHE_SIZE = 1000
+    CLEANUP_CACHE_SIZE = 500
+
+    def authenticate(self, request):
+        """
+        Authenticate request and update last_login if needed.
+
+        Args:
+            request: Django HttpRequest object
+
+        Returns:
+            Tuple of (user, token) if authentication succeeds, None otherwise
+        """
+        # Perform standard JWT authentication
+        result = super().authenticate(request)
+
+        if result is not None:
+            user, token = result
+            # Update last_login with throttling
+            self._update_last_login(user)
+
+        return result
+
+    def _update_last_login(self, user):
+        """
+        Update user's last_login field with intelligent throttling.
+
+        Only updates if:
+        - last_login is None (never logged in)
+        - last_login is older than UPDATE_INTERVAL seconds
+
+        Uses UPDATE query to avoid triggering signals and save() overhead.
+
+        Args:
+            user: User instance to update
+        """
+        now = timezone.now()
+        user_id = user.pk
+
+        # Check if we should update (avoid database spam)
+        last_update = self._last_updates.get(user_id)
+        if last_update and (now - last_update).total_seconds() < self.UPDATE_INTERVAL:
+            # Skip update - too soon since last update
+            return
+
+        try:
+            # Use update() to avoid triggering signals and save() overhead
+            # This is more efficient than user.save(update_fields=['last_login'])
+            updated_count = User.objects.filter(pk=user_id).update(last_login=now)
+
+            if updated_count > 0:
+                # Cache the update time
+                self._last_updates[user_id] = now
+
+                logger.debug(
+                    f"Updated last_login for user {user.email} (ID: {user_id}) "
+                    f"via JWT authentication"
+                )
+
+                # Clean up old cache entries to prevent memory leaks
+                if len(self._last_updates) > self.MAX_CACHE_SIZE:
+                    self._cleanup_cache()
+
+        except Exception as e:
+            # Log error but don't break authentication
+            # Authentication should succeed even if last_login update fails
+            logger.error(
+                f"Failed to update last_login for user {user_id}: {e}",
+                exc_info=True
+            )
+
+    def _cleanup_cache(self):
+        """
+        Clean up old cache entries to prevent memory leaks.
+
+        Keeps only the most recent CLEANUP_CACHE_SIZE entries.
+        Sorted by update time (newest first).
+        """
+        try:
+            # Sort by update time (value), keep newest entries
+            sorted_items = sorted(
+                self._last_updates.items(),
+                key=lambda x: x[1],
+                reverse=True
+            )
+
+            # Keep only the most recent entries
+            self._last_updates = dict(sorted_items[:self.CLEANUP_CACHE_SIZE])
+
+            logger.debug(
+                f"Cleaned up last_login cache: "
+                f"kept {len(self._last_updates)} most recent entries"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to cleanup last_login cache: {e}")
+
+    @classmethod
+    def get_cache_stats(cls):
+        """
+        Get cache statistics for monitoring/debugging.
+
+        Returns:
+            dict: Cache statistics including size and configuration
+        """
+        return {
+            'cache_size': len(cls._last_updates),
+            'max_cache_size': cls.MAX_CACHE_SIZE,
+            'update_interval_seconds': cls.UPDATE_INTERVAL,
+            'update_interval_minutes': cls.UPDATE_INTERVAL / 60,
+        }

django_cfg/models/api/drf/config.py

@@ -17,12 +17,12 @@ class DRFConfig(BaseModel):
     # Authentication
     authentication_classes: List[str] = Field(
         default_factory=lambda: [
-            'rest_framework_simplejwt.authentication.JWTAuthentication',
+            'django_cfg.middleware.authentication.JWTAuthenticationWithLastLogin',
             'rest_framework.authentication.TokenAuthentication',
             # SessionAuthentication removed from defaults (requires CSRF)
             # Add it manually in your config if you need Browsable API with session auth
         ],
-        description="Default authentication classes"
+        description="Default authentication classes (JWT with auto last_login update)"
     )
 
     # Permissions

django_cfg/models/services/email.py

@@ -58,6 +58,11 @@ class EmailConfig(BaseConfig):
         description="Use SSL for SMTP"
     )
 
+    ssl_verify: bool = Field(
+        default=True,
+        description="Verify SSL certificates (set False for self-signed certs in dev)"
+    )
+
     timeout: int = Field(
         default=30,
         ge=1,
@@ -111,7 +116,12 @@ class EmailConfig(BaseConfig):
     def to_django_settings(self) -> Dict[str, Any]:
         """Convert to Django email settings."""
         if self.backend == 'smtp':
-            backend_class = 'django.core.mail.backends.smtp.EmailBackend'
+            # Choose backend based on SSL verification setting
+            if self.ssl_verify:
+                backend_class = 'django.core.mail.backends.smtp.EmailBackend'
+            else:
+                # Use custom backend that accepts self-signed SSL certs
+                backend_class = 'django_cfg.core.backends.smtp.UnverifiedSSLEmailBackend'
 
             settings = {
                 'EMAIL_BACKEND': backend_class,

django_cfg/modules/django_client/system/generate_mjs_clients.py

@@ -54,7 +54,7 @@ def main():
     django_cfg_dir = modules_dir.parent  # django_cfg
     src_dir = django_cfg_dir.parent  # src
     dev_dir = src_dir.parent  # django-cfg-dev
-    example_django_dir = dev_dir.parent / "django-cfg-example" / "django"
+    example_django_dir = dev_dir.parent / "solution" / "projects" / "django"
 
     # Output directory for MJS clients
     if args.output:

django_cfg/modules/django_dashboard/sections/widgets.py

@@ -0,0 +1,209 @@
+"""Widgets section for dashboard.
+
+Automatically renders widgets from DashboardManager.get_widgets_config()
+"""
+
+from datetime import timedelta
+from typing import Any, Dict, List
+
+import psutil
+from django.db.models import Avg
+from django.template import Context, Template
+from django.utils import timezone
+
+from .base import DataSection
+
+
+class WidgetsSection(DataSection):
+    """
+    Widgets section showing automatically generated dashboard widgets.
+
+    Widgets are defined in DashboardManager.get_widgets_config() and
+    can include:
+    - System metrics (CPU, Memory, Disk)
+    - RPC monitoring stats
+    - Custom application widgets
+    """
+
+    template_name = "admin/sections/widgets_section.html"
+    title = "Dashboard Widgets"
+    icon = "widgets"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get widgets configuration from DashboardManager."""
+        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
+
+        dashboard_manager = get_dashboard_manager()
+
+        # Get widgets from dashboard manager (base system widgets)
+        widgets = dashboard_manager.get_widgets_config()
+
+        return {
+            'widgets': widgets,
+            'widgets_count': len(widgets),
+            'has_widgets': len(widgets) > 0,
+        }
+
+    def merge_custom_widgets(self, widgets: List[Dict], custom_widgets: List[Any]) -> List[Dict]:
+        """
+        Merge custom widgets from dashboard_callback.
+
+        Allows projects to add widgets via dashboard_callback:
+            context["custom_widgets"] = [
+                StatsCardsWidget(...),
+                ...
+            ]
+        """
+        if not custom_widgets:
+            return widgets
+
+        # Convert custom widgets to dicts if they are Pydantic models
+        for widget in custom_widgets:
+            if hasattr(widget, 'to_dict'):
+                widgets.append(widget.to_dict())
+            elif hasattr(widget, 'model_dump'):
+                widgets.append(widget.model_dump())
+            elif isinstance(widget, dict):
+                widgets.append(widget)
+
+        return widgets
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """Add additional context for widget rendering."""
+        context = super().get_context_data(**kwargs)
+
+        # Get base widgets from DashboardManager
+        widgets = context['data']['widgets']
+
+        # Merge custom widgets from dashboard_callback if provided
+        custom_widgets_from_callback = kwargs.get('custom_widgets', [])
+        if custom_widgets_from_callback:
+            widgets = self.merge_custom_widgets(widgets, custom_widgets_from_callback)
+            # Update count
+            context['data']['widgets_count'] = len(widgets)
+            context['data']['has_widgets'] = len(widgets) > 0
+
+        # Get metrics data first
+        metrics_data = {}
+        metrics_data.update(self.get_system_metrics())
+
+        # Add RPC metrics if enabled
+        dashboard_manager = self._get_dashboard_manager()
+        if dashboard_manager.is_rpc_enabled():
+            metrics_data.update(self.get_rpc_metrics())
+
+        # Also merge any custom metrics from kwargs
+        custom_metrics = kwargs.get('custom_metrics', {})
+        if custom_metrics:
+            metrics_data.update(custom_metrics)
+
+        # Process widgets and resolve template variables
+        processed_stats_widgets = []
+        for widget in widgets:
+            if widget.get('type') == 'stats_cards':
+                processed_widget = self._process_stats_widget(widget, metrics_data)
+                processed_stats_widgets.append(processed_widget)
+
+        chart_widgets = [w for w in widgets if w.get('type') == 'chart']
+        custom_widgets = [w for w in widgets if w.get('type') not in ['stats_cards', 'chart']]
+
+        # Add processed widgets
+        context.update({
+            'stats_widgets': processed_stats_widgets,
+            'chart_widgets': chart_widgets,
+            'custom_widgets': custom_widgets,
+        })
+
+        # Also add metrics for direct access
+        context.update(metrics_data)
+
+        return context
+
+    def _get_dashboard_manager(self):
+        """Get dashboard manager instance (lazy import to avoid circular dependencies)."""
+        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
+        return get_dashboard_manager()
+
+    def _process_stats_widget(self, widget: Dict[str, Any], context_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Process StatsCardsWidget and resolve template variables in cards."""
+        processed_widget = widget.copy()
+        processed_cards = []
+
+        for card in widget.get('cards', []):
+            processed_card = card.copy()
+
+            # Resolve value_template using Django template engine
+            value_template = card.get('value_template', '')
+            if '{{' in value_template:
+                try:
+                    template = Template(value_template)
+                    context = Context(context_data)
+                    resolved_value = template.render(context)
+                    processed_card['value_template'] = resolved_value
+                except Exception:
+                    # Keep original if rendering fails
+                    pass
+
+            # Also resolve change field if it has template variables
+            change_template = card.get('change', '')
+            if change_template and '{{' in change_template:
+                try:
+                    template = Template(change_template)
+                    context = Context(context_data)
+                    resolved_change = template.render(context)
+                    processed_card['change'] = resolved_change
+                except Exception:
+                    # Keep original if rendering fails
+                    pass
+
+            processed_cards.append(processed_card)
+
+        processed_widget['cards'] = processed_cards
+        return processed_widget
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Get system metrics for widgets."""
+        return {
+            'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
+            'memory_percent': round(psutil.virtual_memory().percent, 1),
+            'disk_percent': round(psutil.disk_usage('/').percent, 1),
+        }
+
+    def get_rpc_metrics(self) -> Dict[str, Any]:
+        """Get RPC metrics for widgets."""
+        try:
+            from django_cfg.apps.ipc.models import RPCLog
+
+            # Get stats for last 24 hours
+            since = timezone.now() - timedelta(hours=24)
+
+            logs = RPCLog.objects.filter(timestamp__gte=since)
+
+            total_calls = logs.count()
+            successful_calls = logs.filter(status='success').count()
+            failed_calls = logs.filter(status='error').count()
+
+            success_rate = round((successful_calls / total_calls * 100) if total_calls > 0 else 0, 1)
+
+            avg_duration = logs.filter(
+                duration__isnull=False
+            ).aggregate(
+                avg=Avg('duration')
+            )['avg']
+
+            avg_duration = round(avg_duration * 1000, 1) if avg_duration else 0  # Convert to ms
+
+            return {
+                'rpc_total_calls': total_calls,
+                'rpc_success_rate': success_rate,
+                'rpc_avg_duration': avg_duration,
+                'rpc_failed_calls': failed_calls,
+            }
+        except Exception as e:
+            # Return zeros if RPC models not available
+            return {
+                'rpc_total_calls': 0,
+                'rpc_success_rate': 0,
+                'rpc_avg_duration': 0,
+                'rpc_failed_calls': 0,
+            }

django_cfg/modules/django_unfold/callbacks/main.py

@@ -19,6 +19,7 @@ from django_cfg.modules.django_dashboard.sections.documentation import Documenta
 from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
 from django_cfg.modules.django_dashboard.sections.stats import StatsSection
 from django_cfg.modules.django_dashboard.sections.system import SystemSection
+from django_cfg.modules.django_dashboard.sections.widgets import WidgetsSection
 
 from ...base import BaseCfgModule
 from ..models.dashboard import DashboardData
@@ -155,6 +156,29 @@ class UnfoldCallbacks(
                 logger.error(f"Failed to render documentation section: {e}", exc_info=True)
                 documentation_section = None
 
+            # Extract custom widgets from context if provided by project's dashboard_callback
+            custom_widgets = context.get('custom_widgets', [])
+            custom_metrics = {}
+
+            # Extract all metric-like variables from context for widget template resolution
+            # This allows dashboard_callback to add metrics like: context['total_users'] = 123
+            for key, value in context.items():
+                if key not in ['request', 'cards', 'system_health', 'quick_actions'] and isinstance(value, (int, float, str)):
+                    custom_metrics[key] = value
+
+            try:
+                # Render widgets section with custom widgets and metrics from callback
+                widgets_section = WidgetsSection(request).render(
+                    custom_widgets=custom_widgets,
+                    custom_metrics=custom_metrics
+                )
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('widgets', widgets_section)
+            except Exception as e:
+                logger.error(f"Failed to render widgets section: {e}", exc_info=True)
+                widgets_section = None
+
             # Combine all stat cards (data already loaded above)
             all_stats = user_stats + support_stats
 
@@ -176,6 +200,7 @@ class UnfoldCallbacks(
                 "system_section": system_section,
                 "commands_section": commands_section,
                 "documentation_section": documentation_section,
+                "widgets_section": widgets_section,
 
                 # Statistics cards
                 "cards": cards_data,
@@ -252,24 +277,24 @@ class UnfoldCallbacks(
             })
 
             # Log charts data for debugging
-            charts_data = context.get('charts', {})
-            logger.info(f"Charts data added to context: {list(charts_data.keys())}")
-            if 'user_registrations' in charts_data:
-                reg_data = charts_data['user_registrations']
-                logger.info(f"Registration chart labels: {reg_data.get('labels', [])}")
-            if 'user_activity' in charts_data:
-                act_data = charts_data['user_activity']
-                logger.info(f"Activity chart labels: {act_data.get('labels', [])}")
-
-            # Log recent users data for debugging
-            recent_users_data = context.get('recent_users', [])
-            logger.info(f"Recent users data count: {len(recent_users_data)}")
-            if recent_users_data:
-                logger.info(f"First user: {recent_users_data[0].get('username', 'N/A')}")
-
-            # Log activity tracker data for debugging
-            activity_tracker_data = context.get('activity_tracker', [])
-            logger.info(f"Activity tracker data count: {len(activity_tracker_data)}")
+            # charts_data = context.get('charts', {})
+            # # logger.info(f"Charts data added to context: {list(charts_data.keys())}")
+            # if 'user_registrations' in charts_data:
+            #     reg_data = charts_data['user_registrations']
+            #     logger.info(f"Registration chart labels: {reg_data.get('labels', [])}")
+            # if 'user_activity' in charts_data:
+            #     act_data = charts_data['user_activity']
+            #     logger.info(f"Activity chart labels: {act_data.get('labels', [])}")
+
+            # # Log recent users data for debugging
+            # recent_users_data = context.get('recent_users', [])
+            # logger.info(f"Recent users data count: {len(recent_users_data)}")
+            # if recent_users_data:
+            #     logger.info(f"First user: {recent_users_data[0].get('username', 'N/A')}")
+
+            # # Log activity tracker data for debugging
+            # activity_tracker_data = context.get('activity_tracker', [])
+            # logger.info(f"Activity tracker data count: {len(activity_tracker_data)}")
 
             return context
 

django_cfg/modules/django_unfold/dashboard.py

@@ -73,9 +73,10 @@ class DashboardManager(BaseCfgModule):
 
         # RPC Dashboard (if enabled)
         if self.is_rpc_enabled():
-            operations_items.append(
-                NavigationItem(title="IPC/RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/ipc/admin/")
-            )
+            operations_items.extend([
+                NavigationItem(title="IPC/RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/ipc/admin/"),
+                NavigationItem(title="RPC Logs", icon=Icons.LIST_ALT, link=str(reverse_lazy("admin:django_cfg_ipc_rpclog_changelist"))),
+            ])
 
         # Background Tasks (if enabled)
         if self.should_enable_tasks():
@@ -298,6 +299,8 @@ class DashboardManager(BaseCfgModule):
 
     def get_widgets_config(self) -> List[Dict[str, Any]]:
         """Get dashboard widgets configuration using Pydantic models."""
+        widgets = []
+
         # Create system overview widget with StatCard models
         system_overview_widget = StatsCardsWidget(
             title="System Overview",
@@ -322,9 +325,43 @@ class DashboardManager(BaseCfgModule):
                 ),
             ]
         )
+        widgets.append(system_overview_widget.to_dict())
+
+        # Add RPC monitoring widget if IPC is enabled
+        if self.is_rpc_enabled():
+            rpc_monitoring_widget = StatsCardsWidget(
+                title="IPC/RPC Monitoring",
+                cards=[
+                    StatCard(
+                        title="Total Calls",
+                        value="{{ rpc_total_calls }}",
+                        icon=Icons.API,
+                        color="blue",
+                    ),
+                    StatCard(
+                        title="Success Rate",
+                        value="{{ rpc_success_rate }}%",
+                        icon=Icons.CHECK_CIRCLE,
+                        color="green",
+                    ),
+                    StatCard(
+                        title="Avg Response Time",
+                        value="{{ rpc_avg_duration }}ms",
+                        icon=Icons.SPEED,
+                        color="purple",
+                    ),
+                    StatCard(
+                        title="Failed Calls",
+                        value="{{ rpc_failed_calls }}",
+                        icon=Icons.ERROR,
+                        color="red",
+                    ),
+                ]
+            )
+            widgets.append(rpc_monitoring_widget.to_dict())
 
         # Convert to dictionaries for Unfold
-        return [system_overview_widget.to_dict()]
+        return widgets
 
 
 # Lazy initialization to avoid circular imports

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.58"
+version = "1.4.60"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]