fastapi-admin-kit 0.1.0__py3-none-any.whl

fastapi_admin_kit/admin/admin_template.py

@@ -0,0 +1,203 @@
+"""Admin template management and context building."""
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    pass
+
+
+class AdminTemplate:
+    """Manages Jinja2 template environment and sidebar context."""
+
+    def __init__(
+        self,
+        title: str = "FastAPI Admin Kit",
+        logo_url: str | None = None,
+        favicon_url: str | None = None,
+        primary_color: str = "#0ea5e9",
+        primary_color_dark: str = "#0284c7",
+        dark_mode_default: bool = False,
+        dashboard_permission: str | None = None,
+        settings_permission: str | None = None,
+    ):
+        self.title = title
+        self.logo_url = logo_url
+        self.favicon_url = favicon_url
+        self.primary_color = primary_color
+        self.primary_color_dark = primary_color_dark
+        self.dark_mode_default = dark_mode_default
+        self.dashboard_permission = dashboard_permission
+        self.settings_permission = settings_permission
+        self._nav_groups_built: list = []
+
+    def _init_jinja(self, app: Any) -> None:
+        """Initialise the Jinja2 template environment."""
+        import re
+        from pathlib import Path
+
+        from starlette.templating import Jinja2Templates
+
+        templates_dir = Path(__file__).parent.parent / "templates"
+        jinja_env = Jinja2Templates(directory=str(templates_dir))
+
+        def slugify(s: str) -> str:
+            return re.sub(r"[^\w]", "-", s, flags=re.A).strip("-").lower()
+
+        jinja_env.env.filters["slugify"] = slugify
+        app.state.admin_jinja_env = jinja_env
+
+    def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
+        """Thin wrapper — returns sidebar kwargs for TemplateResponse contexts."""
+        return self.build_sidebar_context(request)
+
+    def build_sidebar_context(
+        self,
+        request: Any,
+        user: Any = None,
+        permissions_map: dict | None = None,
+    ) -> dict:
+        """Build per-request sidebar context (RBAC filter + permissions map).
+
+        If *permissions_map* is provided (pre-loaded by the async caller),
+        it is used directly instead of querying the database here.
+        """
+        if user is None:
+            user = getattr(request.state, "admin_user", None)
+
+        snapshot = getattr(request.state, "admin_user_snapshot", None)
+        is_superuser = (
+            (
+                bool(snapshot.get("is_superuser", False))
+                if snapshot
+                else bool(getattr(user, "is_superuser", False))
+            )
+            if user
+            else False
+        )
+
+        from fastapi_admin_kit.types import PermissionSet
+
+        nav_groups = self._nav_groups_built
+
+        if permissions_map is None:
+            permissions_map = {}
+
+            if user and not is_superuser:
+                role_ids = (
+                    snapshot.get("role_ids", [])
+                    if snapshot
+                    else getattr(user, "role_ids", [])
+                )
+                if role_ids:
+                    try:
+                        from sqlalchemy import select
+                        from sqlalchemy.orm import Session
+
+                        from fastapi_admin_kit.auth.models import AdminPermission
+
+                        engine = request.app.state.admin_engine
+                        with Session(engine) as s:
+                            result = s.execute(
+                                select(AdminPermission).filter(
+                                    AdminPermission.role_id.in_(role_ids)
+                                )
+                            )
+                            rows = result.scalars().all()
+                            for perm in rows:
+                                if perm.table_name in permissions_map:
+                                    existing = permissions_map[perm.table_name]
+                                    permissions_map[perm.table_name] = (
+                                        PermissionSet(
+                                            can_view=existing.can_view
+                                            or perm.can_view,
+                                            can_create=existing.can_create
+                                            or perm.can_create,
+                                            can_edit=existing.can_edit
+                                            or perm.can_edit,
+                                            can_delete=existing.can_delete
+                                            or perm.can_delete,
+                                        )
+                                    )
+                                else:
+                                    permissions_map[perm.table_name] = (
+                                        PermissionSet(
+                                            can_view=perm.can_view,
+                                            can_create=perm.can_create,
+                                            can_edit=perm.can_edit,
+                                            can_delete=perm.can_delete,
+                                        )
+                                    )
+                    except Exception:
+                        pass
+
+        def _item_visible(item: Any) -> bool:
+            return (
+                item.permission_table is None
+                or is_superuser
+                or (
+                    permissions_map.get(item.permission_table)
+                    and permissions_map[item.permission_table].can_view
+                )
+            )
+
+        def _filter_items(items: list[Any]) -> list[Any]:
+            from dataclasses import replace
+
+            result = []
+            for item in items:
+                if not _item_visible(item):
+                    continue
+                filtered_children = (
+                    _filter_items(item.children) if item.children else []
+                )
+                result.append(replace(item, children=filtered_children))
+            return result
+
+        from dataclasses import replace
+
+        dashboard_visible = (
+            is_superuser
+            or self.dashboard_permission is None
+            or (
+                permissions_map.get(self.dashboard_permission)
+                and permissions_map[self.dashboard_permission].can_view
+            )
+        )
+        settings_visible = (
+            is_superuser
+            or self.settings_permission is None
+            or (
+                permissions_map.get(self.settings_permission)
+                and permissions_map[self.settings_permission].can_view
+            )
+        )
+
+        filtered_groups: list[Any] = []
+        for group in nav_groups:
+            if not (
+                group.permission_table is None
+                or is_superuser
+                or (
+                    permissions_map.get(group.permission_table)
+                    and permissions_map[group.permission_table].can_view
+                )
+            ):
+                continue
+            visible = _filter_items(group.items)
+            if visible:
+                filtered_groups.append(replace(group, items=visible))
+
+        return {
+            "nav_groups": filtered_groups,
+            "permissions_map": permissions_map,
+            "current_user": user,
+            "dashboard_visible": dashboard_visible,
+            "settings_visible": settings_visible,
+        }
+
+    def apply_sidebar_context(
+        self, request: Any, user: Any, context: dict
+    ) -> dict:
+        """Inject nav_groups + permissions_map into a template context dict."""
+        context.update(self.build_sidebar_context(request, user=user))
+        return context

fastapi_admin_kit/admin/builtin_models.py

@@ -0,0 +1,284 @@
+"""Default ModelAdmin classes for built-in admin models."""
+
+from fastapi_admin_kit.modeladmin import ModelAdmin
+from fastapi_admin_kit.types import ExtraField
+from fastapi_admin_kit.widgets.inputs import AutocompleteWidget, PasswordWidget
+from fastapi_admin_kit.widgets.relation import MultiRelationWidget
+
+
+def _get_table_names() -> list[str]:
+    from fastapi_admin_kit.registry.core import AdminRegistry
+
+    registry = AdminRegistry()
+    return sorted({m.table_name for m in registry.all()})
+
+
+class AdminUserAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "group"
+    verbose_name = "Admin User"
+    verbose_name_plural = "Admin Users"
+    list_display = ["id", "email", "full_name", "is_superuser", "is_active"]
+    search_fields = ["email", "full_name"]
+    exclude = ["hashed_password", "password_changed_at"]
+    extra_fields = [
+        ExtraField(
+            name="password",
+            label="Password",
+            required=False,
+            required_on_create=True,
+            widget=PasswordWidget(),
+        ),
+    ]
+    formfield_overrides = {
+        "roles": MultiRelationWidget(
+            related_table="admin_roles",
+            search_url="/admin/users/roles/search",
+        ),
+    }
+
+    def prepare_create_data(self, data, request=None):
+        from fastapi_admin_kit.auth.backend import pwd_context
+
+        password = data.pop("password", None)
+        if password:
+            data["hashed_password"] = pwd_context.hash(password)
+        else:
+            data["hashed_password"] = ""
+        return data
+
+    def on_create(self, obj, request=None):
+        pass
+
+    def on_update(self, obj, data, request=None):
+        pass
+
+    def after_create(self, obj, request=None):
+        if request is None:
+            return
+        perm_data = getattr(request.state, "_admin_perm_data", None)
+        if perm_data:
+            self._save_direct_permissions_after_commit(obj, perm_data, request)
+
+    def after_update(self, obj, request=None):
+        if request is None:
+            return
+        perm_data = getattr(request.state, "_admin_perm_data", None)
+        if perm_data:
+            self._save_direct_permissions_after_commit(obj, perm_data, request)
+
+    def _save_direct_permissions_after_commit(self, obj, perm_data, request):
+        import os
+        import sqlite3
+
+        db_url = os.getenv("DATABASE_URL", "")
+        if "sqlite" in db_url or not db_url:
+            db_path = db_url.split("///")[-1] if "///" in db_url else "test_debug.db"
+            conn = sqlite3.connect(db_path)
+            cursor = conn.cursor()
+
+            cursor.execute(
+                "DELETE FROM admin_user_permissions WHERE user_id = ?",
+                (obj.id,),
+            )
+
+            for table_name, perms in perm_data.items():
+                if not any(perms.get(a) for a in ["view", "create", "edit", "delete"]):
+                    continue
+                cursor.execute(
+                    """INSERT INTO admin_user_permissions
+                       (user_id, table_name, can_view, can_create, can_edit, can_delete)
+                       VALUES (?, ?, ?, ?, ?, ?)""",
+                    (
+                        obj.id,
+                        table_name,
+                        1 if perms.get("view") else 0,
+                        1 if perms.get("create") else 0,
+                        1 if perms.get("edit") else 0,
+                        1 if perms.get("delete") else 0,
+                    ),
+                )
+
+            conn.commit()
+            conn.close()
+
+    def get_form_context(self, context, obj=None, request=None):
+        from sqlalchemy import select
+
+        from fastapi_admin_kit.auth.models import AdminUserPermission
+        from fastapi_admin_kit.db import get_db_session
+
+        perm_data = {}
+        if obj is not None and request is not None:
+            try:
+                session = get_db_session(request)
+                import asyncio
+
+                async def _load_perms():
+                    result = await session.execute(
+                        select(AdminUserPermission).where(
+                            AdminUserPermission.user_id == obj.id
+                        )
+                    )
+                    return result.scalars().all()
+
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    import concurrent.futures
+                    with concurrent.futures.ThreadPoolExecutor() as pool:
+                        perms = pool.submit(asyncio.run, _load_perms()).result()
+                else:
+                    perms = loop.run_until_complete(_load_perms())
+
+                for p in perms:
+                    perm_data[p.table_name] = {
+                        "_label": p.table_name,
+                        "view": p.can_view,
+                        "create": p.can_create,
+                        "edit": p.can_edit,
+                        "delete": p.can_delete,
+                    }
+            except Exception:
+                pass
+
+        context["perm_data"] = perm_data
+        context["search_url"] = "/admin/tables/search"
+        return context
+
+    def process_form_data(self, data, request=None):
+        if request is not None:
+            import asyncio
+
+            async def _get_perm_data():
+                form = await request.form()
+                return form.get("perm_data", "{}")
+
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+
+            if loop and loop.is_running():
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    perm_data_raw = pool.submit(asyncio.run, _get_perm_data()).result()
+            elif loop:
+                perm_data_raw = loop.run_until_complete(_get_perm_data())
+            else:
+                perm_data_raw = asyncio.run(_get_perm_data())
+        else:
+            perm_data_raw = "{}"
+
+        import json
+
+        try:
+            perm_data = json.loads(perm_data_raw)
+        except (json.JSONDecodeError, TypeError):
+            perm_data = {}
+
+        if request is not None and perm_data:
+            request.state._admin_perm_data = perm_data
+
+        return data
+
+
+class AdminRoleAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "shield-check"
+    verbose_name = "Admin Role"
+    verbose_name_plural = "Admin Roles"
+    list_display = ["id", "name", "description"]
+    search_fields = ["name"]
+
+
+class AdminRefreshTokenAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "key"
+    verbose_name = "Refresh Token"
+    verbose_name_plural = "Refresh Tokens"
+    exclude = ["user"]
+
+
+class AdminPermissionAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "lock"
+    verbose_name = "Permission"
+    verbose_name_plural = "Permissions"
+    list_display = [
+        "id",
+        "role",
+        "table_name",
+        "can_view",
+        "can_create",
+        "can_edit",
+        "can_delete",
+    ]
+    formfield_overrides = {
+        "table_name": AutocompleteWidget(suggestions_fn=_get_table_names),
+    }
+
+
+class AuditLogAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "clock"
+    verbose_name = "Audit Log"
+    verbose_name_plural = "Audit Logs"
+    list_display = [
+        "id",
+        "user_email",
+        "action",
+        "model_name",
+        "object_id",
+        "timestamp",
+    ]
+    search_fields = ["user_email", "model_name"]
+    readonly_fields = [
+        "user_id",
+        "user_email",
+        "action",
+        "model_name",
+        "table_name",
+        "object_id",
+        "object_repr",
+        "changes",
+        "full_snapshot",
+        "ip_address",
+        "user_agent",
+        "timestamp",
+    ]
+
+
+class AdminUserTOTPAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "lock"
+    verbose_name = "2FA Token"
+    verbose_name_plural = "2FA Tokens"
+    list_display = ["id", "user_id", "enabled", "secret_key", "created_at"]
+
+
+class AdminUserPermissionAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "lock"
+    verbose_name = "User Permission"
+    verbose_name_plural = "User Permissions"
+    list_display = [
+        "id",
+        "user",
+        "table_name",
+        "can_view",
+        "can_create",
+        "can_edit",
+        "can_delete",
+    ]
+    formfield_overrides = {
+        "table_name": AutocompleteWidget(suggestions_fn=_get_table_names),
+    }
+
+
+class AdminLoginAttemptAdmin(ModelAdmin):
+    tag = "admin"
+    icon = "clock"
+    verbose_name = "Login Attempt"
+    verbose_name_plural = "Login Attempts"
+    list_display = ["id", "email", "ip_address", "success", "timestamp"]
+    search_fields = ["email", "ip_address"]