web-page-backend/travel-proxy/app/main.py

import os
import json
import logging
from pathlib import Path
from typing import Any, List

from fastapi import FastAPI, HTTPException, Query
from fastapi.responses import FileResponse
from pydantic import BaseModel
from PIL import Image

from .db import init_db, get_photos_by_region, get_all_albums, set_album_cover, get_album_cover
from .indexer import sync

logger = logging.getLogger(__name__)

app = FastAPI()

# -----------------------------
# Env / Paths
# -----------------------------
ROOT = Path(os.getenv("TRAVEL_ROOT", "/data/travel")).resolve()
MEDIA_BASE = os.getenv("TRAVEL_MEDIA_BASE", "/media/travel")

META_DIR = ROOT / "_meta"
REGION_MAP_PATH = META_DIR / "region_map.json"
REGIONS_GEOJSON_PATH = META_DIR / "regions.geojson"

THUMB_ROOT = Path(os.getenv("TRAVEL_THUMB_ROOT", "/data/thumbs")).resolve()
THUMB_SIZE = (480, 480)

THUMB_ROOT.mkdir(parents=True, exist_ok=True)

IMAGE_EXT = {".jpg", ".jpeg", ".png", ".webp"}

# -----------------------------
# DB init
# -----------------------------
init_db()

# -----------------------------
# Helpers
# -----------------------------
def _read_json(path: Path) -> Any:
    if not path.exists():
        raise HTTPException(500, f"Missing required file: {path}")
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


def load_region_map() -> dict:
    return _read_json(REGION_MAP_PATH)


def load_regions_geojson() -> dict:
    return _read_json(REGIONS_GEOJSON_PATH)


def _get_albums_for_region(region: str, region_map: dict) -> List[str]:
    if region not in region_map:
        raise HTTPException(400, "Unknown region")
    v = region_map[region]
    if isinstance(v, list):
        return v
    if isinstance(v, dict) and isinstance(v.get("albums"), list):
        return v["albums"]
    raise HTTPException(500, "Invalid region_map format")


def _ensure_thumb_fallback(src: Path, album: str) -> Path:
    """온디맨드 썸네일 폴백 (sync 누락 분 대응)."""
    out = THUMB_ROOT / album / src.name
    if out.exists():
        return out
    out.parent.mkdir(parents=True, exist_ok=True)
    tmp = out.with_name(out.stem + ".tmp" + out.suffix)
    try:
        with Image.open(src) as im:
            im.thumbnail(THUMB_SIZE)
            ext = out.suffix.lower()
            if ext in (".jpg", ".jpeg"):
                fmt = "JPEG"
            elif ext == ".png":
                fmt = "PNG"
            elif ext == ".webp":
                fmt = "WEBP"
            else:
                fmt = (im.format or "").upper() or "JPEG"
            im.save(tmp, format=fmt, quality=85, optimize=True)
        tmp.replace(out)
        return out
    finally:
        try:
            if tmp.exists():
                tmp.unlink()
        except Exception:
            pass


# -----------------------------
# Models
# -----------------------------
class CoverRequest(BaseModel):
    filename: str


# -----------------------------
# Routes
# -----------------------------
@app.get("/health")
def health():
    return {"status": "healthy", "service": "travel-proxy"}


@app.get("/api/travel/regions")
def regions():
    return load_regions_geojson()


@app.get("/api/travel/photos")
def photos(
    region: str = Query(...),
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
):
    region_map = load_region_map()
    albums = _get_albums_for_region(region, region_map)
    result = get_photos_by_region(albums, page, size)

    # URL 조합 (DB에는 경로를 저장하지 않음)
    items = []
    for row in result["items"]:
        items.append({
            "album": row["album"],
            "file": row["filename"],
            "url": f"{MEDIA_BASE}/{row['album']}/{row['filename']}",
            "thumb": f"{MEDIA_BASE}/.thumb/{row['album']}/{row['filename']}",
            "mtime": row["mtime"],
        })

    return {
        "region": region,
        "page": page,
        "size": size,
        "total": result["total"],
        "has_next": result["has_next"],
        "items": items,
        "matched_albums": result["matched_albums"],
    }


@app.post("/api/travel/sync")
def sync_endpoint():
    result = sync(
        travel_root=ROOT,
        thumb_root=THUMB_ROOT,
        region_map_path=REGION_MAP_PATH,
    )
    return result


@app.get("/api/travel/albums")
def albums_list():
    rows = get_all_albums()
    result = []
    for r in rows:
        cover = r["cover_filename"]
        result.append({
            "album": r["album"],
            "count": r["count"],
            "cover_url": f"{MEDIA_BASE}/{r['album']}/{cover}",
            "cover_thumb": f"{MEDIA_BASE}/.thumb/{r['album']}/{cover}",
        })
    return result


@app.put("/api/travel/albums/{album}/cover")
def set_cover(album: str, body: CoverRequest):
    ok = set_album_cover(album, body.filename)
    if not ok:
        raise HTTPException(404, f"Photo not found: {album}/{body.filename}")
    return {
        "album": album,
        "filename": body.filename,
        "cover_url": f"{MEDIA_BASE}/{album}/{body.filename}",
        "cover_thumb": f"{MEDIA_BASE}/.thumb/{album}/{body.filename}",
    }


@app.get("/media/travel/.thumb/{album}/{filename}")
def get_thumb(album: str, filename: str):
    if ".." in album or ".." in filename:
        raise HTTPException(400, "Invalid path")
    src = (ROOT / album / filename).resolve()
    if not str(src).startswith(str(ROOT)):
        raise HTTPException(403, "Access denied")
    if not src.exists() or not src.is_file():
        raise HTTPException(404, "Source not found")
    p = _ensure_thumb_fallback(src, album)
    if not p.exists() or not p.is_file():
        raise HTTPException(404, "Thumbnail not found")
    return FileResponse(str(p))


@app.get("/api/version")
def version():
    return {"version": os.getenv("APP_VERSION", "dev")}