codex-fastapi-cabinet 0.1.0__py3-none-any.whl

fastapi_cabinet/runtime.py

@@ -0,0 +1,58 @@
+from fastapi_cabinet.contracts.admin import CabinetAdmin
+from fastapi_cabinet.contracts.pages import CabinetPage
+from fastapi_cabinet.registry import CabinetRegistry
+
+
+def normalize_mount_path(mount_path: str) -> str:
+    normalized = "/" + mount_path.strip("/")
+    return "/" if normalized == "/" else normalized
+
+
+def admin_public_path(admin: CabinetAdmin, mount_path: str = "/cabinet") -> str:
+    if admin.path:
+        return "/" + admin.path.strip("/")
+    mount = normalize_mount_path(mount_path).rstrip("/")
+    return f"{mount}/{admin.key}"
+
+
+def admin_route_path(admin: CabinetAdmin, mount_path: str = "/cabinet") -> str:
+    public_path = admin_public_path(admin, mount_path)
+    mount = normalize_mount_path(mount_path).rstrip("/")
+    if public_path == mount:
+        return ""
+    if public_path.startswith(f"{mount}/"):
+        return public_path.removeprefix(mount)
+    return public_path
+
+
+def page_public_path(admin: CabinetAdmin, page: CabinetPage, mount_path: str = "/cabinet") -> str:
+    admin_path = admin_public_path(admin, mount_path).rstrip("/")
+    suffix = page.path.strip("/")
+    return admin_path if not suffix else f"{admin_path}/{suffix}"
+
+
+def action_public_path(admin: CabinetAdmin, action_path: str, mount_path: str = "/cabinet") -> str:
+    admin_path = admin_public_path(admin, mount_path).rstrip("/")
+    suffix = action_path.strip("/")
+    return admin_path if not suffix else f"{admin_path}/{suffix}"
+
+
+def resolve_active_admin(
+    request_path: str,
+    registry: CabinetRegistry,
+    mount_path: str = "/cabinet",
+) -> CabinetAdmin | None:
+    normalized_request_path = "/" + request_path.strip("/")
+    matches = [
+        admin
+        for admin in registry.all()
+        if _path_matches(normalized_request_path, admin_public_path(admin, mount_path))
+    ]
+    if not matches:
+        return None
+    return max(matches, key=lambda admin: len(admin_public_path(admin, mount_path)))
+
+
+def _path_matches(request_path: str, candidate_path: str) -> bool:
+    normalized_candidate = "/" + candidate_path.strip("/")
+    return request_path == normalized_candidate or request_path.startswith(f"{normalized_candidate}/")

fastapi_cabinet/site.py

@@ -0,0 +1,262 @@
+from collections.abc import Awaitable, Callable, Sequence
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Request, status
+from fastapi.templating import Jinja2Templates
+from jinja2 import BaseLoader, ChoiceLoader, FileSystemLoader
+from starlette.responses import RedirectResponse, Response
+
+from fastapi_cabinet.contracts.admin import ActionRoute, CabinetAdmin
+from fastapi_cabinet.contracts.navigation import SidebarItem
+from fastapi_cabinet.contracts.pages import CabinetPage
+from fastapi_cabinet.contracts.permissions import AllowAllPermissionProvider, PermissionProvider
+from fastapi_cabinet.contracts.widgets import DashboardWidget
+from fastapi_cabinet.exceptions import CabinetRegistrationError
+from fastapi_cabinet.registry import CabinetRegistry
+from fastapi_cabinet.rendering.layout_mapper import build_layout_map
+from fastapi_cabinet.rendering.page_mapper import resolve_page
+from fastapi_cabinet.rendering.widget_mapper import resolve_widgets
+from fastapi_cabinet.runtime import action_public_path, admin_public_path, normalize_mount_path, page_public_path
+
+_PACKAGE_DIR = Path(__file__).parent
+_PACKAGE_TEMPLATE_DIR = _PACKAGE_DIR / "templates"
+
+
+class CabinetSite:
+    """Application-scoped cabinet composition root."""
+
+    def __init__(
+        self,
+        *,
+        brand_name: str = "Cabinet",
+        permission_provider: PermissionProvider | None = None,
+        templates: Jinja2Templates | None = None,
+        template_directories: Sequence[str | Path] = (),
+    ) -> None:
+        self.brand_name = brand_name
+        self.permission_provider = permission_provider or AllowAllPermissionProvider()
+        self.registry = CabinetRegistry()
+        self.templates = _build_templates(templates, template_directories)
+        self.static_mount_path: str | None = None
+
+    def register(self, admin: type[CabinetAdmin] | CabinetAdmin) -> CabinetAdmin:
+        return self.registry.register(admin)
+
+    def build_router(
+        self,
+        *,
+        mount_path: str = "/cabinet",
+        static_mount_path: str | None = None,
+    ) -> APIRouter:
+        mount = normalize_mount_path(mount_path)
+        assets = static_mount_path or f"{mount.rstrip('/')}/static"
+        router = APIRouter()
+
+        @router.get(mount, name="cabinet:dashboard")
+        async def dashboard(request: Request) -> Response:
+            admins = await self._visible_admins(request)
+            if admins:
+                return RedirectResponse(url=admin_public_path(admins[0], mount), status_code=303)
+            layout = build_layout_map(
+                admins,
+                mount_path=mount,
+                static_mount_path=assets,
+                brand_name=self.brand_name,
+                active_admin=None,
+                active_path=str(request.url.path),
+            )
+            return self.templates.TemplateResponse(
+                request=request,
+                name="cabinet/dashboard.html",
+                context=self._context(request, layout=layout, modules=admins),
+            )
+
+        for admin in self.registry.all():
+            self._register_admin_routes(router, admin, mount, assets)
+        return router
+
+    def _register_admin_routes(
+        self,
+        router: APIRouter,
+        admin: CabinetAdmin,
+        mount_path: str,
+        static_mount_path: str,
+    ) -> None:
+        router.get(admin_public_path(admin, mount_path), name=f"cabinet:{admin.key}")(
+            self._build_module_endpoint(admin, mount_path, static_mount_path)
+        )
+
+        for action in sorted(admin.actions, key=lambda item: item.path):
+            handler = getattr(admin, action.handler, None)
+            if not callable(handler):
+                raise CabinetRegistrationError(
+                    f"Cabinet admin {admin.key!r} action {action.path!r} references missing handler "
+                    f"{action.handler!r}."
+                )
+            endpoint = self._build_action_endpoint(admin, action, handler)
+            router.add_api_route(
+                action_public_path(admin, action.path, mount_path),
+                endpoint,
+                methods=[action.method],
+                name=action.name or f"cabinet:{admin.key}:action:{action.path.strip('/')}",
+            )
+
+        for page in sorted(admin.pages, key=_page_sort_key):
+            router.get(
+                page_public_path(admin, page, mount_path),
+                name=f"cabinet:{admin.key}:page:{page.key}",
+            )(self._build_page_endpoint(admin, page, mount_path, static_mount_path))
+
+    def _build_module_endpoint(
+        self,
+        admin: CabinetAdmin,
+        mount_path: str,
+        static_mount_path: str,
+    ) -> Callable[[Request], Awaitable[Response]]:
+        async def module_page(request: Request) -> Response:
+            await self._ensure_allowed(request, admin.permission)
+            visible_admins = await self._visible_admins(request)
+            sidebar = await self._visible_sidebar(request, admin.sidebar)
+            widget_declarations = await self._visible_widgets(request, admin.dashboard_widgets)
+            badges = await admin.get_sidebar_badges(request)
+            layout = build_layout_map(
+                visible_admins,
+                mount_path=mount_path,
+                static_mount_path=static_mount_path,
+                brand_name=self.brand_name,
+                active_admin=admin,
+                active_path=str(request.url.path),
+                sidebar=sidebar,
+                sidebar_badges=badges,
+            )
+            return self.templates.TemplateResponse(
+                request=request,
+                name="cabinet/module.html",
+                context=self._context(
+                    request,
+                    layout=layout,
+                    module=admin,
+                    module_context=await admin.get_dashboard_context(request),
+                    widgets=await resolve_widgets(admin, widget_declarations, request),
+                ),
+            )
+
+        return module_page
+
+    def _build_page_endpoint(
+        self,
+        admin: CabinetAdmin,
+        declaration: CabinetPage,
+        mount_path: str,
+        static_mount_path: str,
+    ) -> Callable[[Request], Awaitable[Response]]:
+        async def page_endpoint(request: Request) -> Response:
+            await self._ensure_allowed(request, admin.permission)
+            await self._ensure_allowed(request, declaration.permission)
+            visible_admins = await self._visible_admins(request)
+            sidebar = await self._visible_sidebar(request, admin.sidebar)
+            layout = build_layout_map(
+                visible_admins,
+                mount_path=mount_path,
+                static_mount_path=static_mount_path,
+                brand_name=self.brand_name,
+                active_admin=admin,
+                active_path=str(request.url.path),
+                sidebar=sidebar,
+                sidebar_badges=await admin.get_sidebar_badges(request),
+                title=declaration.label,
+            )
+            page = await resolve_page(admin, declaration, request)
+            template = declaration.template or f"cabinet/pages/{declaration.kind}.html"
+            return self.templates.TemplateResponse(
+                request=request,
+                name=template,
+                context=self._context(
+                    request,
+                    layout=layout,
+                    module=admin,
+                    declaration=declaration,
+                    page=page,
+                ),
+            )
+
+        return page_endpoint
+
+    def _build_action_endpoint(
+        self,
+        admin: CabinetAdmin,
+        action: ActionRoute,
+        handler: Callable[[Request], Awaitable[Response]],
+    ) -> Callable[[Request], Awaitable[Response]]:
+        async def action_endpoint(request: Request) -> Response:
+            await self._ensure_allowed(request, admin.permission)
+            await self._ensure_allowed(request, action.permission)
+            return await handler(request)
+
+        return action_endpoint
+
+    async def _visible_admins(self, request: Request) -> tuple[CabinetAdmin, ...]:
+        result: list[CabinetAdmin] = []
+        for admin in self.registry.all():
+            if await self._is_allowed(request, admin.permission):
+                result.append(admin)
+        return tuple(result)
+
+    async def _visible_sidebar(
+        self,
+        request: Request,
+        items: tuple[SidebarItem, ...],
+    ) -> list[SidebarItem]:
+        result: list[SidebarItem] = []
+        for item in items:
+            if await self._is_allowed(request, item.permission):
+                result.append(item)
+        return result
+
+    async def _visible_widgets(
+        self,
+        request: Request,
+        widgets: tuple[DashboardWidget, ...],
+    ) -> tuple[DashboardWidget, ...]:
+        result: list[DashboardWidget] = []
+        for widget in widgets:
+            if await self._is_allowed(request, widget.permission):
+                result.append(widget)
+        return tuple(result)
+
+    async def _is_allowed(self, request: Request, permission: str | None) -> bool:
+        return permission is None or await self.permission_provider.can(request, permission)
+
+    async def _ensure_allowed(self, request: Request, permission: str | None) -> None:
+        if not await self._is_allowed(request, permission):
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Cabinet permission denied.")
+
+    @staticmethod
+    def _context(request: Request, **values: object) -> dict[str, object]:
+        return {
+            "request": request,
+            "csrf_token": getattr(request.state, "csrf_token", ""),
+            **values,
+        }
+
+
+def _page_sort_key(page: CabinetPage) -> tuple[int, int, str]:
+    return (page.path.count("{"), page.order, page.key)
+
+
+def _build_templates(
+    templates: Jinja2Templates | None,
+    template_directories: Sequence[str | Path],
+) -> Jinja2Templates:
+    active = templates or Jinja2Templates(directory=str(_PACKAGE_TEMPLATE_DIR))
+    loaders: list[BaseLoader] = [
+        FileSystemLoader(str(Path(directory))) for directory in template_directories
+    ]
+    if templates is not None and templates.env.loader is not None:
+        loaders.append(templates.env.loader)
+    loaders.append(FileSystemLoader(str(_PACKAGE_TEMPLATE_DIR)))
+    active.env.loader = ChoiceLoader(loaders)
+    return active
+
+
+cabinet_site = CabinetSite()

fastapi_cabinet/static/css/cabinet.css

@@ -0,0 +1,126 @@
+:root {
+    color-scheme: light;
+    --fc-bg: #f4f6f8;
+    --fc-surface: #ffffff;
+    --fc-text: #18202a;
+    --fc-muted: #657180;
+    --fc-border: #dfe4ea;
+    --fc-primary: #2952cc;
+    --fc-primary-soft: #edf2ff;
+    --fc-danger: #b42318;
+    --fc-radius: 12px;
+    font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+* { box-sizing: border-box; }
+body { margin: 0; color: var(--fc-text); background: var(--fc-bg); }
+a { color: var(--fc-primary); text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+.fc-shell { min-height: 100vh; }
+.fc-topbar {
+    min-height: 64px;
+    display: flex;
+    align-items: center;
+    gap: 32px;
+    padding: 0 24px;
+    color: #fff;
+    background: #111827;
+}
+.fc-brand { color: #fff; font-weight: 750; letter-spacing: .01em; }
+.fc-module-nav, .fc-nav-group { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+.fc-nav-group__label { color: #9ca3af; margin-right: 4px; font-size: .75rem; text-transform: uppercase; }
+.fc-nav-link { color: #d1d5db; padding: 9px 12px; border-radius: 8px; }
+.fc-nav-link:hover, .fc-nav-link.is-active { color: #fff; background: #263244; text-decoration: none; }
+.fc-workspace { display: grid; grid-template-columns: minmax(210px, 260px) 1fr; min-height: calc(100vh - 64px); }
+.fc-sidebar { padding: 20px 14px; border-right: 1px solid var(--fc-border); background: var(--fc-surface); }
+.fc-sidebar-link { display: flex; justify-content: space-between; align-items: center; padding: 10px 12px; border-radius: 8px; color: var(--fc-text); }
+.fc-sidebar-link:hover, .fc-sidebar-link.is-active { background: var(--fc-primary-soft); text-decoration: none; }
+.fc-badge { min-width: 22px; padding: 2px 7px; border-radius: 999px; text-align: center; background: #e5e7eb; font-size: .75rem; }
+.fc-main { width: 100%; max-width: 1440px; padding: 32px; }
+.fc-page-header { display: flex; justify-content: space-between; align-items: end; gap: 16px; margin-bottom: 24px; }
+.fc-page-header h1 { margin: 4px 0 0; font-size: clamp(1.7rem, 3vw, 2.35rem); }
+.fc-eyebrow { margin: 0; color: var(--fc-primary); font-size: .75rem; font-weight: 750; letter-spacing: .08em; text-transform: uppercase; }
+.fc-muted { color: var(--fc-muted); }
+.fc-card { padding: 20px; margin-bottom: 20px; border: 1px solid var(--fc-border); border-radius: var(--fc-radius); background: var(--fc-surface); box-shadow: 0 1px 2px rgb(15 23 42 / 4%); }
+.fc-card-title { margin: 0 0 16px; font-size: 1rem; }
+.fc-widget-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 16px; }
+.fc-widget { margin: 0; }
+.fc-span-1 { grid-column: span 1; }
+.fc-span-2 { grid-column: span 2; }
+.fc-span-3 { grid-column: span 3; }
+.fc-span-4 { grid-column: span 4; }
+.fc-metric { display: flex; justify-content: space-between; gap: 16px; }
+.fc-metric-value { margin: 4px 0 0; font-size: 2rem; font-weight: 750; }
+.fc-metric-icon { font-size: 2rem; }
+.fc-trend { color: #067647; font-size: .875rem; }
+.fc-table-wrap { width: 100%; overflow-x: auto; }
+.fc-table { width: 100%; border-collapse: collapse; }
+.fc-table th, .fc-table td { padding: 12px 10px; border-bottom: 1px solid var(--fc-border); text-align: left; vertical-align: top; }
+.fc-table th { color: var(--fc-muted); font-size: .75rem; letter-spacing: .04em; text-transform: uppercase; }
+.fc-table .is-center { text-align: center; }
+.fc-table .is-right { text-align: right; }
+.fc-actions { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+.fc-actions form { margin: 0; }
+.fc-button {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 38px;
+    padding: 8px 13px;
+    border: 1px solid var(--fc-border);
+    border-radius: 8px;
+    color: var(--fc-text);
+    background: var(--fc-surface);
+    font: inherit;
+    cursor: pointer;
+}
+.fc-button:hover { border-color: #aab4c0; text-decoration: none; }
+.fc-button.is-primary { color: #fff; border-color: var(--fc-primary); background: var(--fc-primary); }
+.fc-button.is-danger { color: #fff; border-color: var(--fc-danger); background: var(--fc-danger); }
+.fc-empty { padding: 32px; border: 1px dashed #b8c1cc; border-radius: var(--fc-radius); color: var(--fc-muted); text-align: center; }
+.fc-filters { display: flex; align-items: end; gap: 12px; flex-wrap: wrap; }
+.fc-filters label, .fc-field { display: grid; gap: 7px; font-weight: 600; }
+.fc-form { display: grid; gap: 18px; max-width: 760px; }
+input, select, textarea {
+    width: 100%;
+    min-height: 40px;
+    padding: 9px 11px;
+    border: 1px solid #b8c1cc;
+    border-radius: 8px;
+    color: var(--fc-text);
+    background: #fff;
+    font: inherit;
+}
+input[type="checkbox"] { width: 18px; min-height: 18px; }
+textarea { min-height: 120px; resize: vertical; }
+.fc-error { color: var(--fc-danger); }
+.fc-alert { padding: 12px 14px; border-radius: 8px; background: #eef4ff; }
+.fc-alert.is-error { color: var(--fc-danger); background: #fef3f2; }
+.fc-pagination { display: flex; align-items: center; justify-content: center; gap: 14px; }
+.fc-details { display: grid; gap: 0; margin: 0; }
+.fc-details > div { display: grid; grid-template-columns: minmax(130px, 1fr) 3fr; gap: 20px; padding: 12px 0; border-bottom: 1px solid var(--fc-border); }
+.fc-details > div:last-child { border-bottom: 0; }
+.fc-details dt { color: var(--fc-muted); }
+.fc-details dd { margin: 0; }
+.fc-operation-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 16px; }
+.fc-list { margin: 0; padding-left: 20px; }
+.fc-chart-series dl { display: grid; gap: 8px; }
+.fc-chart-point { display: grid; grid-template-columns: minmax(80px, 1fr) 3fr; align-items: center; gap: 12px; }
+.fc-chart-point dd { position: relative; margin: 0; padding: 5px 8px; border-radius: 5px; background: linear-gradient(90deg, #9db5ff 0 min(calc(var(--fc-value) * 1%), 100%), #edf0f4 0); }
+
+@media (max-width: 900px) {
+    .fc-topbar { align-items: flex-start; flex-direction: column; gap: 12px; padding-block: 16px; }
+    .fc-workspace { display: block; }
+    .fc-sidebar { border-right: 0; border-bottom: 1px solid var(--fc-border); }
+    .fc-main { padding: 22px 16px; }
+    .fc-widget-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+    .fc-span-3, .fc-span-4 { grid-column: span 2; }
+}
+
+@media (max-width: 560px) {
+    .fc-page-header { align-items: flex-start; flex-direction: column; }
+    .fc-widget-grid { grid-template-columns: 1fr; }
+    .fc-span-1, .fc-span-2, .fc-span-3, .fc-span-4 { grid-column: span 1; }
+    .fc-details > div { grid-template-columns: 1fr; gap: 4px; }
+}

fastapi_cabinet/static/js/cabinet.js

@@ -0,0 +1,6 @@
+document.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-confirm]");
+    if (button && !window.confirm(button.dataset.confirm)) {
+        event.preventDefault();
+    }
+});

fastapi_cabinet/templates/cabinet/base.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{ layout.title }} · {{ layout.brand_name }}</title>
+    <link rel="stylesheet" href="{{ layout.static_mount_path }}/css/cabinet.css?v={{ layout.static_version }}">
+</head>
+<body>
+    <div class="fc-shell">
+        {% include "cabinet/includes/topbar.html" %}
+        <div class="fc-workspace">
+            {% include "cabinet/includes/sidebar.html" %}
+            <main class="fc-main" id="main-content">
+                {% block content %}{% endblock %}
+            </main>
+        </div>
+    </div>
+    <script src="{{ layout.static_mount_path }}/js/cabinet.js?v={{ layout.static_version }}" defer></script>
+</body>
+</html>

fastapi_cabinet/templates/cabinet/dashboard.html

@@ -0,0 +1,14 @@
+{% extends "cabinet/base.html" %}
+{% block content %}
+<header class="fc-page-header">
+    <div>
+        <p class="fc-eyebrow">Management</p>
+        <h1>{{ layout.title }}</h1>
+    </div>
+</header>
+{% if modules %}
+    <div class="fc-empty">Choose a management module.</div>
+{% else %}
+    <div class="fc-empty">No management modules are available.</div>
+{% endif %}
+{% endblock %}

fastapi_cabinet/templates/cabinet/includes/sidebar.html

@@ -0,0 +1,20 @@
+{% if layout.sidebar %}
+<aside class="fc-sidebar" aria-label="Module navigation">
+    <nav>
+        {% for item in layout.sidebar %}
+            <a
+                class="fc-sidebar-link{% if layout.active_path == item.path %} is-active{% endif %}"
+                href="{{ item.path }}"
+            >
+                <span>
+                    {% if item.icon %}<span aria-hidden="true">{{ item.icon }}</span>{% endif %}
+                    {{ item.label }}
+                </span>
+                {% if item.badge_key and item.badge_key in layout.sidebar_badges %}
+                    <span class="fc-badge">{{ layout.sidebar_badges[item.badge_key] }}</span>
+                {% endif %}
+            </a>
+        {% endfor %}
+    </nav>
+</aside>
+{% endif %}

fastapi_cabinet/templates/cabinet/includes/topbar.html

@@ -0,0 +1,21 @@
+<header class="fc-topbar">
+    <a class="fc-brand" href="{{ layout.mount_path }}">{{ layout.brand_name }}</a>
+    <nav class="fc-module-nav" aria-label="Management modules">
+        {% for group in layout.header_groups %}
+            <div class="fc-nav-group">
+                {% if layout.header_groups|length > 1 %}
+                    <span class="fc-nav-group__label">{{ group.label }}</span>
+                {% endif %}
+                {% for item in group.items %}
+                    <a
+                        class="fc-nav-link{% if layout.active_module == item.key %} is-active{% endif %}"
+                        href="{{ item.path }}"
+                    >
+                        {% if item.icon %}<span aria-hidden="true">{{ item.icon }}</span>{% endif %}
+                        {{ item.label }}
+                    </a>
+                {% endfor %}
+            </div>
+        {% endfor %}
+    </nav>
+</header>

fastapi_cabinet/templates/cabinet/includes/widget_frame.html

@@ -0,0 +1,3 @@
+<section class="fc-card fc-widget fc-span-{{ widget.span }}" data-widget="{{ widget.key }}">
+    {% include "cabinet/widgets/" ~ widget.kind ~ ".html" %}
+</section>

fastapi_cabinet/templates/cabinet/module.html

@@ -0,0 +1,18 @@
+{% extends "cabinet/base.html" %}
+{% block content %}
+<header class="fc-page-header">
+    <div>
+        <p class="fc-eyebrow">Module</p>
+        <h1>{{ module.label }}</h1>
+    </div>
+</header>
+{% if widgets %}
+    <div class="fc-widget-grid">
+        {% for widget in widgets %}
+            {% include "cabinet/includes/widget_frame.html" %}
+        {% endfor %}
+    </div>
+{% else %}
+    <div class="fc-empty">This module has no dashboard widgets yet.</div>
+{% endif %}
+{% endblock %}

fastapi_cabinet/templates/cabinet/pages/detail.html

@@ -0,0 +1,39 @@
+{% extends "cabinet/base.html" %}
+{% block content %}
+<header class="fc-page-header">
+    <div>
+        <p class="fc-eyebrow">{{ module.label }}</p>
+        <h1>{{ page.title }}</h1>
+        {% if page.subtitle %}<p class="fc-muted">{{ page.subtitle }}</p>{% endif %}
+    </div>
+    <div class="fc-actions">
+        {% for action in page.actions %}<a class="fc-button {{ action.css_class }}" href="{{ action.url }}">{{ action.label }}</a>{% endfor %}
+    </div>
+</header>
+{% if page.back_url %}<p><a href="{{ page.back_url }}">← Back</a></p>{% endif %}
+{% if page.fields %}
+<section class="fc-card">
+    <dl class="fc-details">
+        {% for field in page.fields %}
+        <div>
+            <dt>{{ field.label }}</dt>
+            <dd>{{ field.value }}</dd>
+        </div>
+        {% endfor %}
+    </dl>
+</section>
+{% endif %}
+{% for section in page.sections %}
+<section class="fc-card">
+    <h2 class="fc-card-title">{{ section.title }}</h2>
+    <dl class="fc-details">
+        {% for field in section.fields %}
+        <div>
+            <dt>{{ field.label }}</dt>
+            <dd>{{ field.value }}</dd>
+        </div>
+        {% endfor %}
+    </dl>
+</section>
+{% endfor %}
+{% endblock %}

fastapi_cabinet/templates/cabinet/pages/form.html

@@ -0,0 +1,47 @@
+{% extends "cabinet/base.html" %}
+{% block content %}
+<header class="fc-page-header">
+    <div>
+        <p class="fc-eyebrow">{{ module.label }}</p>
+        <h1>{{ page.title }}</h1>
+        {% if page.subtitle %}<p class="fc-muted">{{ page.subtitle }}</p>{% endif %}
+    </div>
+</header>
+<form class="fc-card fc-form" action="{{ page.action_url }}" method="post">
+    <input type="hidden" name="_method" value="{{ page.method }}">
+    <input type="hidden" name="csrf_token" value="{{ csrf_token }}">
+    {% if page.errors %}
+        <div class="fc-alert is-error" role="alert">
+            {% for error in page.errors %}<p>{{ error }}</p>{% endfor %}
+        </div>
+    {% endif %}
+    {% for field in page.fields %}
+        {% if field.input_type == "hidden" %}
+            <input type="hidden" name="{{ field.name }}" value="{{ field.value }}">
+        {% else %}
+        <label class="fc-field">
+            <span>{{ field.label }}{% if field.required %} <span aria-hidden="true">*</span>{% endif %}</span>
+            {% if field.input_type == "textarea" %}
+                <textarea name="{{ field.name }}" placeholder="{{ field.placeholder }}"{% if field.required %} required{% endif %}{% if field.disabled %} disabled{% endif %}>{{ field.value }}</textarea>
+            {% elif field.input_type == "select" %}
+                <select name="{{ field.name }}"{% if field.required %} required{% endif %}{% if field.disabled %} disabled{% endif %}>
+                    {% for choice in field.choices %}
+                        <option value="{{ choice.value }}"{% if choice.selected %} selected{% endif %}>{{ choice.label }}</option>
+                    {% endfor %}
+                </select>
+            {% elif field.input_type == "checkbox" %}
+                <input type="checkbox" name="{{ field.name }}" value="1"{% if field.value %} checked{% endif %}{% if field.disabled %} disabled{% endif %}>
+            {% else %}
+                <input type="{{ field.input_type }}" name="{{ field.name }}" value="{{ field.value }}" placeholder="{{ field.placeholder }}"{% if field.required %} required{% endif %}{% if field.disabled %} disabled{% endif %}>
+            {% endif %}
+            {% if field.help_text %}<small class="fc-muted">{{ field.help_text }}</small>{% endif %}
+            {% for error in field.errors %}<small class="fc-error">{{ error }}</small>{% endfor %}
+        </label>
+        {% endif %}
+    {% endfor %}
+    <div class="fc-actions">
+        <button class="fc-button is-primary" type="submit">{{ page.submit_label }}</button>
+        {% if page.cancel_url %}<a class="fc-button" href="{{ page.cancel_url }}">{{ page.cancel_label }}</a>{% endif %}
+    </div>
+</form>
+{% endblock %}