121 lines
6.6 KiB
Python
121 lines
6.6 KiB
Python
import json
|
|
|
|
from fastapi import APIRouter, Depends, Query
|
|
from sqlalchemy import text
|
|
|
|
from .db import get_db
|
|
from .layout_routes import DEFAULTS
|
|
|
|
# PUBLIC storefront API — the customer-facing shop reads its theme/layout + catalog here.
|
|
# No auth (theme + in-stock catalog aren't secret); driven by what the builder saves.
|
|
router = APIRouter(prefix="/shop", tags=["shop"])
|
|
|
|
|
|
@router.get("/config")
|
|
async def shop_config(db=Depends(get_db)):
|
|
row = (await db.execute(text("SELECT config FROM store_config WHERE store_id=1"))).first()
|
|
cfg = row[0] if row else None
|
|
if isinstance(cfg, str):
|
|
cfg = json.loads(cfg)
|
|
return cfg or DEFAULTS
|
|
|
|
|
|
@router.get("/catalog")
|
|
async def shop_catalog(q: str = Query(""), page: int = Query(1, ge=1), db=Depends(get_db)):
|
|
per = 24
|
|
where = ["i.in_stock", "i.store_id = 1"]
|
|
params = {"per": per, "off": (page - 1) * per}
|
|
if q:
|
|
where.append("(coalesce(i.title, dc.title) ILIKE :q OR dc.artist ILIKE :q)")
|
|
params["q"] = f"%{q}%"
|
|
w = " AND ".join(where)
|
|
items = [dict(r) for r in (await db.execute(text(f"""
|
|
SELECT i.sku, coalesce(i.title, dc.title) AS title, dc.artist, dc.thumb,
|
|
i.price::float AS price, i.condition, i.kind
|
|
FROM inventory i LEFT JOIN disc_cache dc ON dc.release_id = i.release_id
|
|
WHERE {w}
|
|
ORDER BY i.updated_at DESC NULLS LAST
|
|
LIMIT :per OFFSET :off"""), params)).mappings()]
|
|
cparams = {k: v for k, v in params.items() if k not in ("per", "off")}
|
|
total = (await db.execute(text(
|
|
f"SELECT count(*) FROM inventory i LEFT JOIN disc_cache dc ON dc.release_id=i.release_id WHERE {w}"
|
|
), cparams)).scalar()
|
|
return {"items": items, "page": page, "per": per, "total": total}
|
|
|
|
|
|
@router.get("/browse")
|
|
async def shop_browse(q: str = Query(""), genre: str = Query(""), style: str = Query(""),
|
|
fmt: str = Query(""), year_min: int | None = None, year_max: int | None = None,
|
|
price_min: float | None = None, price_max: float | None = None,
|
|
sort: str = Query("new"), page: int = Query(1, ge=1), db=Depends(get_db)):
|
|
"""Faceted, release-grouped catalog — the public Browse page. One row per release with its cheapest copy."""
|
|
per = 24
|
|
where = ["i.in_stock", "i.store_id = 1", "i.release_id IS NOT NULL"]
|
|
params = {"per": per, "off": (page - 1) * per}
|
|
if q:
|
|
where.append("(coalesce(i.title, dr.title) ILIKE :q OR dr.artists_sort ILIKE :q)"); params["q"] = f"%{q}%"
|
|
if genre:
|
|
where.append("EXISTS (SELECT 1 FROM disc_release_genre g WHERE g.release_id=i.release_id AND g.genre_name=:genre)"); params["genre"] = genre
|
|
if style:
|
|
where.append("EXISTS (SELECT 1 FROM disc_release_style s WHERE s.release_id=i.release_id AND s.style_name=:style)"); params["style"] = style
|
|
if fmt:
|
|
where.append("EXISTS (SELECT 1 FROM disc_release_format f WHERE f.release_id=i.release_id AND f.name ILIKE :fmt)"); params["fmt"] = f"%{fmt}%"
|
|
if year_min:
|
|
where.append("dr.year >= :ymin"); params["ymin"] = year_min
|
|
if year_max:
|
|
where.append("dr.year <= :ymax"); params["ymax"] = year_max
|
|
if price_min:
|
|
where.append("i.price >= :pmin"); params["pmin"] = price_min
|
|
if price_max:
|
|
where.append("i.price <= :pmax"); params["pmax"] = price_max
|
|
w = " AND ".join(where)
|
|
order = {"new": "max(i.updated_at) DESC NULLS LAST", "price_asc": "min(i.price) ASC",
|
|
"price_desc": "min(i.price) DESC", "year": "dr.year DESC NULLS LAST",
|
|
"artist": "dr.artists_sort", "title": "min(coalesce(i.title, dr.title))"}.get(sort, "max(i.updated_at) DESC NULLS LAST")
|
|
items = [dict(r) for r in (await db.execute(text(f"""
|
|
SELECT i.release_id, coalesce(min(i.title), dr.title) AS title, dr.artists_sort AS artist,
|
|
dr.year, dr.country, min(i.price)::float AS price, count(*) AS copies,
|
|
(SELECT string_agg(DISTINCT genre_name, ', ') FROM disc_release_genre g WHERE g.release_id=i.release_id) AS genre
|
|
FROM inventory i JOIN disc_release dr ON dr.id = i.release_id
|
|
WHERE {w}
|
|
GROUP BY i.release_id, dr.title, dr.artists_sort, dr.year, dr.country
|
|
ORDER BY {order} LIMIT :per OFFSET :off"""), params)).mappings()]
|
|
cp = {k: v for k, v in params.items() if k not in ("per", "off")}
|
|
total = (await db.execute(text(
|
|
f"SELECT count(DISTINCT i.release_id) FROM inventory i JOIN disc_release dr ON dr.id=i.release_id WHERE {w}"
|
|
), cp)).scalar()
|
|
return {"items": items, "page": page, "per": per, "total": total}
|
|
|
|
|
|
@router.get("/facets")
|
|
async def shop_facets(db=Depends(get_db)):
|
|
async def top(tbl, col):
|
|
return [dict(r) for r in (await db.execute(text(f"""
|
|
SELECT x.{col} AS name, count(DISTINCT i.release_id) AS n
|
|
FROM {tbl} x JOIN inventory i ON i.release_id = x.release_id
|
|
WHERE i.in_stock AND i.store_id=1 AND x.{col} IS NOT NULL AND x.{col} <> ''
|
|
GROUP BY x.{col} ORDER BY n DESC LIMIT 24"""))).mappings()]
|
|
return {"genres": await top("disc_release_genre", "genre_name"),
|
|
"styles": await top("disc_release_style", "style_name"),
|
|
"formats": await top("disc_release_format", "name")}
|
|
|
|
|
|
@router.get("/release/{release_id}")
|
|
async def shop_release(release_id: int, db=Depends(get_db)):
|
|
"""Public release detail — metadata + tracklist + in-stock copies (with the Woo buy link)."""
|
|
dr = (await db.execute(text("""
|
|
SELECT dr.id, dr.title, dr.artists_sort AS artist, dr.country, dr.year, dr.notes, dr.master_id,
|
|
(SELECT string_agg(label_name || coalesce(' ('||catno||')',''), ', ') FROM disc_release_label WHERE release_id=dr.id) AS label,
|
|
(SELECT string_agg(name || coalesce(' '||descriptions,''), ', ') FROM disc_release_format WHERE release_id=dr.id) AS format,
|
|
(SELECT string_agg(DISTINCT genre_name, ', ') FROM disc_release_genre WHERE release_id=dr.id) AS genre,
|
|
(SELECT string_agg(DISTINCT style_name, ', ') FROM disc_release_style WHERE release_id=dr.id) AS style
|
|
FROM disc_release dr WHERE dr.id = :r"""), {"r": release_id})).mappings().first()
|
|
tracks = [dict(r) for r in (await db.execute(text("""
|
|
SELECT position, title, duration FROM disc_release_track WHERE release_id=:r ORDER BY sequence NULLS LAST, position
|
|
"""), {"r": release_id})).mappings()]
|
|
copies = [dict(r) for r in (await db.execute(text("""
|
|
SELECT sku, price::float AS price, condition, sleeve_cond, product_url
|
|
FROM inventory WHERE release_id=:r AND in_stock AND store_id=1 ORDER BY price
|
|
"""), {"r": release_id})).mappings()]
|
|
return {"release": dict(dr) if dr else None, "tracks": tracks, "copies": copies}
|