copilot-swe-agent[bot]
4b6412734b
- Add onupdate=sa.func.now() to migration updated_at columns - Use UserProfile.is_blocked.is_(False) instead of == False - Fix British to American spelling (organised → organized) Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com> Agent-Logs-Url: https://github.com/christianlouis/DocuElevate/sessions/3894af37-0f19-457b-8811-f1feb18b17ef
675 lines
21 KiB
Python
675 lines
21 KiB
Python
"""Document comments and annotations API endpoints.
|
||
|
||
Provides CRUD operations for threaded comments on documents,
|
||
text annotations on PDF pages, and a list of mentionable users
|
||
for the @mention feature.
|
||
"""
|
||
|
||
import json
|
||
import logging
|
||
import re
|
||
from typing import Annotated, Any
|
||
|
||
from fastapi import APIRouter, Body, Depends, HTTPException, Request, status
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.auth import get_current_user_id, require_login
|
||
from app.database import get_db
|
||
from app.models import DocumentAnnotation, DocumentComment, FileRecord, UserProfile
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
router = APIRouter(tags=["comments"])
|
||
|
||
DbSession = Annotated[Session, Depends(get_db)]
|
||
|
||
# Constraints
|
||
MAX_COMMENT_BODY_LENGTH = 10_000
|
||
MAX_ANNOTATION_CONTENT_LENGTH = 5_000
|
||
|
||
# Allowed annotation types
|
||
ALLOWED_ANNOTATION_TYPES = frozenset({"note", "highlight", "underline", "strikethrough"})
|
||
|
||
# Simple pattern for @mentions – matches @username tokens inside comment body
|
||
_MENTION_PATTERN = re.compile(r"@([\w.\-]+)")
|
||
|
||
|
||
def _extract_mentions(body: str) -> list[str]:
|
||
"""Extract unique @mentioned usernames from a comment body.
|
||
|
||
Args:
|
||
body: The raw comment text.
|
||
|
||
Returns:
|
||
A deduplicated list of mentioned usernames (without the ``@`` prefix).
|
||
"""
|
||
return list(dict.fromkeys(_MENTION_PATTERN.findall(body)))
|
||
|
||
|
||
def _serialize_comment(c: DocumentComment) -> dict[str, Any]:
|
||
"""Serialize a DocumentComment to a JSON-friendly dict.
|
||
|
||
Args:
|
||
c: The comment model instance.
|
||
|
||
Returns:
|
||
A dictionary representation of the comment.
|
||
"""
|
||
mentions: list[str] = []
|
||
if c.mentions:
|
||
try:
|
||
mentions = json.loads(c.mentions)
|
||
except (json.JSONDecodeError, TypeError):
|
||
pass
|
||
return {
|
||
"id": c.id,
|
||
"file_id": c.file_id,
|
||
"user_id": c.user_id,
|
||
"parent_id": c.parent_id,
|
||
"body": c.body,
|
||
"mentions": mentions,
|
||
"is_resolved": c.is_resolved,
|
||
"created_at": c.created_at.isoformat() if c.created_at else None,
|
||
"updated_at": c.updated_at.isoformat() if c.updated_at else None,
|
||
}
|
||
|
||
|
||
def _serialize_annotation(a: DocumentAnnotation) -> dict[str, Any]:
|
||
"""Serialize a DocumentAnnotation to a JSON-friendly dict.
|
||
|
||
Args:
|
||
a: The annotation model instance.
|
||
|
||
Returns:
|
||
A dictionary representation of the annotation.
|
||
"""
|
||
return {
|
||
"id": a.id,
|
||
"file_id": a.file_id,
|
||
"user_id": a.user_id,
|
||
"page": a.page,
|
||
"x": a.x,
|
||
"y": a.y,
|
||
"width": a.width,
|
||
"height": a.height,
|
||
"content": a.content,
|
||
"annotation_type": a.annotation_type,
|
||
"color": a.color,
|
||
"created_at": a.created_at.isoformat() if a.created_at else None,
|
||
"updated_at": a.updated_at.isoformat() if a.updated_at else None,
|
||
}
|
||
|
||
|
||
def _build_thread_tree(comments: list[DocumentComment]) -> list[dict[str, Any]]:
|
||
"""Organize a flat list of comments into a threaded tree structure.
|
||
|
||
Top-level comments (``parent_id is None``) appear as root nodes.
|
||
Replies are nested inside their parent's ``replies`` list.
|
||
|
||
Args:
|
||
comments: All comments for a given document, ordered by ``created_at``.
|
||
|
||
Returns:
|
||
A list of root-level comment dicts, each with a ``replies`` key.
|
||
"""
|
||
by_id: dict[int, dict[str, Any]] = {}
|
||
roots: list[dict[str, Any]] = []
|
||
|
||
for c in comments:
|
||
node = _serialize_comment(c)
|
||
node["replies"] = []
|
||
by_id[c.id] = node
|
||
|
||
for c in comments:
|
||
node = by_id[c.id]
|
||
if c.parent_id and c.parent_id in by_id:
|
||
by_id[c.parent_id]["replies"].append(node)
|
||
else:
|
||
roots.append(node)
|
||
|
||
return roots
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Comments endpoints
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
@router.get("/files/{file_id}/comments")
|
||
@require_login
|
||
def list_comments(request: Request, file_id: int, db: DbSession):
|
||
"""List all comments for a document, organized into threads.
|
||
|
||
Returns a threaded tree where top-level comments contain nested
|
||
``replies``.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
|
||
Returns:
|
||
A dict with ``file_id``, ``comments`` (threaded), and ``total``.
|
||
"""
|
||
file_record = db.query(FileRecord).filter(FileRecord.id == file_id).first()
|
||
if not file_record:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||
|
||
comments = (
|
||
db.query(DocumentComment).filter(DocumentComment.file_id == file_id).order_by(DocumentComment.created_at).all()
|
||
)
|
||
|
||
return {
|
||
"file_id": file_id,
|
||
"comments": _build_thread_tree(comments),
|
||
"total": len(comments),
|
||
}
|
||
|
||
|
||
@router.post("/files/{file_id}/comments", status_code=status.HTTP_201_CREATED)
|
||
@require_login
|
||
def create_comment(
|
||
request: Request,
|
||
file_id: int,
|
||
db: DbSession,
|
||
body: str = Body(..., embed=True),
|
||
parent_id: int | None = Body(None, embed=True),
|
||
):
|
||
"""Create a new comment on a document.
|
||
|
||
Automatically extracts @mentions from the comment body and stores
|
||
them for later notification or UI highlighting.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document to comment on.
|
||
|
||
Request body (JSON):
|
||
body: Comment text (required, max 10 000 characters).
|
||
parent_id: ID of the parent comment for threaded replies (optional).
|
||
|
||
Returns:
|
||
The created comment object.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
file_record = db.query(FileRecord).filter(FileRecord.id == file_id).first()
|
||
if not file_record:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||
|
||
if not isinstance(body, str) or not body.strip():
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail="body is required and must be non-empty",
|
||
)
|
||
body = body.strip()
|
||
if len(body) > MAX_COMMENT_BODY_LENGTH:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"body must be at most {MAX_COMMENT_BODY_LENGTH} characters",
|
||
)
|
||
|
||
if parent_id is not None:
|
||
parent = (
|
||
db.query(DocumentComment)
|
||
.filter(DocumentComment.id == parent_id, DocumentComment.file_id == file_id)
|
||
.first()
|
||
)
|
||
if not parent:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_404_NOT_FOUND,
|
||
detail="Parent comment not found",
|
||
)
|
||
|
||
mentions = _extract_mentions(body)
|
||
|
||
comment = DocumentComment(
|
||
file_id=file_id,
|
||
user_id=user_id,
|
||
parent_id=parent_id,
|
||
body=body,
|
||
mentions=json.dumps(mentions) if mentions else None,
|
||
)
|
||
|
||
try:
|
||
db.add(comment)
|
||
db.commit()
|
||
db.refresh(comment)
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to create comment on file_id=%s", file_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to create comment",
|
||
)
|
||
|
||
logger.info("Comment created: id=%s, file_id=%s, user=%s", comment.id, file_id, user_id)
|
||
return _serialize_comment(comment)
|
||
|
||
|
||
@router.put("/files/{file_id}/comments/{comment_id}")
|
||
@require_login
|
||
def update_comment(
|
||
request: Request,
|
||
file_id: int,
|
||
comment_id: int,
|
||
db: DbSession,
|
||
body: str = Body(..., embed=True),
|
||
):
|
||
"""Update the body of an existing comment.
|
||
|
||
Only the comment author may update the comment. Mentions are
|
||
re-extracted from the updated body.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
comment_id: The ID of the comment to update.
|
||
|
||
Request body (JSON):
|
||
body: New comment text (required).
|
||
|
||
Returns:
|
||
The updated comment object.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
comment = (
|
||
db.query(DocumentComment).filter(DocumentComment.id == comment_id, DocumentComment.file_id == file_id).first()
|
||
)
|
||
if not comment:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Comment not found")
|
||
|
||
if comment.user_id != user_id:
|
||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can only edit your own comments")
|
||
|
||
if not isinstance(body, str) or not body.strip():
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail="body is required and must be non-empty",
|
||
)
|
||
body = body.strip()
|
||
if len(body) > MAX_COMMENT_BODY_LENGTH:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"body must be at most {MAX_COMMENT_BODY_LENGTH} characters",
|
||
)
|
||
|
||
mentions = _extract_mentions(body)
|
||
comment.body = body
|
||
comment.mentions = json.dumps(mentions) if mentions else None
|
||
|
||
try:
|
||
db.commit()
|
||
db.refresh(comment)
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to update comment id=%s", comment_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to update comment",
|
||
)
|
||
|
||
logger.info("Comment updated: id=%s, user=%s", comment_id, user_id)
|
||
return _serialize_comment(comment)
|
||
|
||
|
||
@router.delete("/files/{file_id}/comments/{comment_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||
@require_login
|
||
def delete_comment(request: Request, file_id: int, comment_id: int, db: DbSession):
|
||
"""Delete a comment.
|
||
|
||
Only the comment author may delete the comment. Replies to the
|
||
deleted comment are **not** removed — they become orphaned root
|
||
comments so that conversation context is preserved.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
comment_id: The ID of the comment to delete.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
comment = (
|
||
db.query(DocumentComment).filter(DocumentComment.id == comment_id, DocumentComment.file_id == file_id).first()
|
||
)
|
||
if not comment:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Comment not found")
|
||
|
||
if comment.user_id != user_id:
|
||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can only delete your own comments")
|
||
|
||
try:
|
||
db.delete(comment)
|
||
db.commit()
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to delete comment id=%s", comment_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to delete comment",
|
||
)
|
||
|
||
logger.info("Comment deleted: id=%s, user=%s", comment_id, user_id)
|
||
|
||
|
||
@router.patch("/files/{file_id}/comments/{comment_id}/resolve")
|
||
@require_login
|
||
def resolve_comment(
|
||
request: Request,
|
||
file_id: int,
|
||
comment_id: int,
|
||
db: DbSession,
|
||
is_resolved: bool = Body(..., embed=True),
|
||
):
|
||
"""Mark a top-level comment thread as resolved or unresolved.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
comment_id: The ID of the comment to resolve / unresolve.
|
||
|
||
Request body (JSON):
|
||
is_resolved: ``true`` to resolve, ``false`` to unresolve.
|
||
|
||
Returns:
|
||
The updated comment object.
|
||
"""
|
||
comment = (
|
||
db.query(DocumentComment).filter(DocumentComment.id == comment_id, DocumentComment.file_id == file_id).first()
|
||
)
|
||
if not comment:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Comment not found")
|
||
|
||
comment.is_resolved = is_resolved
|
||
|
||
try:
|
||
db.commit()
|
||
db.refresh(comment)
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to resolve comment id=%s", comment_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to update comment",
|
||
)
|
||
|
||
logger.info("Comment %s: id=%s", "resolved" if is_resolved else "unresolved", comment_id)
|
||
return _serialize_comment(comment)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Annotations endpoints
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
@router.get("/files/{file_id}/annotations")
|
||
@require_login
|
||
def list_annotations(request: Request, file_id: int, db: DbSession):
|
||
"""List all annotations for a document.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
|
||
Returns:
|
||
A dict with ``file_id``, ``annotations``, and ``total``.
|
||
"""
|
||
file_record = db.query(FileRecord).filter(FileRecord.id == file_id).first()
|
||
if not file_record:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||
|
||
annotations = (
|
||
db.query(DocumentAnnotation)
|
||
.filter(DocumentAnnotation.file_id == file_id)
|
||
.order_by(DocumentAnnotation.page, DocumentAnnotation.created_at)
|
||
.all()
|
||
)
|
||
|
||
return {
|
||
"file_id": file_id,
|
||
"annotations": [_serialize_annotation(a) for a in annotations],
|
||
"total": len(annotations),
|
||
}
|
||
|
||
|
||
@router.post("/files/{file_id}/annotations", status_code=status.HTTP_201_CREATED)
|
||
@require_login
|
||
def create_annotation(
|
||
request: Request,
|
||
file_id: int,
|
||
db: DbSession,
|
||
page: int = Body(..., embed=True),
|
||
x: float = Body(..., embed=True),
|
||
y: float = Body(..., embed=True),
|
||
content: str = Body(..., embed=True),
|
||
width: float = Body(0, embed=True),
|
||
height: float = Body(0, embed=True),
|
||
annotation_type: str = Body("note", embed=True),
|
||
color: str | None = Body(None, embed=True),
|
||
):
|
||
"""Create a new annotation on a PDF page.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
|
||
Request body (JSON):
|
||
page: Page number (1-based, required).
|
||
x: Horizontal position on the page (required).
|
||
y: Vertical position on the page (required).
|
||
content: Annotation text (required, max 5 000 characters).
|
||
width: Width of the annotation bounding box (default 0).
|
||
height: Height of the annotation bounding box (default 0).
|
||
annotation_type: One of ``note``, ``highlight``, ``underline``,
|
||
``strikethrough`` (default ``note``).
|
||
color: Optional CSS colour string (e.g. ``#ff0000``).
|
||
|
||
Returns:
|
||
The created annotation object.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
file_record = db.query(FileRecord).filter(FileRecord.id == file_id).first()
|
||
if not file_record:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="File not found")
|
||
|
||
if not isinstance(content, str) or not content.strip():
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail="content is required and must be non-empty",
|
||
)
|
||
content = content.strip()
|
||
if len(content) > MAX_ANNOTATION_CONTENT_LENGTH:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"content must be at most {MAX_ANNOTATION_CONTENT_LENGTH} characters",
|
||
)
|
||
|
||
if page < 1:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail="page must be >= 1",
|
||
)
|
||
|
||
if annotation_type not in ALLOWED_ANNOTATION_TYPES:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"annotation_type must be one of: {', '.join(sorted(ALLOWED_ANNOTATION_TYPES))}",
|
||
)
|
||
|
||
annotation = DocumentAnnotation(
|
||
file_id=file_id,
|
||
user_id=user_id,
|
||
page=page,
|
||
x=x,
|
||
y=y,
|
||
width=width,
|
||
height=height,
|
||
content=content,
|
||
annotation_type=annotation_type,
|
||
color=color,
|
||
)
|
||
|
||
try:
|
||
db.add(annotation)
|
||
db.commit()
|
||
db.refresh(annotation)
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to create annotation on file_id=%s", file_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to create annotation",
|
||
)
|
||
|
||
logger.info("Annotation created: id=%s, file_id=%s, user=%s", annotation.id, file_id, user_id)
|
||
return _serialize_annotation(annotation)
|
||
|
||
|
||
@router.put("/files/{file_id}/annotations/{annotation_id}")
|
||
@require_login
|
||
def update_annotation(
|
||
request: Request,
|
||
file_id: int,
|
||
annotation_id: int,
|
||
db: DbSession,
|
||
content: str | None = Body(None, embed=True),
|
||
x: float | None = Body(None, embed=True),
|
||
y: float | None = Body(None, embed=True),
|
||
width: float | None = Body(None, embed=True),
|
||
height: float | None = Body(None, embed=True),
|
||
annotation_type: str | None = Body(None, embed=True),
|
||
color: str | None = Body(None, embed=True),
|
||
):
|
||
"""Update an existing annotation.
|
||
|
||
Only the annotation author may update the annotation.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
annotation_id: The ID of the annotation to update.
|
||
|
||
Request body (JSON):
|
||
Any subset of ``content``, ``x``, ``y``, ``width``, ``height``,
|
||
``annotation_type``, and ``color``.
|
||
|
||
Returns:
|
||
The updated annotation object.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
annotation = (
|
||
db.query(DocumentAnnotation)
|
||
.filter(DocumentAnnotation.id == annotation_id, DocumentAnnotation.file_id == file_id)
|
||
.first()
|
||
)
|
||
if not annotation:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Annotation not found")
|
||
|
||
if annotation.user_id != user_id:
|
||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can only edit your own annotations")
|
||
|
||
if content is not None:
|
||
content = content.strip() if isinstance(content, str) else ""
|
||
if not content:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail="content must be non-empty",
|
||
)
|
||
if len(content) > MAX_ANNOTATION_CONTENT_LENGTH:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"content must be at most {MAX_ANNOTATION_CONTENT_LENGTH} characters",
|
||
)
|
||
annotation.content = content
|
||
|
||
if x is not None:
|
||
annotation.x = x
|
||
if y is not None:
|
||
annotation.y = y
|
||
if width is not None:
|
||
annotation.width = width
|
||
if height is not None:
|
||
annotation.height = height
|
||
if annotation_type is not None:
|
||
if annotation_type not in ALLOWED_ANNOTATION_TYPES:
|
||
raise HTTPException(
|
||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||
detail=f"annotation_type must be one of: {', '.join(sorted(ALLOWED_ANNOTATION_TYPES))}",
|
||
)
|
||
annotation.annotation_type = annotation_type
|
||
if color is not None:
|
||
annotation.color = color
|
||
|
||
try:
|
||
db.commit()
|
||
db.refresh(annotation)
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to update annotation id=%s", annotation_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to update annotation",
|
||
)
|
||
|
||
logger.info("Annotation updated: id=%s, user=%s", annotation_id, user_id)
|
||
return _serialize_annotation(annotation)
|
||
|
||
|
||
@router.delete("/files/{file_id}/annotations/{annotation_id}", status_code=status.HTTP_204_NO_CONTENT)
|
||
@require_login
|
||
def delete_annotation(request: Request, file_id: int, annotation_id: int, db: DbSession):
|
||
"""Delete an annotation.
|
||
|
||
Only the annotation author may delete the annotation.
|
||
|
||
Path Parameters:
|
||
file_id: The ID of the document.
|
||
annotation_id: The ID of the annotation to delete.
|
||
"""
|
||
user_id = get_current_user_id(request)
|
||
|
||
annotation = (
|
||
db.query(DocumentAnnotation)
|
||
.filter(DocumentAnnotation.id == annotation_id, DocumentAnnotation.file_id == file_id)
|
||
.first()
|
||
)
|
||
if not annotation:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Annotation not found")
|
||
|
||
if annotation.user_id != user_id:
|
||
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You can only delete your own annotations")
|
||
|
||
try:
|
||
db.delete(annotation)
|
||
db.commit()
|
||
except Exception:
|
||
db.rollback()
|
||
logger.exception("Failed to delete annotation id=%s", annotation_id)
|
||
raise HTTPException(
|
||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||
detail="Failed to delete annotation",
|
||
)
|
||
|
||
logger.info("Annotation deleted: id=%s, user=%s", annotation_id, user_id)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Mentionable users endpoint
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
@router.get("/users/mentionable")
|
||
@require_login
|
||
def list_mentionable_users(request: Request, db: DbSession):
|
||
"""List users that can be @mentioned in comments.
|
||
|
||
Returns all user profiles that are not blocked, sorted by
|
||
``display_name``.
|
||
|
||
Returns:
|
||
A list of ``{user_id, display_name}`` objects.
|
||
"""
|
||
profiles = db.query(UserProfile).filter(UserProfile.is_blocked.is_(False)).order_by(UserProfile.display_name).all()
|
||
|
||
return [
|
||
{
|
||
"user_id": p.user_id,
|
||
"display_name": p.display_name or p.user_id,
|
||
}
|
||
for p in profiles
|
||
]
|