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

fastapi_admin_kit/views/users.py

@@ -0,0 +1,347 @@
+"""Admin user management views — list, create, edit, delete."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi.responses import JSONResponse
+from sqlalchemy import or_, select
+
+from fastapi_admin_kit.auth.dependencies import get_current_admin_user
+from fastapi_admin_kit.auth.models import AdminRole
+from fastapi_admin_kit.auth.protocol import AdminUserProtocol
+from fastapi_admin_kit.db import get_db_session
+
+router = APIRouter()
+
+
+async def _require_superuser(
+    user: AdminUserProtocol = Depends(get_current_admin_user),
+) -> AdminUserProtocol:
+    if not getattr(user, "is_superuser", False):
+        raise HTTPException(
+            status_code=403, detail="Superuser access required."
+        )
+    return user
+
+
+@router.get("/users/roles/search")
+async def roles_search(
+    request: Request,
+    q: str = Query("", description="Search query"),
+    ids: str = Query("", description="Comma-separated role IDs to load"),
+    _: AdminUserProtocol = Depends(_require_superuser),
+):
+    """Search roles for the multi-relation picker. Supports ?q= and ?ids=."""
+    session = get_db_session(request)
+
+    if ids:
+        id_list = [
+            int(i.strip()) for i in ids.split(",") if i.strip().isdigit()
+        ]
+        result = await session.execute(
+            select(AdminRole).where(AdminRole.id.in_(id_list))
+        )
+    elif q:
+        result = await session.execute(
+            select(AdminRole)
+            .where(
+                or_(
+                    AdminRole.name.ilike(f"%{q}%"),
+                    AdminRole.description.ilike(f"%{q}%"),
+                )
+            )
+            .limit(20)
+        )
+    else:
+        result = await session.execute(
+            select(AdminRole).order_by(AdminRole.name).limit(20)
+        )
+
+    roles = result.scalars().all()
+    return JSONResponse(content=[{"id": r.id, "label": r.name} for r in roles])
+
+
+# @router.get("/users", response_class=HTMLResponse)
+# async def user_list_view(
+#     request: Request,
+#     _: AdminUserProtocol = Depends(_require_superuser),
+# ):
+#     """List admin users (superuser only)."""
+#     templates = request.app.state.admin_jinja_env
+#     session = get_db_session(request)
+
+#     result = await session.execute(
+#         select(AdminUser).options(selectinload(AdminUser.roles)).order_by(AdminUser.id)
+#     )
+#     users = list(result.scalars().all())
+
+#     return templates.TemplateResponse(
+#         request,
+#         "pages/users/list.html",
+#         await inject_sidebar_context(
+#             request,
+#             {
+#                 "users": users,
+#             },
+#         ),
+#     )
+
+
+# @router.get("/users/create", response_class=HTMLResponse)
+# async def user_create_view(
+#     request: Request,
+#     _: AdminUserProtocol = Depends(_require_superuser),
+# ):
+#     """Show user create form."""
+#     templates = request.app.state.admin_jinja_env
+#     session = get_db_session(request)
+
+#     result = await session.execute(select(AdminRole).order_by(AdminRole.name))
+#     roles = list(result.scalars().all())
+
+#     return templates.TemplateResponse(
+#         request,
+#         "pages/users/form.html",
+#         await inject_sidebar_context(
+#             request,
+#             {
+#                 "user": None,
+#                 "roles": roles,
+#             },
+#         ),
+#     )
+
+
+# @router.post("/users/create")
+# async def user_create_post(
+#     request: Request,
+#     _: AdminUserProtocol = Depends(_require_superuser),
+#     _csrf: bool = Depends(require_csrf_token),
+# ):
+#     """Handle user creation."""
+#     from fastapi_admin_kit.auth.backend import pwd_context
+#     from fastapi_admin_kit.auth.password import validate_password_strength
+
+#     session = get_db_session(request)
+#     form = await request.form()
+
+#     email = form.get("email", "").strip()
+#     password = form.get("password", "")
+#     full_name = form.get("full_name", "").strip()
+#     is_superuser = form.get("is_superuser") == "on"
+
+#     if not email:
+#         raise HTTPException(status_code=400, detail="Email is required.")
+
+#     existing = await session.execute(
+#         select(AdminUser).where(AdminUser.email == email)
+#     )
+#     if existing.scalar_one_or_none():
+#         raise HTTPException(status_code=400, detail="Email already exists.")
+
+#     password_errors = validate_password_strength(password)
+#     if password_errors:
+#         templates = request.app.state.admin_jinja_env
+#         result = await session.execute(
+#             select(AdminRole).order_by(AdminRole.name)
+#         )
+#         roles = list(result.scalars().all())
+#         return templates.TemplateResponse(
+#             request,
+#             "pages/users/form.html",
+#             await inject_sidebar_context(
+#                 request,
+#                 {
+#                     "user": None,
+#                     "roles": roles,
+#                     "error": password_errors[0],
+#                 },
+#             ),
+#         )
+
+#     user = AdminUser(
+#         email=email,
+#         hashed_password=pwd_context.hash(password),
+#         full_name=full_name,
+#         is_superuser=is_superuser,
+#     )
+#     session.add(user)
+#     await session.flush()
+
+#     # Assign selected roles (from multiRelation JSON string or multi-select)
+#     import json as _json
+
+#     raw_role_ids = form.get("role_ids", "")
+#     if isinstance(raw_role_ids, list):
+#         raw_role_ids = raw_role_ids[0] if raw_role_ids else ""
+#     if raw_role_ids:
+#         try:
+#             parsed = _json.loads(raw_role_ids)
+#             if isinstance(parsed, list):
+#                 role_id_strs = [str(v) for v in parsed]
+#             else:
+#                 role_id_strs = [str(parsed)]
+#         except (ValueError, TypeError):
+#             role_id_strs = [raw_role_ids]
+#         for rid in role_id_strs:
+#             try:
+#                 role = await session.get(AdminRole, int(rid))
+#                 if role:
+#                     user.roles.append(role)
+#             except (ValueError, TypeError):
+#                 pass
+
+#     await session.commit()
+
+#     return RedirectResponse(url="/admin/users", status_code=302)
+
+
+# @router.get("/users/{user_id}", response_class=HTMLResponse)
+# async def user_edit_view(
+#     request: Request,
+#     user_id: int,
+#     _: AdminUserProtocol = Depends(_require_superuser),
+# ):
+#     """Show user edit form."""
+#     templates = request.app.state.admin_jinja_env
+#     session = get_db_session(request)
+
+#     result = await session.execute(
+#         select(AdminUser)
+#         .options(selectinload(AdminUser.roles))
+#         .where(AdminUser.id == user_id)
+#     )
+#     user = result.scalar_one_or_none()
+#     if user is None:
+#         raise HTTPException(status_code=404, detail="User not found.")
+
+#     result = await session.execute(select(AdminRole).order_by(AdminRole.name))
+#     roles = list(result.scalars().all())
+
+#     return templates.TemplateResponse(
+#         request,
+#         "pages/users/form.html",
+#         await inject_sidebar_context(
+#             request,
+#             {
+#                 "user": user,
+#                 "roles": roles,
+#             },
+#         ),
+#     )
+
+
+# @router.post("/users/{user_id}")
+# async def user_edit_post(
+#     request: Request,
+#     user_id: int,
+#     current_user: AdminUserProtocol = Depends(_require_superuser),
+#     _csrf: bool = Depends(require_csrf_token),
+# ):
+#     """Handle user edit."""
+#     from fastapi_admin_kit.auth.backend import pwd_context
+#     from fastapi_admin_kit.auth.password import validate_password_strength
+
+#     session = get_db_session(request)
+#     user = await session.get(AdminUser, user_id)
+#     if user is None:
+#         raise HTTPException(status_code=404, detail="User not found.")
+
+#     form = await request.form()
+#     email = form.get("email", "").strip()
+#     password = form.get("password", "")
+#     full_name = form.get("full_name", "").strip()
+#     is_superuser = form.get("is_superuser") == "on"
+#     is_active = form.get("is_active") != "off"
+
+#     if email:
+#         user.email = email
+#     user.full_name = full_name
+
+#     # Prevent superuser from deactivating themselves
+#     if user.id == current_user.id and not is_active:
+#         raise HTTPException(
+#             status_code=400, detail="Cannot deactivate your own account."
+#         )
+
+#     if user.id == current_user.id and not is_superuser:
+#         raise HTTPException(
+#             status_code=400,
+#             detail="Cannot remove superuser from your own account.",
+#         )
+
+#     user.is_superuser = is_superuser
+#     user.is_active = is_active
+
+#     if password:
+#         password_errors = validate_password_strength(password)
+#         if password_errors:
+#             templates = request.app.state.admin_jinja_env
+#             result = await session.execute(
+#                 select(AdminRole).order_by(AdminRole.name)
+#             )
+#             roles = list(result.scalars().all())
+#             return templates.TemplateResponse(
+#                 request,
+#                 "pages/users/form.html",
+#                 await inject_sidebar_context(
+#                     request,
+#                     {
+#                         "user": user,
+#                         "roles": roles,
+#                         "error": password_errors[0],
+#                     },
+#                 ),
+#             )
+#         user.hashed_password = pwd_context.hash(password)
+
+#     # Update roles: clear existing, add selected
+#     import json as _json
+
+#     user.roles.clear()
+#     raw_role_ids = form.get("role_ids", "")
+#     if isinstance(raw_role_ids, list):
+#         raw_role_ids = raw_role_ids[0] if raw_role_ids else ""
+#     if raw_role_ids:
+#         try:
+#             parsed = _json.loads(raw_role_ids)
+#             if isinstance(parsed, list):
+#                 role_id_strs = [str(v) for v in parsed]
+#             else:
+#                 role_id_strs = [str(parsed)]
+#         except (ValueError, TypeError):
+#             role_id_strs = [raw_role_ids]
+#         for rid in role_id_strs:
+#             try:
+#                 role = await session.get(AdminRole, int(rid))
+#                 if role:
+#                     user.roles.append(role)
+#             except (ValueError, TypeError):
+#                 pass
+
+#     await session.commit()
+#     return RedirectResponse(url="/admin/users", status_code=302)
+
+
+# @router.post("/users/{user_id}/delete")
+# async def user_delete_post(
+#     request: Request,
+#     user_id: int,
+#     current_user: AdminUserProtocol = Depends(_require_superuser),
+#     _csrf: bool = Depends(require_csrf_token),
+# ):
+#     """Soft-delete user (set is_active=False)."""
+#     session = get_db_session(request)
+#     user = await session.get(AdminUser, user_id)
+#     if user is None:
+#         raise HTTPException(status_code=404, detail="User not found.")
+
+#     if user.id == current_user.id:
+#         raise HTTPException(
+#             status_code=400, detail="Cannot deactivate your own account."
+#         )
+
+#     user.is_active = False
+#     await session.commit()
+
+#     return RedirectResponse(url="/admin/users", status_code=302)

fastapi_admin_kit/views.py

@@ -0,0 +1,117 @@
+"""Route handler factories — list, form, delete, roles, dashboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+
+from fastapi_admin_kit.admin.decorators import column
+
+if TYPE_CHECKING:
+    from fastapi_admin_kit.registry import RegisteredModel
+
+
+class ModelAdmin:
+    """Base class for model admin configuration."""
+
+    # List view config
+    list_display: list[str] | None = None
+    list_filter: list[str] | None = None
+    search_fields: list[str] | None = None
+    ordering: list[str] | None = None
+    per_page: int = 20
+
+    # Form config
+    fields: list[str] | None = None
+    exclude: list[str] | None = None
+    readonly_fields: list[str] | None = None
+
+    # Labels and display
+    verbose_name: str | None = None
+    verbose_name_plural: str | None = None
+    icon: str | None = None
+
+    # Custom display functions (dict-based fallback)
+    display_functions: dict[str, Any] | None = None
+
+    # Decorator for custom column display
+    column = staticmethod(column)
+
+    def __str__(self, obj: Any) -> str:
+        """How to display an object in dropdowns/links."""
+        return str(getattr(obj, "name", None) or getattr(obj, "title", None) or f"#{obj.id}")
+
+
+def create_list_view(registered: RegisteredModel) -> Any:
+    """Create a list view handler for a model."""
+
+    async def list_view(request: Request) -> HTMLResponse:
+        # Placeholder — will render list template
+        return HTMLResponse(
+            f"<h1>{registered.verbose_name_plural}</h1><p>List view coming soon.</p>"
+        )
+
+    return list_view
+
+
+def create_create_view(registered: RegisteredModel) -> Any:
+    """Create a create view handler for a model."""
+
+    async def create_view(request: Request) -> HTMLResponse:
+        # Placeholder — will render form template
+        return HTMLResponse(
+            f"<h1>Create {registered.verbose_name}</h1><p>Form coming soon.</p>"
+        )
+
+    return create_view
+
+
+def create_edit_view(registered: RegisteredModel) -> Any:
+    """Create an edit view handler for a model."""
+
+    async def edit_view(request: Request, item_id: str) -> HTMLResponse:
+        # Placeholder — will render form template
+        return HTMLResponse(
+            f"<h1>Edit {registered.verbose_name}</h1><p>Form for {item_id} coming soon.</p>"
+        )
+
+    return edit_view
+
+
+def create_delete_view(registered: RegisteredModel) -> Any:
+    """Create a delete view handler for a model."""
+
+    async def delete_view(request: Request, item_id: str) -> HTMLResponse:
+        # Placeholder — will handle deletion
+        return HTMLResponse(
+            f"<h1>Delete {registered.verbose_name}</h1><p>Delete {item_id} coming soon.</p>"
+        )
+
+    return delete_view
+
+
+def create_model_router(registered: RegisteredModel) -> APIRouter:
+    """Create all CRUD routes for a registered model."""
+    router = APIRouter(
+        prefix=f"/{registered.table_name}", tags=[registered.verbose_name]
+    )
+
+    router.add_api_route(
+        "/", create_list_view(registered), methods=["GET"], name="list"
+    )
+    router.add_api_route(
+        "/create", create_create_view(registered),
+        methods=["GET", "POST"], name="create",
+    )
+    router.add_api_route(
+        "/{item_id}", create_edit_view(registered),
+        methods=["GET", "POST"], name="edit",
+    )
+    router.add_api_route(
+        "/{item_id}/delete", create_delete_view(registered),
+        methods=["POST"], name="delete",
+    )
+
+    return router

fastapi_admin_kit/widgets/__init__.py

@@ -0,0 +1,44 @@
+"""Widgets module — base class, all built-in widgets, WidgetRegistry, WidgetResolver."""
+
+from __future__ import annotations
+
+from fastapi_admin_kit.widgets.base import Widget
+from fastapi_admin_kit.widgets.inputs import (
+    DatePickerWidget,
+    DateTimePickerWidget,
+    FileUploadWidget,
+    HiddenWidget,
+    ImageUploadWidget,
+    JsonEditorWidget,
+    NumberInputWidget,
+    PasswordWidget,
+    ReadOnlyWidget,
+    SelectWidget,
+    TextareaWidget,
+    TextInputWidget,
+    ToggleWidget,
+)
+from fastapi_admin_kit.widgets.registry import WidgetRegistry
+from fastapi_admin_kit.widgets.relation import MultiRelationWidget, RelationPickerWidget
+from fastapi_admin_kit.widgets.resolver import WidgetResolver
+
+__all__ = [
+    "Widget",
+    "WidgetRegistry",
+    "WidgetResolver",
+    "TextInputWidget",
+    "TextareaWidget",
+    "NumberInputWidget",
+    "ToggleWidget",
+    "DatePickerWidget",
+    "DateTimePickerWidget",
+    "SelectWidget",
+    "JsonEditorWidget",
+    "PasswordWidget",
+    "ReadOnlyWidget",
+    "HiddenWidget",
+    "FileUploadWidget",
+    "ImageUploadWidget",
+    "RelationPickerWidget",
+    "MultiRelationWidget",
+]

fastapi_admin_kit/widgets/base.py

@@ -0,0 +1,44 @@
+"""Widget base class — two-layer: Python class (parse + validate) + Jinja2 macro (HTML)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi_admin_kit.types import FieldMeta
+
+
+class Widget:
+    """Base widget class.
+
+    Stateless: receives FieldMeta + value at render/validate time.
+    Override ``parse`` to transform raw form data.
+    Override ``validate`` to add custom validation.
+    Override ``render_context`` to customise template variables.
+    """
+
+    macro_name: str = "text_input"
+
+    def render_context(self, field: FieldMeta, value: Any) -> dict:
+        """Variables injected into the Jinja2 macro."""
+        return {
+            "field": field,
+            "value": value if value is not None else "",
+            "id": f"field-{field.name}",
+            "name": field.name,
+        }
+
+    def parse(self, raw: str | list | None) -> Any:
+        """Convert raw FormData string to typed Python value."""
+        if raw is None or raw == "":
+            return None
+        return raw
+
+    def validate(self, value: Any, field: FieldMeta) -> list[str]:
+        """Return a list of error messages. Empty list means valid."""
+        errors: list[str] = []
+        if field.required and (value is None or value == ""):
+            errors.append(f"{field.label} is required.")
+        return errors
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} macro={self.macro_name!r}>"