plain.admin 0.14.1__py3-none-any.whl

plain/admin/views/models.py

@@ -0,0 +1,254 @@
+from typing import TYPE_CHECKING
+
+from plain import models
+from plain.models import Manager, Q
+
+from .objects import (
+    AdminCreateView,
+    AdminDeleteView,
+    AdminDetailView,
+    AdminListView,
+    AdminUpdateView,
+)
+
+if TYPE_CHECKING:
+    from plain import models
+
+
+def get_model_field(instance, field):
+    if "__" in field:
+        # Allow __ syntax like querysets use,
+        # also automatically calling callables (like __date)
+        result = instance
+        for part in field.split("__"):
+            result = getattr(result, part)
+
+            # If we hit a None, just return it
+            if not result:
+                return result
+
+            if callable(result):
+                result = result()
+
+        return result
+
+    attr = getattr(instance, field)
+
+    if isinstance(attr, Manager):
+        # Automatically get .all() of related managers
+        return attr.all()
+
+    return attr
+
+
+class AdminModelListView(AdminListView):
+    show_search = True
+    allow_global_search = True
+
+    model: "models.Model"
+
+    fields: list = ["pk"]
+    queryset_order = []
+    search_fields: list = ["pk"]
+
+    def get_title(self) -> str:
+        if title := super().get_title():
+            return title
+
+        return self.model._meta.model_name.capitalize() + "s"
+
+    @classmethod
+    def get_nav_title(cls) -> str:
+        if cls.nav_title:
+            return cls.nav_title
+
+        if cls.title:
+            return cls.title
+
+        return cls.model._meta.model_name.capitalize() + "s"
+
+    @classmethod
+    def get_slug(cls) -> str:
+        return cls.model._meta.model_name
+
+    def get_template_context(self):
+        context = super().get_template_context()
+
+        order_by = self.request.GET.get("order_by", "")
+        if order_by.startswith("-"):
+            order_by_field = order_by[1:]
+            order_by_direction = "-"
+        else:
+            order_by_field = order_by
+            order_by_direction = ""
+
+        context["order_by_field"] = order_by_field
+        context["order_by_direction"] = order_by_direction
+
+        return context
+
+    def get_objects(self):
+        queryset = self.get_initial_queryset()
+        queryset = self.order_queryset(queryset)
+        queryset = self.search_queryset(queryset)
+        return queryset
+
+    def get_initial_queryset(self):
+        # Separate override for the initial queryset
+        # so that annotations can be added BEFORE order_by, etc.
+        return self.model.objects.all()
+
+    def order_queryset(self, queryset):
+        if order_by := self.request.GET.get("order_by"):
+            queryset = queryset.order_by(order_by)
+        elif self.queryset_order:
+            queryset = queryset.order_by(*self.queryset_order)
+
+        return queryset
+
+    def search_queryset(self, queryset):
+        if search := self.request.GET.get("search"):
+            filters = Q()
+            for field in self.search_fields:
+                filters |= Q(**{f"{field}__icontains": search})
+
+            queryset = queryset.filter(filters)
+
+        return queryset
+
+    def get_field_value(self, obj, field: str):
+        try:
+            return super().get_field_value(obj, field)
+        except (AttributeError, TypeError):
+            return get_model_field(obj, field)
+
+    def get_field_value_template(self, obj, field: str, value):
+        templates = super().get_field_value_template(obj, field, value)
+        if hasattr(obj, f"get_{field}_display"):
+            # Insert before the last default template,
+            # so it can still be overriden by the user
+            templates.insert(-1, "admin/values/get_display.html")
+        return templates
+
+
+class AdminModelDetailView(AdminDetailView):
+    model: "models.Model"
+
+    def get_title(self) -> str:
+        return str(self.object)
+
+    @classmethod
+    def get_slug(cls) -> str:
+        return f"{cls.model._meta.model_name}_detail"
+
+    @classmethod
+    def get_path(cls) -> str:
+        return f"{cls.model._meta.model_name}/<int:pk>/"
+
+    def get_fields(self):
+        if fields := super().get_fields():
+            return fields
+
+        return ["pk"] + [f.name for f in self.object._meta.get_fields() if f.concrete]
+
+    def get_field_value(self, obj, field: str):
+        try:
+            return super().get_field_value(obj, field)
+        except (AttributeError, TypeError):
+            return get_model_field(obj, field)
+
+    def get_object(self):
+        return self.model.objects.get(pk=self.url_kwargs["pk"])
+
+    def get_template_names(self) -> list[str]:
+        template_names = super().get_template_names()
+
+        if not self.template_name and isinstance(self.object, models.Model):
+            object_meta = self.object._meta
+            template_names = [
+                f"admin/{object_meta.package_label}/{object_meta.model_name}{self.template_name_suffix}.html"
+            ] + template_names
+
+        return template_names
+
+
+class AdminModelCreateView(AdminCreateView):
+    model: "models.Model"
+    form_class = None  # TODO type annotation
+
+    def get_title(self) -> str:
+        if title := super().get_title():
+            return title
+
+        return f"New {self.model._meta.model_name}"
+
+    @classmethod
+    def get_slug(cls) -> str:
+        return f"{cls.model._meta.model_name}_create"
+
+    @classmethod
+    def get_path(cls) -> str:
+        return f"{cls.model._meta.model_name}/create/"
+
+    def get_template_names(self):
+        template_names = super().get_template_names()
+
+        if not self.template_name and issubclass(self.model, models.Model):
+            model_meta = self.model._meta
+            template_names = [
+                f"admin/{model_meta.package_label}/{model_meta.model_name}{self.template_name_suffix}.html"
+            ] + template_names
+
+        return template_names
+
+
+class AdminModelUpdateView(AdminUpdateView):
+    model: "models.Model"
+    form_class = None  # TODO type annotation
+    success_url = "."  # Redirect back to the same update page by default
+
+    def get_title(self) -> str:
+        if title := super().get_title():
+            return title
+
+        return f"Update {self.object}"
+
+    @classmethod
+    def get_slug(cls) -> str:
+        return f"{cls.model._meta.model_name}_update"
+
+    @classmethod
+    def get_path(cls) -> str:
+        return f"{cls.model._meta.model_name}/<int:pk>/update/"
+
+    def get_object(self):
+        return self.model.objects.get(pk=self.url_kwargs["pk"])
+
+    def get_template_names(self):
+        template_names = super().get_template_names()
+
+        if not self.template_name and isinstance(self.object, models.Model):
+            object_meta = self.object._meta
+            template_names = [
+                f"admin/{object_meta.package_label}/{object_meta.model_name}{self.template_name_suffix}.html"
+            ] + template_names
+
+        return template_names
+
+
+class AdminModelDeleteView(AdminDeleteView):
+    model: "models.Model"
+
+    def get_title(self) -> str:
+        return f"Delete {self.object}"
+
+    @classmethod
+    def get_slug(cls) -> str:
+        return f"{cls.model._meta.model_name}_delete"
+
+    @classmethod
+    def get_path(cls) -> str:
+        return f"{cls.model._meta.model_name}/<int:pk>/delete/"
+
+    def get_object(self):
+        return self.model.objects.get(pk=self.url_kwargs["pk"])

plain/admin/views/objects.py

@@ -0,0 +1,399 @@
+from plain.htmx.views import HTMXViewMixin
+from plain.http import Response, ResponseRedirect
+from plain.models import Model
+from plain.paginator import Paginator
+from plain.views import (
+    CreateView,
+    DeleteView,
+    DetailView,
+    UpdateView,
+)
+
+from .base import AdminView
+
+
+class AdminListView(HTMXViewMixin, AdminView):
+    template_name = "admin/list.html"
+    fields: list[str]
+    actions: list[str] = []
+    displays: list[str] = []
+    page_size = 100
+    show_search = False
+    allow_global_search = False
+
+    def get_template_context(self):
+        context = super().get_template_context()
+
+        # Make this available on self for usage in get_objects and other methods
+        self.display = self.request.GET.get("display", "")
+
+        # Make this available to get_displays and stuff
+        self.objects = self.get_objects()
+
+        page_size = self.request.GET.get("page_size", self.page_size)
+        paginator = Paginator(self.objects, page_size)
+        self._page = paginator.get_page(self.request.GET.get("page", 1))
+
+        context["paginator"] = paginator
+        context["page"] = self._page
+        context["objects"] = self._page  # alias
+        context["fields"] = self.get_fields()
+        context["actions"] = self.get_actions()
+        context["displays"] = self.get_displays()
+
+        context["current_display"] = self.display
+
+        # Implement search yourself in get_objects
+        context["search_query"] = self.request.GET.get("search", "")
+        context["show_search"] = self.show_search
+
+        context["table_style"] = getattr(self, "_table_style", "default")
+
+        context["get_object_pk"] = self.get_object_pk
+        context["get_field_value"] = self.get_field_value
+        context["get_field_value_template"] = self.get_field_value_template
+
+        context["get_object_url"] = self.get_object_url
+        context["get_object_links"] = self.get_object_links
+
+        return context
+
+    def get(self) -> Response:
+        if self.is_htmx_request:
+            hx_from_this_page = self.request.path in self.request.headers.get(
+                "HX-Current-Url", ""
+            )
+            if not hx_from_this_page:
+                self._table_style = "simple"
+        else:
+            hx_from_this_page = False
+
+        response = super().get()
+
+        if self.is_htmx_request and not hx_from_this_page and not self._page:
+            # Don't render anything
+            return Response(status=204)
+
+        return response
+
+    def post(self) -> Response:
+        # won't be "key" anymore, just list
+        action_name = self.request.POST.get("action_name")
+        actions = self.get_actions()
+        if action_name and action_name in actions:
+            target_pks = self.request.POST["action_pks"].split(",")
+            response = self.perform_action(action_name, target_pks)
+            if response:
+                return response
+            else:
+                # message in session first
+                return ResponseRedirect(".")
+
+        raise ValueError("Invalid action")
+
+    def perform_action(self, action: str, target_pks: list) -> Response | None:
+        raise NotImplementedError
+
+    def get_objects(self) -> list:
+        return []
+
+    def get_fields(self) -> list:
+        return (
+            self.fields.copy()
+        )  # Avoid mutating the class attribute if using append etc
+
+    def get_actions(self) -> dict[str]:
+        return self.actions.copy()  # Avoid mutating the class attribute itself
+
+    def get_displays(self) -> list[str]:
+        return self.displays.copy()  # Avoid mutating the class attribute itself
+
+    def get_field_value(self, obj, field: str):
+        try:
+            # Try basic dict lookup first
+            if field in obj:
+                return obj[field]
+        except TypeError:
+            pass
+
+        # Try dot notation
+        if "." in field:
+            field, subfield = field.split(".", 1)
+            return self.get_field_value(obj[field], subfield)
+
+        # Try regular object attribute
+        attr = getattr(obj, field)
+
+        # Call if it's callable
+        if callable(attr):
+            return attr()
+        else:
+            return attr
+
+    def get_object_pk(self, obj):
+        try:
+            return self.get_field_value(obj, "pk")
+        except AttributeError:
+            return self.get_field_value(obj, "id")
+
+    def get_field_value_template(self, obj, field: str, value):
+        type_str = type(value).__name__.lower()
+        return [
+            f"admin/values/{type_str}.html",  # Create a template per-type
+            f"admin/values/{field}.html",  # Or for specific field names
+            "admin/values/default.html",
+        ]
+
+    def get_list_url(self) -> str | None:
+        return None
+
+    def get_create_url(self) -> str | None:
+        return None
+
+    def get_detail_url(self, obj) -> str | None:
+        return None
+
+    def get_update_url(self, obj) -> str | None:
+        return None
+
+    def get_delete_url(self, obj) -> str | None:
+        return None
+
+    def get_object_url(self, obj) -> str | None:
+        if url := self.get_detail_url(obj):
+            return url
+        if url := self.get_update_url(obj):
+            return url
+        if url := self.get_delete_url(obj):
+            return url
+        return None
+
+    def get_object_links(self, obj) -> dict[str]:
+        links = {}
+        if self.get_detail_url(obj):
+            links["View"] = self.get_detail_url(obj)
+        if self.get_update_url(obj):
+            links["Edit"] = self.get_update_url(obj)
+        if self.get_delete_url(obj):
+            links["Delete"] = self.get_delete_url(obj)
+        return links
+
+    def get_links(self):
+        links = super().get_links()
+
+        # Not tied to a specific object
+        if create_url := self.get_create_url():
+            links["New"] = create_url
+
+        return links
+
+
+class AdminCreateView(AdminView, CreateView):
+    template_name = None
+
+    def get_list_url(self) -> str | None:
+        return None
+
+    def get_create_url(self) -> str | None:
+        return None
+
+    def get_detail_url(self, obj) -> str | None:
+        return None
+
+    def get_update_url(self, obj) -> str | None:
+        return None
+
+    def get_delete_url(self, obj) -> str | None:
+        return None
+
+    def get_success_url(self, form):
+        if list_url := self.get_list_url():
+            return list_url
+
+        return super().get_success_url(form)
+
+
+class AdminDetailView(AdminView, DetailView):
+    template_name = None
+    nav_section = ""
+    fields: list[str] = []
+
+    def get_template_context(self):
+        context = super().get_template_context()
+        context["get_field_value"] = self.get_field_value
+        context["get_field_value_template"] = self.get_field_value_template
+        context["fields"] = self.get_fields()
+        return context
+
+    def get_template_names(self) -> list[str]:
+        return super().get_template_names() + [
+            "admin/detail.html",
+        ]
+
+    def get_description(self):
+        return repr(self.object)
+
+    def get_field_value(self, obj, field: str):
+        try:
+            # Try basic dict lookup first
+            if field in obj:
+                return obj[field]
+        except TypeError:
+            pass
+
+        # Try dot notation
+        if "." in field:
+            field, subfield = field.split(".", 1)
+            return self.get_field_value(obj[field], subfield)
+
+        # Try regular object attribute
+        attr = getattr(obj, field)
+
+        # Call if it's callable
+        if callable(attr):
+            return attr()
+        else:
+            return attr
+
+    def get_field_value_template(self, obj, field: str, value):
+        templates = []
+
+        # By type name
+        type_str = type(value).__name__.lower()
+        templates.append(f"admin/values/{type_str}.html")
+
+        # By field name
+        templates.append(f"admin/values/{field}.html")
+
+        # As any model
+        if isinstance(value, Model):
+            templates.append("admin/values/model.html")
+
+        # Default
+        templates.append("admin/values/default.html")
+
+        return templates
+
+    def get_list_url(self) -> str | None:
+        return None
+
+    def get_create_url(self) -> str | None:
+        return None
+
+    def get_detail_url(self, obj) -> str | None:
+        return None
+
+    def get_update_url(self, obj) -> str | None:
+        return None
+
+    def get_delete_url(self, obj) -> str | None:
+        return None
+
+    def get_fields(self):
+        return self.fields.copy()  # Avoid mutating the class attribute itself
+
+    def get_links(self):
+        links = super().get_links()
+
+        if hasattr(self.object, "get_absolute_url"):
+            links["View in app"] = self.object.get_absolute_url()
+
+        if update_url := self.get_update_url(self.object):
+            links["Edit"] = update_url
+
+        if delete_url := self.get_delete_url(self.object):
+            links["Delete"] = delete_url
+
+        return links
+
+    def get_success_url(self, form):
+        if detail_url := self.get_detail_url(self.object):
+            return detail_url
+
+        if list_url := self.get_list_url():
+            return list_url
+
+        if update_url := self.get_update_url(self.object):
+            return update_url
+
+        return super().get_success_url(form)
+
+
+class AdminUpdateView(AdminView, UpdateView):
+    template_name = None
+    nav_section = ""
+
+    def get_list_url(self) -> str | None:
+        return None
+
+    def get_create_url(self) -> str | None:
+        return None
+
+    def get_detail_url(self, obj) -> str | None:
+        return None
+
+    def get_update_url(self, obj) -> str | None:
+        return None
+
+    def get_delete_url(self, obj) -> str | None:
+        return None
+
+    def get_description(self):
+        return repr(self.object)
+
+    def get_links(self):
+        links = super().get_links()
+
+        if hasattr(self.object, "get_absolute_url"):
+            links["View in app"] = self.object.get_absolute_url()
+
+        if detail_url := self.get_detail_url(self.object):
+            links["View"] = detail_url
+
+        if delete_url := self.get_delete_url(self.object):
+            links["Delete"] = delete_url
+
+        return links
+
+
+class AdminDeleteView(AdminView, DeleteView):
+    template_name = "admin/delete.html"
+    nav_section = ""
+
+    def get_description(self):
+        return repr(self.object)
+
+    def get_list_url(self) -> str | None:
+        return None
+
+    def get_create_url(self) -> str | None:
+        return None
+
+    def get_detail_url(self, obj) -> str | None:
+        return None
+
+    def get_update_url(self, obj) -> str | None:
+        return None
+
+    def get_delete_url(self, obj) -> str | None:
+        return None
+
+    def get_links(self):
+        links = super().get_links()
+
+        if hasattr(self.object, "get_absolute_url"):
+            links["View in app"] = self.object.get_absolute_url()
+
+        if detail_url := self.get_detail_url(self.object):
+            links["View"] = detail_url
+
+        if update_url := self.get_update_url(self.object):
+            links["Edit"] = update_url
+
+        return links
+
+    def get_success_url(self, form):
+        if list_url := self.get_list_url():
+            return list_url
+
+        return super().get_success_url(form)