django-cfg 1.4.62__py3-none-any.whl → 1.4.63__py3-none-any.whl

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.62"
+__version__ = "1.4.63"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/accounts/services/otp_service.py

@@ -5,6 +5,7 @@ from typing import Optional
 from django.db import transaction
 from django.utils import timezone
 
+from django_cfg.core.utils import get_otp_url
 from django_cfg.modules.django_telegram import DjangoTelegram
 
 from ..models import CustomUser, OTPSecret
@@ -17,20 +18,8 @@ logger = logging.getLogger(__name__)
 class OTPService:
     """Simple OTP service for authentication."""
 
-    @staticmethod
-    def _get_otp_url(otp_code: str) -> str:
-        """Get OTP verification URL from configuration."""
-        try:
-            from django_cfg.core.state import get_current_config
-            config = get_current_config()
-            if config and hasattr(config, 'get_otp_url'):
-                return config.get_otp_url(otp_code)
-            else:
-                # Fallback URL if config is not available
-                return f"#otp-{otp_code}"
-        except Exception as e:
-            logger.warning(f"Could not generate OTP URL: {e}")
-            return f"#otp-{otp_code}"
+    # Expose get_otp_url as a static method for backward compatibility
+    _get_otp_url = staticmethod(get_otp_url)
 
     @staticmethod
     @transaction.atomic

django_cfg/apps/centrifugo/__init__.py

@@ -0,0 +1,57 @@
+"""
+Django-CFG Centrifugo Integration.
+
+Provides Django integration with Centrifugo WebSocket server for real-time
+notifications with delivery confirmation (ACK tracking).
+
+Main Components:
+- CentrifugoClient: Django client for publishing messages
+- CentrifugoLog: Model for tracking publish operations
+- CentrifugoLogger: Helper for automatic logging
+- DjangoCfgCentrifugoConfig: Pydantic configuration model
+
+Example:
+    >>> from django_cfg.apps.centrifugo import get_centrifugo_client
+    >>>
+    >>> client = get_centrifugo_client()
+    >>> result = await client.publish_with_ack(
+    ...     channel="user#123",
+    ...     data={"title": "Hello", "message": "World"},
+    ...     ack_timeout=10
+    ... )
+    >>> print(f"Delivered: {result.delivered}")
+"""
+
+from .services.client.client import CentrifugoClient, get_centrifugo_client, PublishResponse
+from .services.client.config import DjangoCfgCentrifugoConfig
+from .services.client.exceptions import (
+    CentrifugoBaseException,
+    CentrifugoConfigurationError,
+    CentrifugoConnectionError,
+    CentrifugoPublishError,
+    CentrifugoTimeoutError,
+    CentrifugoValidationError,
+)
+from .services.logging import CentrifugoLogContext, CentrifugoLogger
+
+# Note: CentrifugoLog model is not imported here to avoid AppRegistryNotReady errors
+# Import it directly from .models when needed: from django_cfg.apps.centrifugo.models import CentrifugoLog
+
+__all__ = [
+    # Config
+    "DjangoCfgCentrifugoConfig",
+    # Client
+    "CentrifugoClient",
+    "get_centrifugo_client",
+    "PublishResponse",
+    # Logging
+    "CentrifugoLogger",
+    "CentrifugoLogContext",
+    # Exceptions
+    "CentrifugoBaseException",
+    "CentrifugoTimeoutError",
+    "CentrifugoPublishError",
+    "CentrifugoConnectionError",
+    "CentrifugoConfigurationError",
+    "CentrifugoValidationError",
+]

django_cfg/apps/centrifugo/admin/__init__.py

@@ -0,0 +1,13 @@
+"""
+Django Admin for Centrifugo models.
+
+Uses PydanticAdmin with declarative configuration.
+"""
+
+from .centrifugo_log import CentrifugoLogAdmin
+from .config import centrifugolog_config
+
+__all__ = [
+    "centrifugolog_config",
+    "CentrifugoLogAdmin",
+]

django_cfg/apps/centrifugo/admin/centrifugo_log.py

@@ -0,0 +1,249 @@
+"""
+Centrifugo Log Admin.
+
+PydanticAdmin for CentrifugoLog model with custom computed fields.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import CentrifugoLog
+from .config import centrifugolog_config
+
+
+@admin.register(CentrifugoLog)
+class CentrifugoLogAdmin(PydanticAdmin):
+    """
+    Centrifugo log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - ACK tracking visualization
+    - Duration display with performance indicators
+    - Formatted JSON for message data
+    - Error details with highlighted display
+    """
+
+    config = centrifugolog_config
+
+    @computed_field("Type", ordering="wait_for_ack")
+    def type_badge(self, obj):
+        """Display badge showing if this publish waited for ACK."""
+        if obj.wait_for_ack:
+            return self.html.badge("ACK", variant="success", icon=Icons.CHECK_CIRCLE)
+        else:
+            return self.html.badge("FIRE", variant="secondary", icon=Icons.NOTIFICATIONS)
+
+    @computed_field("ACKs", ordering="acks_received")
+    def acks_display(self, obj):
+        """Display ACK count with context."""
+        if not obj.wait_for_ack:
+            return self.html.empty()
+
+        # If we have expected count
+        if obj.acks_expected:
+            rate = obj.delivery_rate
+            if rate == 1.0:
+                variant = "success"
+                icon = Icons.CHECK_CIRCLE
+            elif rate > 0:
+                variant = "warning"
+                icon = Icons.TIMER
+            else:
+                variant = "danger"
+                icon = Icons.ERROR
+
+            return self.html.badge(
+                f"{obj.acks_received}/{obj.acks_expected}",
+                variant=variant,
+                icon=icon,
+            )
+
+        # Just show count
+        if obj.acks_received > 0:
+            return self.html.badge(
+                f"{obj.acks_received} ACKs", variant="success", icon=Icons.CHECK_CIRCLE
+            )
+        else:
+            return self.html.badge("0 ACKs", variant="danger", icon=Icons.ERROR)
+
+    @computed_field("Duration", ordering="duration_ms")
+    def duration_display(self, obj):
+        """Display duration with color coding based on speed."""
+        if obj.duration_ms is None:
+            return self.html.empty()
+
+        # Color code based on duration
+        if obj.duration_ms < 100:
+            variant = "success"  # Fast
+            icon = Icons.SPEED
+        elif obj.duration_ms < 500:
+            variant = "warning"  # Moderate
+            icon = Icons.TIMER
+        else:
+            variant = "danger"  # Slow
+            icon = Icons.ERROR
+
+        return self.html.badge(f"{obj.duration_ms}ms", variant=variant, icon=icon)
+
+    def data_display(self, obj):
+        """Display formatted JSON message data."""
+        if not obj.data:
+            return self.html.empty("No data")
+
+        try:
+            formatted = json.dumps(obj.data, indent=2)
+            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
+        except Exception:
+            return str(obj.data)
+
+    data_display.short_description = "Message Data"
+
+    def error_details_display(self, obj):
+        """Display error information if publish failed."""
+        if obj.is_successful or obj.status == "pending":
+            return self.html.inline(
+                [
+                    self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                    self.html.span("No errors", "text-green-600"),
+                ]
+            )
+
+        details = []
+
+        if obj.error_code:
+            details.append(
+                self.html.inline(
+                    [
+                        self.html.span("Error Code:", "font-semibold"),
+                        self.html.badge(obj.error_code, variant="danger", icon=Icons.ERROR),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        if obj.error_message:
+            details.append(
+                self.html.inline(
+                    [
+                        self.html.span("Message:", "font-semibold"),
+                        self.html.span(obj.error_message, "text-red-600"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        return "<br>".join(details) if details else self.html.empty()
+
+    error_details_display.short_description = "Error Details"
+
+    def delivery_stats_display(self, obj):
+        """Display delivery statistics."""
+        if not obj.wait_for_ack:
+            return self.html.empty("No ACK tracking")
+
+        stats = []
+
+        # ACK timeout
+        if obj.ack_timeout:
+            stats.append(
+                self.html.inline(
+                    [
+                        self.html.span("Timeout:", "font-semibold"),
+                        self.html.span(f"{obj.ack_timeout}s", "text-gray-600"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+        # ACKs received
+        stats.append(
+            self.html.inline(
+                [
+                    self.html.span("ACKs Received:", "font-semibold"),
+                    self.html.badge(str(obj.acks_received), variant="info"),
+                ],
+                separator=" ",
+            )
+        )
+
+        # ACKs expected (if known)
+        if obj.acks_expected:
+            stats.append(
+                self.html.inline(
+                    [
+                        self.html.span("ACKs Expected:", "font-semibold"),
+                        self.html.span(str(obj.acks_expected), "text-gray-600"),
+                    ],
+                    separator=" ",
+                )
+            )
+
+            # Delivery rate
+            if obj.delivery_rate is not None:
+                rate_pct = obj.delivery_rate * 100
+                stats.append(
+                    self.html.inline(
+                        [
+                            self.html.span("Delivery Rate:", "font-semibold"),
+                            self.html.span(f"{rate_pct:.1f}%", "text-blue-600"),
+                        ],
+                        separator=" ",
+                    )
+                )
+
+        return "<br>".join(stats) if stats else self.html.empty()
+
+    delivery_stats_display.short_description = "Delivery Statistics"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Publish Information",
+                {"fields": ("id", "message_id", "channel", "user", "status")},
+            ),
+            (
+                "Message Data",
+                {"fields": ("data_display",), "classes": ("collapse",)},
+            ),
+            ("Performance", {"fields": ("duration_ms", "created_at", "completed_at")}),
+            ("Metadata", {"fields": ("caller_ip", "user_agent"), "classes": ("collapse",)}),
+        ]
+
+        # Add ACK tracking section if enabled
+        if obj and obj.wait_for_ack:
+            fieldsets.insert(
+                2,
+                (
+                    "ACK Tracking",
+                    {
+                        "fields": (
+                            "delivery_stats_display",
+                            "wait_for_ack",
+                            "ack_timeout",
+                            "acks_received",
+                            "acks_expected",
+                        )
+                    },
+                ),
+            )
+
+        # Add error section only if failed
+        if obj and not obj.is_successful and obj.status != "pending":
+            fieldsets.insert(
+                3,
+                (
+                    "Error Details",
+                    {"fields": ("error_details_display", "error_code", "error_message")},
+                ),
+            )
+
+        return fieldsets
+
+
+__all__ = ["CentrifugoLogAdmin"]

django_cfg/apps/centrifugo/admin/config.py

@@ -0,0 +1,82 @@
+"""
+Admin configuration for Centrifugo models.
+
+Declarative AdminConfig using PydanticAdmin patterns.
+"""
+
+from django_cfg.modules.django_admin import (
+    AdminConfig,
+    BadgeField,
+    DateTimeField,
+    Icons,
+    UserField,
+)
+
+from ..models import CentrifugoLog
+
+
+# Declarative configuration for CentrifugoLog
+centrifugolog_config = AdminConfig(
+    model=CentrifugoLog,
+    # Performance optimization
+    select_related=["user"],
+
+    # List display
+    list_display=[
+        "channel",
+        "type_badge",
+        "status",
+        "user",
+        "acks_display",
+        "duration_display",
+        "created_at",
+        "completed_at"
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(name="channel", title="Channel", variant="info", icon=Icons.NOTIFICATIONS),
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "pending": "warning",
+                "success": "success",
+                "failed": "danger",
+                "timeout": "danger",
+                "partial": "warning",
+            },
+        ),
+        UserField(name="user", title="User", header=True),
+        DateTimeField(name="created_at", title="Created", ordering="created_at"),
+        DateTimeField(name="completed_at", title="Completed", ordering="completed_at"),
+    ],
+    # Filters
+    list_filter=["status", "wait_for_ack", "channel", "created_at"],
+    search_fields=[
+        "message_id",
+        "channel",
+        "user__username",
+        "user__email",
+        "error_message",
+    ],
+    # Autocomplete for user field
+    autocomplete_fields=["user"],
+    # Readonly fields
+    readonly_fields=[
+        "id",
+        "message_id",
+        "created_at",
+        "completed_at",
+        "data_display",
+        "error_details_display",
+        "delivery_stats_display",
+    ],
+    # Date hierarchy
+    date_hierarchy="created_at",
+    # Per page
+    list_per_page=50,
+)
+
+
+__all__ = ["centrifugolog_config"]

django_cfg/apps/centrifugo/apps.py

@@ -0,0 +1,31 @@
+"""
+Django app configuration for Centrifugo module.
+
+Provides Centrifugo pub/sub client with ACK tracking.
+"""
+
+from django.apps import AppConfig
+
+
+class CentrifugoConfig(AppConfig):
+    """
+    Centrifugo application configuration.
+
+    Provides:
+    - Async client for publishing messages to Centrifugo
+    - ACK tracking for delivery confirmation
+    - Logging of all publish operations
+    - Migration-friendly API (mirrors django-ipc patterns)
+    """
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_cfg.apps.centrifugo"
+    label = "django_cfg_centrifugo"
+    verbose_name = "Centrifugo WebSocket"
+
+    def ready(self):
+        """Initialize app when Django starts."""
+        from django_cfg.modules.django_logging import get_logger
+
+        logger = get_logger("centrifugo.apps")
+        logger.info("Centrifugo app initialized")