268 lines
9.2 KiB
Python
268 lines
9.2 KiB
Python
"""Bookmarks: organized folder directory for links."""
|
|
|
|
from fastapi import APIRouter, Request, Form, Depends
|
|
from fastapi.templating import Jinja2Templates
|
|
from fastapi.responses import RedirectResponse
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import text
|
|
from typing import Optional
|
|
|
|
from core.database import get_db
|
|
from core.base_repository import BaseRepository
|
|
from core.sidebar import get_sidebar_data
|
|
|
|
router = APIRouter(prefix="/weblinks", tags=["bookmarks"])
|
|
templates = Jinja2Templates(directory="templates")
|
|
|
|
|
|
async def get_default_folder_id(db: AsyncSession) -> str:
|
|
"""Return the Default folder id, creating it if it doesn't exist."""
|
|
result = await db.execute(text(
|
|
"SELECT id FROM link_folders WHERE name = 'Default' AND is_deleted = false ORDER BY created_at LIMIT 1"
|
|
))
|
|
row = result.first()
|
|
if row:
|
|
return str(row[0])
|
|
repo = BaseRepository("link_folders", db)
|
|
folder = await repo.create({"name": "Default", "sort_order": 0})
|
|
return str(folder["id"])
|
|
|
|
|
|
@router.get("/")
|
|
async def list_bookmarks(
|
|
request: Request,
|
|
folder_id: Optional[str] = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
sidebar = await get_sidebar_data(db)
|
|
|
|
# Get all folders for tree nav
|
|
result = await db.execute(text("""
|
|
SELECT lf.*, (SELECT count(*) FROM folder_links fl WHERE fl.folder_id = lf.id) as link_count
|
|
FROM link_folders lf
|
|
WHERE lf.is_deleted = false
|
|
ORDER BY lf.sort_order, lf.name
|
|
"""))
|
|
all_folders = [dict(r._mapping) for r in result]
|
|
|
|
# Top-level folders and child folders
|
|
top_folders = [f for f in all_folders if f.get("parent_id") is None]
|
|
child_folder_map = {}
|
|
for f in all_folders:
|
|
pid = f.get("parent_id")
|
|
if pid:
|
|
child_folder_map.setdefault(str(pid), []).append(f)
|
|
|
|
# Current folder info
|
|
current_folder = None
|
|
if folder_id:
|
|
for f in all_folders:
|
|
if str(f["id"]) == folder_id:
|
|
current_folder = f
|
|
break
|
|
|
|
# Get links (filtered by folder or all unfiled)
|
|
if folder_id:
|
|
result = await db.execute(text("""
|
|
SELECT l.* FROM links l
|
|
JOIN folder_links fl ON fl.link_id = l.id
|
|
WHERE fl.folder_id = :fid AND l.is_deleted = false
|
|
ORDER BY fl.sort_order, l.label
|
|
"""), {"fid": folder_id})
|
|
else:
|
|
# Show all links
|
|
result = await db.execute(text("""
|
|
SELECT l.* FROM links l
|
|
WHERE l.is_deleted = false
|
|
ORDER BY l.sort_order, l.label
|
|
"""))
|
|
items = [dict(r._mapping) for r in result]
|
|
|
|
return templates.TemplateResponse("weblinks.html", {
|
|
"request": request, "sidebar": sidebar, "items": items,
|
|
"top_folders": top_folders, "child_folder_map": child_folder_map,
|
|
"current_folder": current_folder,
|
|
"current_folder_id": folder_id or "",
|
|
"page_title": "Bookmarks", "active_nav": "bookmarks",
|
|
})
|
|
|
|
|
|
@router.get("/create")
|
|
async def create_form(
|
|
request: Request,
|
|
folder_id: Optional[str] = None,
|
|
task_id: Optional[str] = None,
|
|
meeting_id: Optional[str] = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
sidebar = await get_sidebar_data(db)
|
|
result = await db.execute(text(
|
|
"SELECT id, name FROM link_folders WHERE is_deleted = false ORDER BY name"
|
|
))
|
|
folders = [dict(r._mapping) for r in result]
|
|
|
|
return templates.TemplateResponse("weblink_form.html", {
|
|
"request": request, "sidebar": sidebar,
|
|
"folders": folders,
|
|
"page_title": "New Link", "active_nav": "bookmarks",
|
|
"item": None,
|
|
"prefill_folder_id": folder_id or "",
|
|
"prefill_task_id": task_id or "",
|
|
"prefill_meeting_id": meeting_id or "",
|
|
})
|
|
|
|
|
|
@router.post("/create")
|
|
async def create_link(
|
|
request: Request,
|
|
label: str = Form(...),
|
|
url: str = Form(...),
|
|
description: Optional[str] = Form(None),
|
|
folder_id: Optional[str] = Form(None),
|
|
task_id: Optional[str] = Form(None),
|
|
meeting_id: Optional[str] = Form(None),
|
|
tags: Optional[str] = Form(None),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
repo = BaseRepository("links", db)
|
|
data = {"label": label, "url": url, "description": description}
|
|
if task_id and task_id.strip():
|
|
data["task_id"] = task_id
|
|
if meeting_id and meeting_id.strip():
|
|
data["meeting_id"] = meeting_id
|
|
if tags and tags.strip():
|
|
data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
|
|
|
|
link = await repo.create(data)
|
|
|
|
# Add to folder (default if none specified)
|
|
effective_folder = folder_id if folder_id and folder_id.strip() else await get_default_folder_id(db)
|
|
await db.execute(text("""
|
|
INSERT INTO folder_links (folder_id, link_id)
|
|
VALUES (:fid, :lid) ON CONFLICT DO NOTHING
|
|
"""), {"fid": effective_folder, "lid": link["id"]})
|
|
|
|
if task_id and task_id.strip():
|
|
return RedirectResponse(url=f"/tasks/{task_id}?tab=links", status_code=303)
|
|
if meeting_id and meeting_id.strip():
|
|
return RedirectResponse(url=f"/meetings/{meeting_id}?tab=links", status_code=303)
|
|
redirect_url = f"/weblinks?folder_id={folder_id}" if folder_id and folder_id.strip() else "/weblinks"
|
|
return RedirectResponse(url=redirect_url, status_code=303)
|
|
|
|
|
|
@router.get("/{link_id}/edit")
|
|
async def edit_form(link_id: str, request: Request, db: AsyncSession = Depends(get_db)):
|
|
repo = BaseRepository("links", db)
|
|
sidebar = await get_sidebar_data(db)
|
|
item = await repo.get(link_id)
|
|
if not item:
|
|
return RedirectResponse(url="/weblinks", status_code=303)
|
|
|
|
result = await db.execute(text(
|
|
"SELECT id, name FROM link_folders WHERE is_deleted = false ORDER BY name"
|
|
))
|
|
folders = [dict(r._mapping) for r in result]
|
|
|
|
# Current folder assignment
|
|
result = await db.execute(text(
|
|
"SELECT folder_id FROM folder_links WHERE link_id = :lid LIMIT 1"
|
|
), {"lid": link_id})
|
|
row = result.first()
|
|
current_folder_id = str(row[0]) if row else ""
|
|
|
|
return templates.TemplateResponse("weblink_form.html", {
|
|
"request": request, "sidebar": sidebar,
|
|
"folders": folders,
|
|
"page_title": "Edit Link", "active_nav": "bookmarks",
|
|
"item": item,
|
|
"prefill_folder_id": current_folder_id,
|
|
})
|
|
|
|
|
|
@router.post("/{link_id}/edit")
|
|
async def update_link(
|
|
link_id: str,
|
|
label: str = Form(...),
|
|
url: str = Form(...),
|
|
description: Optional[str] = Form(None),
|
|
folder_id: Optional[str] = Form(None),
|
|
tags: Optional[str] = Form(None),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
repo = BaseRepository("links", db)
|
|
data = {
|
|
"label": label, "url": url,
|
|
"description": description if description and description.strip() else None,
|
|
}
|
|
if tags and tags.strip():
|
|
data["tags"] = [t.strip() for t in tags.split(",") if t.strip()]
|
|
else:
|
|
data["tags"] = None
|
|
|
|
await repo.update(link_id, data)
|
|
|
|
# Update folder assignment
|
|
await db.execute(text("DELETE FROM folder_links WHERE link_id = :lid"), {"lid": link_id})
|
|
if folder_id and folder_id.strip():
|
|
await db.execute(text("""
|
|
INSERT INTO folder_links (folder_id, link_id)
|
|
VALUES (:fid, :lid) ON CONFLICT DO NOTHING
|
|
"""), {"fid": folder_id, "lid": link_id})
|
|
|
|
return RedirectResponse(url="/weblinks", status_code=303)
|
|
|
|
|
|
@router.post("/{link_id}/delete")
|
|
async def delete_link(link_id: str, request: Request, db: AsyncSession = Depends(get_db)):
|
|
repo = BaseRepository("links", db)
|
|
await repo.soft_delete(link_id)
|
|
referer = request.headers.get("referer", "/weblinks")
|
|
return RedirectResponse(url=referer, status_code=303)
|
|
|
|
|
|
# ---- Folders ----
|
|
|
|
@router.get("/folders/create")
|
|
async def create_folder_form(request: Request, db: AsyncSession = Depends(get_db)):
|
|
sidebar = await get_sidebar_data(db)
|
|
result = await db.execute(text(
|
|
"SELECT id, name FROM link_folders WHERE is_deleted = false ORDER BY name"
|
|
))
|
|
parent_folders = [dict(r._mapping) for r in result]
|
|
|
|
return templates.TemplateResponse("weblink_folder_form.html", {
|
|
"request": request, "sidebar": sidebar,
|
|
"parent_folders": parent_folders,
|
|
"page_title": "New Folder", "active_nav": "bookmarks",
|
|
"item": None,
|
|
})
|
|
|
|
|
|
@router.post("/folders/create")
|
|
async def create_folder(
|
|
request: Request,
|
|
name: str = Form(...),
|
|
parent_id: Optional[str] = Form(None),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
repo = BaseRepository("link_folders", db)
|
|
data = {"name": name}
|
|
if parent_id and parent_id.strip():
|
|
data["parent_id"] = parent_id
|
|
await repo.create(data)
|
|
return RedirectResponse(url="/weblinks", status_code=303)
|
|
|
|
|
|
@router.post("/folders/{folder_id}/delete")
|
|
async def delete_folder(folder_id: str, request: Request, db: AsyncSession = Depends(get_db)):
|
|
# Prevent deleting the Default folder
|
|
result = await db.execute(text(
|
|
"SELECT name FROM link_folders WHERE id = :id"
|
|
), {"id": folder_id})
|
|
row = result.first()
|
|
if row and row[0] == "Default":
|
|
return RedirectResponse(url="/weblinks", status_code=303)
|
|
repo = BaseRepository("link_folders", db)
|
|
await repo.soft_delete(folder_id)
|
|
return RedirectResponse(url="/weblinks", status_code=303)
|