358 lines
11 KiB
Python
358 lines
11 KiB
Python
"""
|
|
LinkSyncServer - Link CRUD Endpoints with SQLAlchemy
|
|
"""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, status, Query, Request
|
|
from sqlalchemy.orm import Session, sessionmaker
|
|
from sqlalchemy import func, or_
|
|
from typing import List, Optional
|
|
import uuid
|
|
import logging
|
|
import hashlib
|
|
|
|
from models.base import Base, Bookmark, User, AuditLog, get_engine, create_engine
|
|
from pydantic import BaseModel, Field
|
|
import os
|
|
|
|
router = APIRouter(prefix="/api/links", tags=["Links"])
|
|
|
|
# Logging
|
|
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, description="Optional description")
|
|
notes: Optional[str] = Field(None, max_length=2000, description="Optional notes")
|
|
tags: Optional[List[str]] = Field(default_factory=list, description="List of tag names")
|
|
favicon_url: Optional[str] = Field(None, max_length=512, description="Favicon URL")
|
|
path: Optional[str] = Field(None, max_length=512, description="Folder path")
|
|
visit_count: int = Field(ge=0, description="Visit counter")
|
|
is_bookmarked: bool = Field(default=False, description="Bookmark flag")
|
|
|
|
|
|
class BookmarkUpdate(BaseModel):
|
|
url: Optional[str] = Field(None, description="New URL")
|
|
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]] = Field(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
|
|
|
|
|
|
class BookmarkResponse(BaseModel):
|
|
id: str
|
|
url: str
|
|
title: str
|
|
description: Optional[str]
|
|
notes: Optional[str]
|
|
tags: List[str]
|
|
favicon_url: Optional[str]
|
|
path: Optional[str]
|
|
created_at: str
|
|
updated_at: str
|
|
visit_count: int
|
|
is_bookmarked: bool
|
|
source_set_id: Optional[str]
|
|
user_id: Optional[str]
|
|
|
|
|
|
def get_db_session():
|
|
"""Get database session."""
|
|
try:
|
|
return sessionmaker(get_engine())()
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def get_current_user(request: Request):
|
|
"""Get current authenticated user."""
|
|
SECRET_KEY = os.environ.get("SECRET_KEY")
|
|
|
|
auth_header = request.headers.get("Authorization") or request.headers.get("authorization")
|
|
|
|
if auth_header and auth_header.startswith("Bearer "):
|
|
token = auth_header[7:]
|
|
try:
|
|
import jwt
|
|
payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
|
|
return {"username": payload.get("sub"), "id": payload.get("sub")}
|
|
except Exception:
|
|
pass
|
|
|
|
return {"username": "guest"}
|
|
|
|
|
|
@router.get("/", response_model=List[BookmarkResponse])
|
|
async def list_bookmarks(
|
|
limit: int = Query(20, le=100, ge=1, description="Number of results per page"),
|
|
offset: int = Query(0, ge=0, description="Offset for pagination"),
|
|
search: Optional[str] = Query(None, description="Search query"),
|
|
tags_filter: Optional[List[str]] = Query(None, description="Filter by tags"),
|
|
path_filter: Optional[str] = Query(None, description="Filter by folder path")
|
|
):
|
|
"""List all bookmarks with optional filters."""
|
|
db = get_db_session()
|
|
if not db:
|
|
return []
|
|
|
|
query = Bookmark.query
|
|
|
|
# Search filter
|
|
if search:
|
|
query = query.filter((Bookmark.title.contains(search)) |
|
|
(Bookmark.description.contains(search)) |
|
|
(Bookmark.url.contains(search)))
|
|
|
|
# Tag filter
|
|
if tags_filter:
|
|
or_clause = or_(*[Bookmark.tags.contains(tag) for tag in tags_filter])
|
|
query = query.filter(or_clause)
|
|
|
|
# Path filter
|
|
if path_filter:
|
|
query = query.filter(Bookmark.path.contains(path_filter))
|
|
|
|
bookmarks = query.limit(limit).offset(offset).all()
|
|
return bookmarks
|
|
|
|
|
|
@router.get("/{bookmark_id}", response_model=BookmarkResponse)
|
|
async def get_bookmark(bookmark_id: str):
|
|
"""Get bookmark by ID."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
return bookmark
|
|
|
|
|
|
@router.post("/", response_model=BookmarkResponse, status_code=status.HTTP_201_CREATED)
|
|
async def create_bookmark(data: BookmarkCreate, request: Request):
|
|
"""Create new bookmark."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
|
|
|
|
bookmark = Bookmark(
|
|
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
|
|
)
|
|
|
|
bookmark_id = f"{data.url[:20]}-{uuid.uuid4()[:8]}"
|
|
bookmark = db.add(bookmark)
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
|
|
# Get user for audit log
|
|
user = get_current_user(request)
|
|
|
|
# Create audit log (optional)
|
|
try:
|
|
audit = AuditLog(
|
|
action="create",
|
|
entity_type="Bookmark",
|
|
entity_id=bookmark_id,
|
|
old_value=None,
|
|
new_value=bookmark.dict(),
|
|
user_id=user.get("id")
|
|
)
|
|
db.add(audit)
|
|
db.commit()
|
|
except Exception:
|
|
pass
|
|
|
|
return bookmark
|
|
|
|
|
|
@router.put("/{bookmark_id}", response_model=BookmarkResponse)
|
|
async def update_bookmark(
|
|
bookmark_id: str,
|
|
data: BookmarkUpdate,
|
|
request: Request
|
|
):
|
|
"""Update bookmark."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
# Update fields
|
|
for field_name, value in data.dict().items():
|
|
if value is not None:
|
|
setattr(bookmark, field_name, value)
|
|
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
|
|
# Get user for audit log
|
|
user = get_current_user(request)
|
|
|
|
# Create audit log
|
|
try:
|
|
old_data = Bookmark(id=bookmark_id, url=bookmark.url, title=bookmark.title).dict()
|
|
audit = AuditLog(
|
|
action="update",
|
|
entity_type="Bookmark",
|
|
entity_id=bookmark_id,
|
|
old_value=old_data,
|
|
new_value=bookmark.dict(),
|
|
user_id=user.get("id")
|
|
)
|
|
db.add(audit)
|
|
db.commit()
|
|
except Exception:
|
|
pass
|
|
|
|
return bookmark
|
|
|
|
|
|
@router.delete("/{bookmark_id}", response_model=dict)
|
|
async def delete_bookmark(bookmark_id: str, request: Request):
|
|
"""Delete bookmark."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
db.delete(bookmark)
|
|
db.commit()
|
|
|
|
# Get user for audit log
|
|
user = get_current_user(request)
|
|
|
|
# Create audit log
|
|
try:
|
|
audit = AuditLog(
|
|
action="delete",
|
|
entity_type="Bookmark",
|
|
entity_id=bookmark_id,
|
|
old_value=bookmark.dict(),
|
|
new_value=None,
|
|
user_id=user.get("id")
|
|
)
|
|
db.add(audit)
|
|
db.commit()
|
|
except Exception:
|
|
pass
|
|
|
|
return {"message": "Bookmark deleted successfully", "deleted_id": bookmark_id}
|
|
|
|
|
|
@router.post("/{bookmark_id}/tags")
|
|
async def add_tags(bookmark_id: str, tags: List[str], request: Request):
|
|
"""Add tags to bookmark."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
for tag in tags:
|
|
if tag.lower() not in [t.lower() for t in bookmark.tags]:
|
|
bookmark.tags.append(tag)
|
|
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
|
|
return bookmark
|
|
|
|
|
|
@router.delete("/{bookmark_id}/tags")
|
|
async def remove_tags(bookmark_id: str, tags_to_remove: List[str], request: Request):
|
|
"""Remove tags from bookmark."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Database unavailable")
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
bookmark.tags = [t for t in bookmark.tags if t.lower() not in [tag.lower() for tag in tags_to_remove]]
|
|
|
|
db.commit()
|
|
db.refresh(bookmark)
|
|
|
|
return bookmark
|
|
|
|
|
|
@router.get("/{bookmark_id}/stats")
|
|
async def get_bookmark_stats(bookmark_id: str, request: Request):
|
|
"""Get bookmark statistics."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
return {}
|
|
|
|
bookmark = db.query(Bookmark).filter(Bookmark.id == bookmark_id).first()
|
|
|
|
if not bookmark:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bookmark not found")
|
|
|
|
# Get visit count
|
|
visits = db.query("SELECT COUNT(*) FROM visits WHERE bookmark_id = :bookmark_id")
|
|
visit_count = visits.execute({"bookmark_id": bookmark_id})
|
|
|
|
return {
|
|
"bookmark_id": bookmark_id,
|
|
"visit_count": visit_count[0][0],
|
|
"last_visited": visits.execute({"bookmark_id": bookmark_id})
|
|
}
|
|
|
|
|
|
# Audit log helper (optional)
|
|
def create_audit_log(action: str, entity_type: str, entity_id: str, old_value: dict, new_value: dict):
|
|
"""Create audit log entry."""
|
|
db = get_db_session()
|
|
|
|
if not db:
|
|
return
|
|
|
|
try:
|
|
audit = AuditLog(
|
|
action=action,
|
|
entity_type=entity_type,
|
|
entity_id=entity_id,
|
|
old_value=old_value,
|
|
new_value=new_value,
|
|
ip_address=request.client.host if hasattr(request, 'client') and hasattr(request.client, 'host') else None
|
|
)
|
|
db.add(audit)
|
|
db.commit()
|
|
except Exception:
|
|
pass |