df_site 0.1.0__py3-none-any.whl

df_site/__init__.py

@@ -0,0 +1 @@
+"""Main package for the df_site application."""

df_site/__main__.py

@@ -0,0 +1,37 @@
+"""Allow to use "python3 -m df_site" to run the manage command."""
+
+import multiprocessing
+import os
+import sys
+import warnings
+
+from df_config.manage import DEFAULT_SETTINGS_MODULE, manage, set_env
+
+
+def setup(module_name: str = None, settings_module=DEFAULT_SETTINGS_MODULE):
+    """Setup the Django environment."""
+    set_env(module_name=module_name, settings_module=settings_module)
+    import django
+
+    django.setup()
+    from django.conf import settings
+
+    return settings
+
+
+def main(module_name: str = "df_site"):
+    """Run the manage command."""
+    if not sys.warnoptions:
+        warnings.simplefilter("default")  # Change the filter in this process
+        os.environ["PYTHONWARNINGS"] = "default"  # Also affect subprocesses
+    # avoid "django.core.exceptions.AppRegistryNotReady: Apps aren't loaded yet." during parallel testing
+    multiprocessing.set_start_method("fork")
+
+    # required for parallel testing on macOS and Python 3.8+
+    os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES"
+    manage(module_name=module_name)
+
+
+if __name__ == "__main__":
+    """Allow to use "python3 -m df_site"."""
+    main()

df_site/admin.py

@@ -0,0 +1,130 @@
+"""Admin classes for the df_site app."""
+
+from functools import cached_property
+
+from allauth.account.models import EmailAddress
+from allauth.mfa.models import Authenticator
+from allauth.socialaccount.models import SocialAccount
+from allauth.usersessions.models import UserSession
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin
+from django.utils.translation import gettext as _
+
+from df_site.models import AlertRibbon, PreferencesUser
+
+
+@admin.register(AlertRibbon)
+class AlertRibbonAdmin(admin.ModelAdmin):
+    """Admin class for the alert ribbon model."""
+
+    list_display = ("message", "color", "start_date", "end_date", "is_active")
+    list_filter = ("color", "start_date", "end_date", "is_active", "position")
+    search_fields = ("summary",)
+    fields = ["summary", "url", "message", "color", "start_date", "end_date", "is_active", "position"]
+
+
+class EmailAddressInline(admin.TabularInline):
+    """Inline for the email address model."""
+
+    model = EmailAddress
+    extra = 0
+
+
+class SocialAccountInline(admin.TabularInline):
+    """Inline for the social account model."""
+
+    model = SocialAccount
+    extra = 0
+    fields = ["provider", "last_login", "date_joined"]
+    readonly_fields = ["provider", "last_login", "date_joined"]
+
+    def has_add_permission(self, request, obj):
+        """Return False to prevent adding new social accounts."""
+        return False
+
+
+class AuthenticatorInline(admin.TabularInline):
+    """Inline for the authenticator model."""
+
+    model = Authenticator
+    extra = 0
+    fields = ["type", "created_at", "last_used_at"]
+    readonly_fields = ["type", "created_at", "last_used_at"]
+
+    def has_add_permission(self, request, obj):
+        """Return False to prevent adding new authenticators."""
+        return False
+
+
+class UserSessionInline(admin.TabularInline):
+    """Inline for the user session model."""
+
+    model = UserSession
+    extra = 0
+    fields = [
+        "created_at",
+        "ip",
+        "last_seen_at",
+    ]
+    readonly_fields = [
+        "created_at",
+        "ip",
+        "last_seen_at",
+    ]
+
+    def has_add_permission(self, request, obj):
+        """Return False to prevent adding new user sessions."""
+        return False
+
+
+@admin.register(PreferencesUser)
+class PreferencesUserAdmin(UserAdmin):
+    """Admin class for the preferences user model."""
+
+    inlines = [EmailAddressInline, AuthenticatorInline, SocialAccountInline, UserSessionInline]
+    list_display = ("username", "email", "first_name", "last_name", "is_staff", "date_joined")
+    list_filter = ("is_staff", "is_superuser", "is_active", "date_joined", "groups")
+    readonly_fields = ["last_login", "date_joined"]
+    fieldsets = (
+        (None, {"fields": ("username", "password")}),
+        (
+            _("Personal info"),
+            {"fields": ("first_name", "last_name", "email", "color_theme", "display_online", "email_notifications")},
+        ),
+        (
+            _("Permissions"),
+            {
+                "fields": (
+                    "is_active",
+                    "is_staff",
+                    "is_superuser",
+                    "groups",
+                    "user_permissions",
+                ),
+            },
+        ),
+        (_("Important dates"), {"fields": (("last_login", "date_joined"),)}),
+    )
+
+    @cached_property
+    def excluded_inlines(self):
+        """Exclude inlines of which the corresponding app is not installed."""
+        excluded = []
+        if "allauth.mfa" not in settings.INSTALLED_APPS:
+            excluded.append(AuthenticatorInline)
+        if "allauth.socialaccount" not in settings.INSTALLED_APPS:
+            excluded.append(SocialAccountInline)
+        if "allauth.usersessions" not in settings.INSTALLED_APPS:
+            excluded.append(UserSessionInline)
+        if "allauth.account" not in settings.INSTALLED_APPS:
+            excluded.append(EmailAddressInline)
+        return excluded
+
+    def get_inlines(self, request, obj):
+        """Return inlines excluding those that correspond to apps not installed."""
+        inlines = super().get_inlines(request, obj)
+        if obj is None:
+            return []
+        inlines = [x for x in inlines if x not in self.excluded_inlines]
+        return inlines

df_site/apps.py

@@ -0,0 +1,57 @@
+"""Configuration for the df_site app."""
+
+from typing import Type
+
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate, pre_save
+from django.utils.translation import gettext_lazy as _
+
+
+class DFSiteApp(AppConfig):
+    """Configuration for the df_site app."""
+
+    default_auto_field = "django.db.models.AutoField"
+    name = "df_site"
+    verbose_name = _("df_site")
+
+    def ready(self):
+        """Run code when the app is ready."""
+        super().ready()
+        post_migrate.connect(auto_create_site_object, sender=self)
+        from django.contrib.auth import get_user_model
+
+        user_model = get_user_model()
+        pre_save.connect(create_admin_user, sender=user_model)
+
+
+def create_admin_user(sender, instance, **kwargs):
+    """Create an admin user if none already exists."""
+    from django.contrib.auth.models import AbstractUser
+
+    sender: Type[AbstractUser]
+    instance: AbstractUser
+    if hasattr(create_admin_user, "run"):
+        return
+    if not hasattr(instance, "is_superuser") or sender.objects.filter(is_superuser=True, is_active=True).exists():
+        return
+    instance.is_superuser = True
+    instance.is_staff = True
+    setattr(create_admin_user, "run", True)
+
+
+# noinspection PyUnusedLocal
+def auto_create_site_object(sender, **kwargs):
+    """Create a Site object if it does not exist."""
+    from django.conf import settings
+    from django.contrib.sites.models import Site
+
+    site, created = Site.objects.get_or_create(
+        id=1,
+        defaults={
+            "domain": settings.SERVER_NAME,
+            "name": settings.DF_SITE_TITLE,
+        },
+    )
+    site.domain = settings.SERVER_NAME
+    site.name = settings.DF_SITE_TITLE
+    site.save()

df_site/components/__init__.py

@@ -0,0 +1 @@
+"""Contains components to use in templates."""

df_site/components/base.py

@@ -0,0 +1,82 @@
+"""Define a HTML component class, a elaborated piece of template.
+
+A component should be instantiated once and not have any request-specific attribute.
+Request-specific data should be passed as arguments to methods.
+"""
+
+from typing import List, Optional, Type
+
+from django.db import models
+from django.http import HttpRequest
+
+
+class Component:
+    """Base component class."""
+
+    template_name: str = "components/base.html"
+
+    def render(self, context, **kwargs) -> str:
+        """Render the component in a HTML template.
+
+        Context the complete template context.
+        Kwargs is a dictionary of data provided to the template tag.
+        """
+        self.update_render_context(context, **kwargs)
+        names = self.get_template_names()
+        template = context.template.engine.select_template(names)
+        return template.render(context)
+
+    def get_template_names(self) -> List[str]:
+        """Return a list of template names to be used for the request."""
+        return [self.template_name]
+
+    def update_render_context(self, context, **kwargs):
+        """Update the context before rendering the component.
+
+        Context the complete template context.
+        Kwargs is a dictionary of data provided to the template tag.
+        """
+        pass
+
+
+class ModelComponent(Component):
+    """Base component class for model-related components."""
+
+    template_name: Optional[str] = None
+
+    def __init__(self, model: Type[models.Model], base_template: str):
+        """Initialize the component."""
+        super().__init__()
+        self.model: Type[models.Model] = model
+        # noinspection PyProtectedMember
+        self.opts = model._meta
+        self.base_template: str = base_template
+
+    @property
+    def id_prefix(self) -> str:
+        """Propose a prefix for the HTML IDs linked to this component."""
+        return f"{self.opts.app_label}_{self.opts.model_name}"
+
+    # noinspection PyUnusedLocal
+    def get_base_queryset(self, request: HttpRequest, **kwargs) -> models.QuerySet:
+        """Return the base queryset to use for this component.
+
+        Any extra filter based on kwargs should be applied here.
+        """
+        # noinspection PyProtectedMember
+        return self.model._default_manager.get_queryset()
+
+    # noinspection PyMethodMayBeStatic
+    def get_empty_value_display(self) -> str:
+        """Return the value to display for an empty field."""
+        return "-"
+
+    def get_template_names(self) -> List[str]:
+        """Return a list of template names to be used for the request."""
+        if self.template_name:
+            return [self.template_name]
+        return [
+            f"df_components/{self.opts.app_label}/{self.opts.model_name}/{self.base_template}",
+            f"df_components/{self.opts.app_label}/{self.base_template}",
+            f"df_components/{self.base_template}",
+        ]

df_site/components/detail.py

@@ -0,0 +1,191 @@
+"""Component and generic View for displaying the details of a model instance."""
+
+from typing import Dict, List, Optional, Type, Union
+
+from df_websockets.tasks import set_websocket_topics
+from django import forms
+from django.contrib.admin import helpers
+from django.contrib.admin.utils import flatten_fieldsets
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.forms import fields_for_model
+from django.urls import reverse
+from django.utils.translation import gettext as _
+from django.views.generic import DetailView
+
+from df_site.components.base import ModelComponent
+
+
+class ModelDetailComponent(ModelComponent):
+    """A component that displays the details of a model instance."""
+
+    model: Type[models.Model]
+
+    def __init__(
+        self,
+        model: Type[models.Model],
+        base_template: str = "detail.html",
+        inlines: List = None,
+        fields=None,
+        exclude=None,
+        fieldsets=None,
+        filter_vertical=(),
+        filter_horizontal=(),
+    ):
+        """Initialize the component."""
+        super().__init__(model, base_template)
+        self.inlines = inlines or []
+        self.fields = fields
+        self.exclude = exclude
+        self.fieldsets = fieldsets
+        self.filter_vertical = filter_vertical
+        self.filter_horizontal = filter_horizontal
+        self.opts = model._meta
+
+    def get_queryset(self, request):
+        """Return a QuerySet of all model instances that can be viewed."""
+        # noinspection PyProtectedMember
+        return self.model._default_manager.get_queryset()
+
+    def get_fields(self, request, obj=None):
+        """Return the list of selected fields."""
+        if self.fields:
+            return self.fields
+        # _get_form_for_get_fields() is implemented in subclasses.
+        fields = fields_for_model(self.model)
+        return [*fields]
+
+    def get_fieldsets(self, request, obj=None):
+        """Return the specified fieldsets."""
+        if self.fieldsets:
+            return self.fieldsets
+        return [(None, {"fields": self.get_fields(request, obj)})]
+
+    def get_inlines(self, request, obj):
+        """Hook for specifying custom inlines."""
+        return self.inlines
+
+    def get_object(self, request, object_id, from_field=None):
+        """Return an instance matching the field and value provided.
+
+        The primary key is used if no field is provided. Return ``None`` if no match is
+        found or the object_id fails validation.
+        """
+        queryset = self.get_queryset(request)
+        model = queryset.model
+        field = self.opts.pk if from_field is None else self.opts.get_field(from_field)
+        try:
+            object_id = field.to_python(object_id)
+            return queryset.get(**{field.name: object_id})
+        except (model.DoesNotExist, ValidationError, ValueError):
+            return None
+
+    def update_render_context(self, context, **kwargs):
+        """Update the context before rendering the component.
+
+        The displayed object can be specified either in the context as "object",
+         in the kwargs as "obj" or its ID as "object_id" in kwargs.
+        """
+        request = context["request"]
+        if "object" in context:
+            obj = context["object"]
+        elif "obj" in kwargs:
+            obj = kwargs["obj"]
+        else:
+            object_id = kwargs.get("object_id")
+            from_field = kwargs.get("from_field")
+            obj = self.get_object(request, object_id=object_id, from_field=from_field)
+        fieldsets = self.get_fieldsets(request, obj)
+        readonly_fields = flatten_fieldsets(fieldsets)
+
+        class AdminForm(forms.ModelForm):
+            class Meta:
+                model = self.model
+                fields = []
+
+        form = AdminForm(instance=obj)
+        admin_form = helpers.AdminForm(
+            form,
+            list(fieldsets),
+            {},
+            readonly_fields=readonly_fields,
+            model_admin=self,
+        )
+        context["adminform"] = admin_form
+
+
+class ModelDetailView(DetailView):
+    """A view that displays the details of a model instance."""
+
+    component: ModelDetailComponent
+    model: Type[models.Model]
+    component_template: str = "detail.html"
+    inlines: List = None
+    fields = None
+    exclude = None
+    fieldsets = None
+    filter_vertical = ()
+    filter_horizontal = ()
+
+    @classmethod
+    def as_view(cls, **initkwargs):
+        """Main entry point for a request-response process."""
+        cls.component = ModelDetailComponent(
+            model=cls.model,
+            base_template=cls.component_template,
+            inlines=cls.inlines,
+            fields=cls.fields,
+            exclude=cls.exclude,
+            fieldsets=cls.fieldsets,
+            filter_vertical=cls.filter_vertical,
+            filter_horizontal=cls.filter_horizontal,
+        )
+        return super().as_view(**initkwargs)
+
+    def get_template_names(self):
+        """Return a list of template names to be used for the request."""
+        if self.template_name:
+            return [self.template_name]
+        return [
+            f"df_site/{self.component.opts.app_label}/{self.component.opts.model_name}/detail.html",
+            f"df_site/{self.component.opts.app_label}/detail.html",
+            "df_site/detail.html",
+        ]
+
+    def get_breadcrumb(self) -> List[Dict[str, Union[str, bool]]]:
+        """Return the breadcrumb for the view.
+
+        The breadcrumb is a list of dictionaries with the following keys:
+        * `link`: URL to link to
+        * `title`: Text to display
+        * `active`: boolean, element is active, meaning that the link is not displayed
+        """
+        return [
+            {"link": reverse("index"), "title": _("Home"), "active": False},
+            {"link": None, "title": str(self.object), "active": True},
+        ]
+
+    def get_context_data(self, **kwargs):
+        """Get the context data for the view."""
+        context = super().get_context_data(**kwargs)
+        context["detail_component"] = self.component
+        context["detail_breadcrumb"] = self.get_breadcrumb()
+        context["PAGE_TITLE"] = self.get_page_title()
+        context["PAGE_DESCRIPTION"] = self.get_page_description()
+        context["PAGE_URL"] = self.get_page_url(context)
+        set_websocket_topics(self.request, self.object)
+        return context
+
+    def get_page_url(self, context) -> Optional[str]:
+        """Return the URL of the current page."""
+        if hasattr(self.object, "get_absolute_url"):
+            return self.object.get_absolute_url()
+
+    def get_page_title(self) -> Optional[str]:
+        """Return the title of the current page."""
+        return str(self.object)
+
+    def get_page_description(self) -> Optional[str]:
+        """Return the description of the current page."""
+        # noinspection PyProtectedMember
+        return self.object._meta.verbose_name