fe4cbc3537
- Web UI: login, dashboard, links CRUD, collections, API keys, admin pages - Query engine: AND/OR/XOR with field filters, tag search, preview endpoint - Session management: token expiry detection, 401 interceptor, expiry banner - Links search: tags included, multi-word AND, query mode with set operations - Collections: static/dynamic, query builder with preview, public tree view - Save as Collection: convert search results (static) or query (dynamic) - Dashboard stats: resilient loading with allSettled pattern - Login page: redesigned with public collections tree view - Bug fix: query executor None fields crash (notes/description/url/title) - E2E tests: 20 Playwright tests covering all critical user flows - All 104 tests passing (84 unit/integration + 20 E2E)
272 lines
9.6 KiB
Python
272 lines
9.6 KiB
Python
"""
|
|
LinkSyncServer - Link CRUD Endpoints
|
|
"""
|
|
|
|
import logging
|
|
import uuid
|
|
from typing import List, Optional
|
|
|
|
from fastapi import APIRouter, HTTPException, Query, Request, status
|
|
from pydantic import BaseModel, Field
|
|
from sqlalchemy import or_, func
|
|
|
|
from config.settings import settings
|
|
from models.base import AuditLog, Bookmark, User, get_session
|
|
|
|
router = APIRouter(prefix="/api/links", tags=["Links"])
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class BookmarkCreate(BaseModel):
|
|
url: str = Field(..., description="Bookmark URL")
|
|
title: str = Field(..., min_length=1, max_length=255, description="Bookmark title")
|
|
description: Optional[str] = Field(None, max_length=500)
|
|
notes: Optional[str] = Field(None, max_length=2000)
|
|
tags: Optional[List[str]] = Field(default_factory=list)
|
|
favicon_url: Optional[str] = Field(None, max_length=512)
|
|
path: Optional[str] = Field(None, max_length=512)
|
|
visit_count: int = Field(0, ge=0)
|
|
is_bookmarked: bool = Field(default=False)
|
|
|
|
|
|
class BookmarkUpdate(BaseModel):
|
|
url: Optional[str] = None
|
|
title: Optional[str] = Field(None, min_length=1, max_length=255)
|
|
description: Optional[str] = Field(None, max_length=500)
|
|
notes: Optional[str] = Field(None, max_length=2000)
|
|
tags: Optional[List[str]] = None
|
|
favicon_url: Optional[str] = Field(None, max_length=512)
|
|
path: Optional[str] = Field(None, max_length=512)
|
|
visit_count: Optional[int] = Field(None, ge=0)
|
|
is_bookmarked: Optional[bool] = None
|
|
|
|
|
|
def get_current_user_id(request: Request) -> Optional[str]:
|
|
auth_header = request.headers.get("Authorization", "")
|
|
if auth_header.startswith("Bearer "):
|
|
token = auth_header[7:]
|
|
try:
|
|
import jwt
|
|
payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
|
|
return payload.get("sub")
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def parse_uuid(id_str: str):
|
|
try:
|
|
return uuid.UUID(id_str) if isinstance(id_str, str) else id_str
|
|
except (ValueError, AttributeError):
|
|
return None
|
|
|
|
|
|
def log_audit(db, action: str, entity_type: str, entity_id: str, user_id: Optional[str], old_value=None, new_value=None):
|
|
try:
|
|
audit = AuditLog(
|
|
action=action,
|
|
entity_type=entity_type,
|
|
entity_id=entity_id,
|
|
old_value=old_value,
|
|
new_value=new_value,
|
|
user_id=user_id,
|
|
)
|
|
db.add(audit)
|
|
db.commit()
|
|
except Exception:
|
|
db.rollback()
|
|
|
|
|
|
@router.get("/", response_model=List[dict])
|
|
async def list_bookmarks(
|
|
limit: int = Query(20, le=100, ge=1),
|
|
offset: int = Query(0, ge=0),
|
|
search: Optional[str] = Query(None),
|
|
tags_filter: Optional[List[str]] = Query(None),
|
|
path_filter: Optional[str] = Query(None),
|
|
):
|
|
db = get_session()
|
|
try:
|
|
query = db.query(Bookmark)
|
|
if search:
|
|
from sqlalchemy.sql import text
|
|
from models.base import get_engine
|
|
engine = get_engine()
|
|
dialect = engine.dialect.name
|
|
terms = [t.strip() for t in search.split() if t.strip()]
|
|
|
|
for term in terms:
|
|
term_lower = term.lower()
|
|
if dialect == "postgresql":
|
|
tag_match = text(
|
|
"EXISTS (SELECT 1 FROM jsonb_array_elements_text(links.tags) AS t WHERE lower(t) LIKE :search_tag)"
|
|
).bindparams(search_tag=f"%{term_lower}%")
|
|
else:
|
|
tag_match = text(
|
|
"EXISTS (SELECT 1 FROM json_each(links.tags) WHERE lower(value) LIKE :search_tag)"
|
|
).bindparams(search_tag=f"%{term_lower}%")
|
|
|
|
term_filter = or_(
|
|
Bookmark.title.ilike(f"%{term}%"),
|
|
Bookmark.description.ilike(f"%{term}%"),
|
|
Bookmark.url.ilike(f"%{term}%"),
|
|
Bookmark.notes.ilike(f"%{term}%"),
|
|
tag_match,
|
|
)
|
|
query = query.filter(term_filter)
|
|
if tags_filter:
|
|
for tag in tags_filter:
|
|
query = query.filter(Bookmark.tags.contains(tag))
|
|
if path_filter:
|
|
query = query.filter(Bookmark.path.ilike(f"%{path_filter}%"))
|
|
bookmarks = query.order_by(Bookmark.created_at.desc()).offset(offset).limit(limit).all()
|
|
return [b.to_dict() for b in bookmarks]
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.get("/{bookmark_id}", response_model=dict)
|
|
async def get_bookmark(bookmark_id: str):
|
|
db = get_session()
|
|
try:
|
|
parsed_id = parse_uuid(bookmark_id)
|
|
if parsed_id is None:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == parsed_id).first()
|
|
if not bookmark:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
return bookmark.to_dict()
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.post("/", response_model=dict, status_code=status.HTTP_201_CREATED)
|
|
async def create_bookmark(data: BookmarkCreate, request: Request):
|
|
db = get_session()
|
|
try:
|
|
user_id = None
|
|
username = get_current_user_id(request)
|
|
if username:
|
|
user = db.query(User).filter(User.username == username).first()
|
|
if user:
|
|
user_id = user.id
|
|
bookmark = Bookmark(
|
|
id=uuid.uuid4(),
|
|
url=data.url,
|
|
title=data.title,
|
|
description=data.description,
|
|
notes=data.notes,
|
|
tags=data.tags or [],
|
|
favicon_url=data.favicon_url,
|
|
path=data.path,
|
|
visit_count=data.visit_count,
|
|
is_bookmarked=data.is_bookmarked,
|
|
user_id=user_id,
|
|
)
|
|
db.add(bookmark)
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
log_audit(db, "create", "Bookmark", bookmark.id, user_id, new_value=bookmark.to_dict())
|
|
return bookmark.to_dict()
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.put("/{bookmark_id}", response_model=dict)
|
|
async def update_bookmark(bookmark_id: str, data: BookmarkUpdate, request: Request):
|
|
db = get_session()
|
|
try:
|
|
parsed_id = parse_uuid(bookmark_id)
|
|
if parsed_id is None:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == parsed_id).first()
|
|
if not bookmark:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
|
|
old_value = bookmark.to_dict()
|
|
update_data = data.model_dump(exclude_unset=True)
|
|
for field, value in update_data.items():
|
|
setattr(bookmark, field, value)
|
|
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
username = get_current_user_id(request)
|
|
user = db.query(User).filter(User.username == username).first() if username else None
|
|
log_audit(db, "update", "Bookmark", bookmark.id, user.id if user else None, old_value=old_value, new_value=bookmark.to_dict())
|
|
return bookmark.to_dict()
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.delete("/{bookmark_id}", response_model=dict)
|
|
async def delete_bookmark(bookmark_id: str, request: Request):
|
|
db = get_session()
|
|
try:
|
|
parsed_id = parse_uuid(bookmark_id)
|
|
if parsed_id is None:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == parsed_id).first()
|
|
if not bookmark:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
|
|
old_value = bookmark.to_dict()
|
|
db.delete(bookmark)
|
|
db.commit()
|
|
username = get_current_user_id(request)
|
|
user = db.query(User).filter(User.username == username).first() if username else None
|
|
log_audit(db, "delete", "Bookmark", bookmark.id, user.id if user else None, old_value=old_value)
|
|
return {"message": "Bookmark deleted successfully", "deleted_id": str(bookmark.id)}
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
class TagList(BaseModel):
|
|
tags: List[str]
|
|
|
|
|
|
@router.post("/{bookmark_id}/tags", response_model=dict)
|
|
async def add_tags(bookmark_id: str, data: TagList, request: Request):
|
|
db = get_session()
|
|
try:
|
|
parsed_id = parse_uuid(bookmark_id)
|
|
if parsed_id is None:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == parsed_id).first()
|
|
if not bookmark:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
|
|
current_tags = list(bookmark.tags or [])
|
|
current_lower = [t.lower() for t in current_tags]
|
|
for tag in data.tags:
|
|
if tag.lower() not in current_lower:
|
|
current_tags.append(tag)
|
|
current_lower.append(tag.lower())
|
|
bookmark.tags = current_tags
|
|
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
return bookmark.to_dict()
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
@router.delete("/{bookmark_id}/tags", response_model=dict)
|
|
async def remove_tags(bookmark_id: str, data: TagList, request: Request):
|
|
db = get_session()
|
|
try:
|
|
parsed_id = parse_uuid(bookmark_id)
|
|
if parsed_id is None:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == parsed_id).first()
|
|
if not bookmark:
|
|
raise HTTPException(status_code=404, detail="Bookmark not found")
|
|
|
|
remove_lower = [t.lower() for t in data.tags]
|
|
bookmark.tags = [t for t in (bookmark.tags or []) if t.lower() not in remove_lower]
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
return bookmark.to_dict()
|
|
finally:
|
|
db.close()
|