hunt-framework 0.2.2__py3-none-any.whl

hunt/admin/controllers/resource.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hunt.http.request import Request
+from hunt.http.response import HttpException, RedirectResponse, Response
+from hunt.validation.validator import Validator
+
+
+def _get_resource(resource_key: str) -> Any:
+    from hunt.admin.application import Admin
+
+    resource_cls = Admin.find_resource(resource_key)
+    if resource_cls is None:
+        raise HttpException(404, "Resource not found.")
+    return resource_cls()
+
+
+def _get_instance(resource: Any, id: str) -> Any:
+    try:
+        instance = resource.model.find(id)
+    except Exception:
+        instance = None
+    if instance is None:
+        raise HttpException(404, "Record not found.")
+    return instance
+
+
+def _flash_and_redirect(request: Request, key: str, message: str, url: str) -> RedirectResponse:
+    store = getattr(request, "_session", None)
+    if store is not None:
+        store.flash(key, message)
+    return RedirectResponse(url)
+
+
+def index(request: Request, resource_key: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    if not resource.can_view_any(request):
+        raise HttpException(403, "Forbidden.")
+
+    try:
+        page = int(request.query("page", "1"))
+    except (ValueError, TypeError):
+        page = 1
+
+    _options = resource.per_page_options or [10, 25, 50, 100]
+    _default = resource.per_page if resource.per_page in _options else _options[0]
+    try:
+        per_page = int(request.query("per_page", str(_default)))
+        if per_page not in _options:
+            per_page = _default
+    except (ValueError, TypeError):
+        per_page = _default
+
+    query = resource.index_query(request)
+    paginate_result = query.paginate(per_page, page)
+
+    index_fields = [f for f in resource.fields() if f._show_on_index]
+    ctx = Admin._base_context(request)
+    ctx.update(
+        {
+            "title": resource.get_label_plural(),
+            "resource": resource,
+            "resource_key": resource_key,
+            "items": paginate_result["data"],
+            "pagination": paginate_result,
+            "fields": index_fields,
+            "search": request.query("search", ""),
+            "sort": request.query("sort", ""),
+            "dir": request.query("dir", "desc"),
+            "filters": resource.filters(),
+            "actions": resource.actions(),
+            "metrics": [],
+            "per_page": per_page,
+            "per_page_options": _options,
+            "can_create": resource.can_create(request),
+            "can_update": resource.can_update(request),
+            "can_delete": resource.can_delete(request),
+        }
+    )
+
+    # Calculate per-resource metrics
+    for card in resource.metrics():
+        try:
+            data = card.calculate()
+            data["metric_type"] = card.metric_type
+            ctx["metrics"].append(data)
+        except Exception:
+            pass
+
+    return Admin._render("admin/resource/index.html", ctx)
+
+
+def show(request: Request, resource_key: str, id: str) -> Response:
+    from hunt.admin.application import Admin
+    from hunt.admin.fields.has_many import HasMany
+
+    resource = _get_resource(resource_key)
+    if not resource.can_view_any(request):
+        raise HttpException(403, "Forbidden.")
+
+    instance = _get_instance(resource, id)
+    detail_fields = [f for f in resource.fields() if f._show_on_detail]
+    has_many_panels = [f for f in resource.fields() if isinstance(f, HasMany)]
+
+    related_data = {}
+    for panel in has_many_panels:
+        try:
+            related_resource_inst = panel.related_resource_class()
+            fk = panel.foreign_key or f"{type(instance).__name__.lower()}_id"
+            rel_query = related_resource_inst.model.query().where(fk, instance._attributes.get("id"))
+            related_data[panel.attribute] = rel_query.limit(20).get()
+        except Exception:
+            related_data[panel.attribute] = []
+
+    ctx = Admin._base_context(request)
+    ctx.update(
+        {
+            "title": resource.title(instance),
+            "resource": resource,
+            "resource_key": resource_key,
+            "instance": instance,
+            "fields": detail_fields,
+            "has_many_panels": has_many_panels,
+            "related_data": related_data,
+            "record_id": id,
+            "can_update": resource.can_update(request, instance),
+            "can_delete": resource.can_delete(request, instance),
+        }
+    )
+    return Admin._render("admin/resource/show.html", ctx)
+
+
+def create(request: Request, resource_key: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    if not resource.can_create(request):
+        raise HttpException(403, "Forbidden.")
+
+    create_fields = [f for f in resource.fields() if f._show_on_create]
+    ctx = Admin._base_context(request)
+    ctx.update(
+        {
+            "title": f"Create {resource.get_label()}",
+            "resource": resource,
+            "resource_key": resource_key,
+            "fields": create_fields,
+        }
+    )
+    return Admin._render("admin/resource/create.html", ctx)
+
+
+def _collect_data(request: Request, fields: list) -> dict:
+    """Merge form text values with uploaded files for the given field list."""
+    from hunt.admin.fields.image import Image as ImageField
+    from hunt.validation.validator import ValidationException
+
+    allowed_attrs = {f.attribute for f in fields if not f._readonly}
+    raw_data = request.all()
+    data = {k: v for k, v in raw_data.items() if k in allowed_attrs}
+    size_errors: dict[str, list[str]] = {}
+    for field in fields:
+        if isinstance(field, ImageField) and not field._readonly:
+            uploaded = request.file(field.attribute)
+            if uploaded is not None and uploaded.size > 0:
+                if uploaded.size > field._max_kb * 1024:
+                    size_errors[field.attribute] = [f"The file may not be greater than {field._max_kb} KB."]
+                else:
+                    data[field.attribute] = uploaded
+    if size_errors:
+        raise ValidationException(size_errors)
+    return data
+
+
+def _store_image_fields(data: dict, fields: list) -> dict:
+    """Replace UploadedFile values with stored paths; skip if no file submitted."""
+    from hunt.admin.fields.image import Image as ImageField
+    from hunt.http.request import UploadedFile
+
+    result = {}
+    field_map = {f.attribute: f for f in fields if not f._readonly}
+    for key, value in data.items():
+        if isinstance(value, UploadedFile):
+            field = field_map.get(key)
+            disk = field._disk if field and isinstance(field, ImageField) else "public"
+            path = field._path if field and isinstance(field, ImageField) else "uploads"
+            result[key] = value.store(path, disk)
+        else:
+            result[key] = value
+    return result
+
+
+def store(request: Request, resource_key: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    if not resource.can_create(request):
+        raise HttpException(403, "Forbidden.")
+
+    create_fields = [f for f in resource.fields() if f._show_on_create]
+    rules = {f.attribute: "|".join(f._rules) for f in create_fields if f._rules}
+    data = _collect_data(request, create_fields)
+
+    if rules:
+        Validator.make(data, rules).validate()
+
+    stored = _store_image_fields(data, create_fields)
+    resource.model.create(stored)
+
+    return _flash_and_redirect(
+        request,
+        "admin_success",
+        f"{resource.get_label()} created successfully.",
+        f"{Admin.prefix}/resources/{resource_key}",
+    )
+
+
+def edit(request: Request, resource_key: str, id: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    instance = _get_instance(resource, id)
+    if not resource.can_update(request, instance):
+        raise HttpException(403, "Forbidden.")
+
+    edit_fields = [f for f in resource.fields() if f._show_on_edit]
+    ctx = Admin._base_context(request)
+    ctx.update(
+        {
+            "title": f"Edit {resource.title(instance)}",
+            "resource": resource,
+            "resource_key": resource_key,
+            "instance": instance,
+            "fields": edit_fields,
+            "old": ctx["old"] or instance._attributes,
+            "record_id": id,
+        }
+    )
+    return Admin._render("admin/resource/edit.html", ctx)
+
+
+def update(request: Request, resource_key: str, id: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    instance = _get_instance(resource, id)
+    if not resource.can_update(request, instance):
+        raise HttpException(403, "Forbidden.")
+
+    edit_fields = [f for f in resource.fields() if f._show_on_edit]
+    rules = {f.attribute: "|".join(f._rules) for f in edit_fields if f._rules}
+    data = _collect_data(request, edit_fields)
+
+    if rules:
+        Validator.make(data, rules).validate()
+
+    stored = _store_image_fields(data, edit_fields)
+    from hunt.http.request import UploadedFile
+
+    final = {k: v for k, v in stored.items() if not isinstance(v, UploadedFile)}
+    instance.fill(final)
+    instance.save()
+
+    return _flash_and_redirect(
+        request,
+        "admin_success",
+        f"{resource.get_label()} updated successfully.",
+        f"{Admin.prefix}/resources/{resource_key}/{id}",
+    )
+
+
+def destroy(request: Request, resource_key: str, id: str) -> Response:
+    from hunt.admin.application import Admin
+
+    resource = _get_resource(resource_key)
+    instance = _get_instance(resource, id)
+    if not resource.can_delete(request, instance):
+        raise HttpException(403, "Forbidden.")
+
+    try:
+        instance.delete()
+    except Exception:
+        return _flash_and_redirect(
+            request,
+            "admin_error",
+            "Could not delete record. Please try again.",
+            f"{Admin.prefix}/resources/{resource_key}",
+        )
+
+    return _flash_and_redirect(
+        request,
+        "admin_success",
+        f"{resource.get_label()} deleted successfully.",
+        f"{Admin.prefix}/resources/{resource_key}",
+    )

hunt/admin/controllers/search.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from hunt.http.request import Request
+from hunt.http.response import JsonResponse
+
+
+def index(request: Request) -> JsonResponse:
+    from hunt.admin.application import Admin
+
+    q = str(request.query("q", "") or "").strip()
+    if not q:
+        return JsonResponse({"groups": []})
+    q = q[:200]  # cap to avoid pathological LIKE patterns
+    groups = []
+
+    for resource_cls in Admin._resources:
+        resource = resource_cls()
+        if not resource.search_columns:
+            continue
+
+        try:
+            query = resource.model.query()
+            first_col = resource.search_columns[0]
+            query = query.where(first_col, "LIKE", f"%{q}%")
+            for col in resource.search_columns[1:]:
+                try:
+                    query = query.or_where(col, "LIKE", f"%{q}%")
+                except ValueError:
+                    pass
+            items = query.limit(5).get()
+
+            if not items:
+                continue
+
+            groups.append(
+                {
+                    "resource": resource_cls.get_label(),
+                    "resource_key": resource_cls.slug(),
+                    "resource_url": f"{Admin.prefix}/resources/{resource_cls.slug()}",
+                    "items": [
+                        {
+                            "id": item._attributes.get("id"),
+                            "title": resource.title(item),
+                            "url": f"{Admin.prefix}/resources/{resource_cls.slug()}/{item._attributes.get('id')}",
+                        }
+                        for item in items
+                    ],
+                }
+            )
+        except Exception:
+            continue
+
+    return JsonResponse({"groups": groups})

hunt/admin/field.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hunt.support.str import Str
+
+
+class Field:
+    """Base field for AdminResource definitions."""
+
+    field_type: str = "text"
+
+    def __init__(self, name: str, attribute: str | None = None) -> None:
+        self.name = name
+        self.attribute = attribute if attribute is not None else Str.snake(name)
+        self.label = name
+        self.field_type = self.__class__.field_type
+
+        self._show_on_index: bool = True
+        self._show_on_detail: bool = True
+        self._show_on_create: bool = True
+        self._show_on_edit: bool = True
+        self._sortable: bool = False
+        self._readonly: bool = False
+        self._help_text: str = ""
+        self._nullable: bool = False
+        self._rules: list[str] = []
+        self._panel: str | None = None
+
+    # ------------------------------------------------------------------
+    # Fluent visibility / behaviour setters
+    # ------------------------------------------------------------------
+
+    def hide_from_index(self) -> Field:
+        self._show_on_index = False
+        return self
+
+    def hide_from_detail(self) -> Field:
+        self._show_on_detail = False
+        return self
+
+    def hide_from_forms(self) -> Field:
+        self._show_on_create = False
+        self._show_on_edit = False
+        return self
+
+    def hide_from_create(self) -> Field:
+        self._show_on_create = False
+        return self
+
+    def hide_from_edit(self) -> Field:
+        self._show_on_edit = False
+        return self
+
+    def only_on_index(self) -> Field:
+        self._show_on_detail = False
+        self._show_on_create = False
+        self._show_on_edit = False
+        return self
+
+    def only_on_forms(self) -> Field:
+        self._show_on_index = False
+        self._show_on_detail = False
+        return self
+
+    def only_on_detail(self) -> Field:
+        self._show_on_index = False
+        self._show_on_create = False
+        self._show_on_edit = False
+        return self
+
+    def show_on_index(self) -> Field:
+        self._show_on_index = True
+        return self
+
+    def show_on_detail(self) -> Field:
+        self._show_on_detail = True
+        return self
+
+    def show_on_create(self) -> Field:
+        self._show_on_create = True
+        return self
+
+    def show_on_edit(self) -> Field:
+        self._show_on_edit = True
+        return self
+
+    def sortable(self) -> Field:
+        self._sortable = True
+        return self
+
+    def readonly(self) -> Field:
+        self._readonly = True
+        return self
+
+    def help(self, text: str) -> Field:
+        self._help_text = text
+        return self
+
+    def rules(self, *r: str) -> Field:
+        self._rules = list(r)
+        return self
+
+    def nullable(self) -> Field:
+        self._nullable = True
+        return self
+
+    def panel(self, name: str) -> Field:
+        self._panel = name
+        return self
+
+    # ------------------------------------------------------------------
+    # Value resolution
+    # ------------------------------------------------------------------
+
+    def value_for(self, instance: Any) -> Any:
+        return instance._attributes.get(self.attribute)
+
+    def display_value(self, instance: Any) -> str:
+        val = self.value_for(instance)
+        if val is None:
+            return ""
+        return str(val)

hunt/admin/fields/__init__.py

@@ -0,0 +1,30 @@
+from hunt.admin.fields.badge import Badge
+from hunt.admin.fields.belongs_to import BelongsTo
+from hunt.admin.fields.boolean import Boolean
+from hunt.admin.fields.datetime_ import Date, DateTime
+from hunt.admin.fields.has_many import HasMany
+from hunt.admin.fields.image import Image
+from hunt.admin.fields.number import Currency, Number
+from hunt.admin.fields.richtext import RichText
+from hunt.admin.fields.select import Select
+from hunt.admin.fields.text import Email, Password, Slug, Text
+from hunt.admin.fields.textarea import Textarea
+
+__all__ = [
+    "Badge",
+    "BelongsTo",
+    "Boolean",
+    "Currency",
+    "Date",
+    "DateTime",
+    "Email",
+    "HasMany",
+    "Image",
+    "Number",
+    "Password",
+    "RichText",
+    "Select",
+    "Slug",
+    "Text",
+    "Textarea",
+]

hunt/admin/fields/badge.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hunt.admin.field import Field
+
+_DEFAULT_COLOUR = "gray"
+
+
+class Badge(Field):
+    field_type: str = "badge"
+
+    def __init__(
+        self,
+        name: str,
+        colour_map: dict | None = None,
+        attribute: str | None = None,
+    ) -> None:
+        super().__init__(name, attribute)
+        self._colour_map: dict = colour_map or {}
+
+    def get_colour(self, value: Any) -> str:
+        if value is None:
+            return _DEFAULT_COLOUR
+        return self._colour_map.get(str(value), _DEFAULT_COLOUR)

hunt/admin/fields/belongs_to.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from hunt.admin.field import Field
+
+
+class BelongsTo(Field):
+    field_type: str = "belongs_to"
+
+    def __init__(
+        self,
+        name: str,
+        related_resource_class: type,
+        attribute: str | None = None,
+    ) -> None:
+        super().__init__(name, attribute)
+        self.related_resource_class = related_resource_class
+        self._searchable: bool = False
+
+    def searchable(self) -> BelongsTo:
+        self._searchable = True
+        return self

hunt/admin/fields/boolean.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hunt.admin.field import Field
+
+
+class Boolean(Field):
+    field_type: str = "boolean"
+
+    def display_value(self, instance: Any) -> str:
+        val = self.value_for(instance)
+        if val is None:
+            return ""
+        return "Yes" if val else "No"

hunt/admin/fields/datetime_.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+from hunt.admin.field import Field
+
+
+def _parse_and_format(value: Any, fmt: str) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (datetime.datetime, datetime.date)):
+        return value.strftime(fmt)
+    if isinstance(value, (int, float)):
+        # Unix timestamp
+        try:
+            return datetime.datetime.fromtimestamp(value).strftime(fmt)
+        except (OSError, OverflowError, ValueError):
+            return str(value)
+    if isinstance(value, str):
+        # Try common ISO formats
+        for parse_fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"):
+            try:
+                return datetime.datetime.strptime(value, parse_fmt).strftime(fmt)
+            except ValueError:
+                continue
+        return value
+    return str(value)
+
+
+class DateTime(Field):
+    field_type: str = "datetime"
+
+    def __init__(self, name: str, attribute: str | None = None) -> None:
+        super().__init__(name, attribute)
+        self._format: str = "%Y-%m-%d %H:%M"
+
+    def format(self, fmt: str) -> DateTime:
+        self._format = fmt
+        return self
+
+    def display_value(self, instance: Any) -> str:
+        return _parse_and_format(self.value_for(instance), self._format)
+
+
+class Date(Field):
+    field_type: str = "date"
+
+    def __init__(self, name: str, attribute: str | None = None) -> None:
+        super().__init__(name, attribute)
+        self._format: str = "%Y-%m-%d"
+
+    def format(self, fmt: str) -> Date:
+        self._format = fmt
+        return self
+
+    def display_value(self, instance: Any) -> str:
+        return _parse_and_format(self.value_for(instance), self._format)

hunt/admin/fields/has_many.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from hunt.admin.field import Field
+
+
+class HasMany(Field):
+    field_type: str = "has_many"
+
+    def __init__(
+        self,
+        name: str,
+        related_resource_class: type,
+        foreign_key: str | None = None,
+        attribute: str | None = None,
+    ) -> None:
+        super().__init__(name, attribute)
+        self.related_resource_class = related_resource_class
+        self.foreign_key = foreign_key
+        # HasMany panels are never displayed in these views
+        self.hide_from_index()
+        self.hide_from_create()
+        self.hide_from_edit()