e20be06bf0
/nav/insert: drop one record (release id/sku/barcode) into a crate at a chosen slot, shifting items at>=slot down by one. Scanner: click a contents row to set the insert anchor (before/after toggle) — drives both the bulk 'Insert at picked slot' mode and a new Quick Insert one-record panel. Picked row highlighted; anchor is per-crate. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
365 lines
18 KiB
Python
365 lines
18 KiB
Python
from fastapi import APIRouter, Depends, HTTPException
|
|
from pydantic import BaseModel
|
|
from sqlalchemy import text
|
|
|
|
from .auth import require_token
|
|
from .db import get_db
|
|
|
|
# Store Navigator — the WowPlatter "Search & Inventory Management" drill-down, RecordGod-side.
|
|
# Store → Rack → Crate → Item, over the migrated virtual_* geometry. See RECORDGOD_NAVIGATOR_PLAN.md.
|
|
# Dims are METRES here (the 3D-store convention the data was migrated into), not WowPlatter's old cm.
|
|
router = APIRouter(prefix="/nav", tags=["navigator"])
|
|
|
|
|
|
@router.get("/spaces")
|
|
async def spaces(ident=Depends(require_token), db=Depends(get_db)):
|
|
rows = await db.execute(text("""
|
|
SELECT id, name, room_width::float AS room_width, room_depth::float AS room_depth,
|
|
(is_default = 'y') AS is_default
|
|
FROM virtual_space WHERE visible = 'y'
|
|
ORDER BY (is_default = 'y') DESC, id
|
|
"""))
|
|
return {"spaces": [dict(r) for r in rows.mappings()]}
|
|
|
|
|
|
@router.get("/store-layout")
|
|
async def store_layout(space_id: int | None = None, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""All racks (position + facing + type dims + counts) for one space — the top-down store view."""
|
|
if space_id is None:
|
|
sp = (await db.execute(text(
|
|
"SELECT id FROM virtual_space WHERE visible='y' ORDER BY (is_default='y') DESC, id LIMIT 1"
|
|
))).first()
|
|
space_id = sp[0] if sp else None
|
|
space = (await db.execute(text("""
|
|
SELECT id, name, room_width::float AS room_width, room_depth::float AS room_depth
|
|
FROM virtual_space WHERE id = :s
|
|
"""), {"s": space_id})).mappings().first()
|
|
racks = [dict(r) for r in (await db.execute(text("""
|
|
SELECT r.id, r.name, r.pos_x::float AS x, r.pos_z::float AS z,
|
|
r.rotation_y::float AS rot, r.direction,
|
|
rt.type AS rack_type, rt.name AS type_name,
|
|
rt.width::float AS w, rt.depth::float AS d, coalesce(rt.levels,1)::int AS levels,
|
|
(SELECT count(*) FROM virtual_crate c WHERE c.rack_id = r.id AND c.visible = 'y') AS crates,
|
|
(SELECT count(*) FROM inventory i
|
|
WHERE i.crate_id IN (SELECT id FROM virtual_crate c WHERE c.rack_id = r.id)
|
|
AND i.in_stock) AS items
|
|
FROM virtual_rack r LEFT JOIN virtual_rack_type rt ON rt.id = r.rack_type_id
|
|
WHERE r.visible = 'y' AND r.space_id = :s
|
|
AND coalesce(rt.rack_purpose, 'stock') <> 'prop' -- functional racks only; props = 3D scenery
|
|
"""), {"s": space_id})).mappings()]
|
|
return {"ok": True, "space": dict(space) if space else None, "racks": racks}
|
|
|
|
|
|
@router.get("/rack/{rack_id}")
|
|
async def rack_detail(rack_id: int, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""One rack: its type dims/levels + every crate (level, slot, facing, label, item count)."""
|
|
rack = (await db.execute(text("""
|
|
SELECT r.id, r.name, r.direction, r.pos_x::float AS x, r.pos_z::float AS z,
|
|
r.rotation_y::float AS rot, r.space_id,
|
|
rt.type AS rack_type, rt.name AS type_name,
|
|
rt.width::float AS w, rt.depth::float AS d,
|
|
coalesce(rt.levels,1)::int AS levels, coalesce(rt.slots_per_level,0)::int AS slots_per_level
|
|
FROM virtual_rack r LEFT JOIN virtual_rack_type rt ON rt.id = r.rack_type_id
|
|
WHERE r.id = :id
|
|
"""), {"id": rack_id})).mappings().first()
|
|
if not rack:
|
|
raise HTTPException(404, "rack not found")
|
|
crates = [dict(r) for r in (await db.execute(text("""
|
|
SELECT c.id, c.name, c.label_text, c.rack_level_index::int AS level, c.slot_number::int AS slot,
|
|
c.direction, c.pos_x::float AS x, c.pos_z::float AS z, c.crate_purpose,
|
|
ct.name AS crate_type, ct.material_color AS color,
|
|
(SELECT count(*) FROM inventory i WHERE i.crate_id = c.id AND i.in_stock) AS items
|
|
FROM virtual_crate c LEFT JOIN virtual_crate_type ct ON ct.id = c.crate_type_id
|
|
WHERE c.rack_id = :id AND c.visible = 'y'
|
|
ORDER BY c.rack_level_index NULLS FIRST, c.slot_number NULLS LAST
|
|
"""), {"id": rack_id})).mappings()]
|
|
levels = [dict(r) for r in (await db.execute(text("""
|
|
SELECT l.level_index::int AS level, coalesce(l.slots,0)::int AS slots
|
|
FROM virtual_rack_type_level l
|
|
JOIN virtual_rack r ON r.rack_type_id = l.rack_type_id
|
|
WHERE r.id = :id ORDER BY l.level_index
|
|
"""), {"id": rack_id})).mappings()]
|
|
return {"ok": True, "rack": dict(rack), "crates": crates, "levels": levels}
|
|
|
|
|
|
class RackEditIn(BaseModel):
|
|
name: str | None = None
|
|
pos_x: float | None = None # move the rack on the store map (metres)
|
|
pos_z: float | None = None
|
|
direction: str | None = None # forward | back | left | right
|
|
rotation_y: float | None = None # fine rotation (degrees)
|
|
|
|
|
|
@router.post("/rack/{rack_id}")
|
|
async def rack_edit(rack_id: int, body: RackEditIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
fields = {k: v for k, v in body.model_dump().items() if v is not None}
|
|
if not fields:
|
|
return {"ok": True, "unchanged": True}
|
|
sets = ", ".join(f"{k} = :{k}" for k in fields) + ", updated_at = now()"
|
|
r = await db.execute(text(f"UPDATE virtual_rack SET {sets} WHERE id = :i"), {**fields, "i": rack_id})
|
|
await db.commit()
|
|
if not r.rowcount:
|
|
raise HTTPException(404, "rack not found")
|
|
return {"ok": True}
|
|
|
|
|
|
@router.get("/crate/{crate_id}")
|
|
async def crate_contents(crate_id: int, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""A crate's records, in slot order — the Crate Contents list."""
|
|
crate = (await db.execute(text("""
|
|
SELECT c.id, c.name, c.label_text, c.rack_id, c.rack_level_index::int AS level,
|
|
c.slot_number::int AS slot, c.direction, c.crate_purpose,
|
|
c.updated_at AS last_scanned, c.updated_by, r.name AS rack_name, rt.type AS rack_type,
|
|
(SELECT count(*) FROM inventory i WHERE i.crate_id = c.id AND i.in_stock) AS items_count
|
|
FROM virtual_crate c LEFT JOIN virtual_rack r ON r.id = c.rack_id
|
|
LEFT JOIN virtual_rack_type rt ON rt.id = r.rack_type_id
|
|
WHERE c.id = :id
|
|
"""), {"id": crate_id})).mappings().first()
|
|
if not crate:
|
|
raise HTTPException(404, "crate not found")
|
|
items = [dict(r) for r in (await db.execute(text("""
|
|
SELECT i.sku, i.release_id, i.slot_number::int AS slot, coalesce(i.title, dc.title) AS title,
|
|
dc.artist, i.price::float AS price, i.condition, i.in_stock,
|
|
(SELECT string_agg(DISTINCT g.genre_name, ', ') FROM disc_release_genre g WHERE g.release_id = i.release_id) AS genre,
|
|
(SELECT string_agg(DISTINCT s.style_name, ', ') FROM disc_release_style s WHERE s.release_id = i.release_id) AS style
|
|
FROM inventory i LEFT JOIN disc_cache dc ON dc.release_id = i.release_id
|
|
WHERE i.crate_id = :id
|
|
ORDER BY i.slot_number NULLS LAST, i.sku
|
|
"""), {"id": crate_id})).mappings()]
|
|
return {"ok": True, "crate": dict(crate), "items": items}
|
|
|
|
|
|
@router.get("/release/{release_id}")
|
|
async def release_info(release_id: int, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""Full release metadata (from the disc_release mirror) + every inventory copy + where each lives."""
|
|
dr = (await db.execute(text("""
|
|
SELECT dr.id, dr.title, dr.artists_sort AS artist, dr.country, dr.year, dr.thumb, 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,
|
|
(SELECT value FROM disc_release_identifier WHERE release_id=dr.id AND type ILIKE 'barcode' LIMIT 1) AS barcode
|
|
FROM disc_release dr WHERE dr.id = :r
|
|
"""), {"r": release_id})).mappings().first()
|
|
items = [dict(r) for r in (await db.execute(text("""
|
|
SELECT i.sku, i.price::float AS price, i.condition, i.sleeve_cond, i.in_stock,
|
|
i.crate_id, i.slot_number::int AS slot, c.label_text AS crate, r.name AS rack,
|
|
c.rack_level_index::int AS level
|
|
FROM inventory i LEFT JOIN virtual_crate c ON c.id = i.crate_id
|
|
LEFT JOIN virtual_rack r ON r.id = c.rack_id
|
|
WHERE i.release_id = :r ORDER BY i.in_stock DESC, i.sku
|
|
"""), {"r": release_id})).mappings()]
|
|
return {"ok": True, "release": dict(dr) if dr else None, "items": items}
|
|
|
|
|
|
# ── Scanner — assign scanned items to a crate's slots (Replace / Append / Prepend / Insert) ────
|
|
class CrateEditIn(BaseModel):
|
|
name: str | None = None
|
|
label_text: str | None = None
|
|
crate_purpose: str | None = None
|
|
direction: str | None = None # forward | back | left | right — the crate's facing (rotate)
|
|
|
|
|
|
@router.post("/crate/{crate_id}")
|
|
async def crate_edit(crate_id: int, body: CrateEditIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
fields = {k: v for k, v in body.model_dump().items() if v is not None}
|
|
if not fields:
|
|
return {"ok": True, "unchanged": True}
|
|
sets = ", ".join(f"{k} = :{k}" for k in fields) + ", updated_at = now()"
|
|
r = await db.execute(text(f"UPDATE virtual_crate SET {sets} WHERE id = :i"), {**fields, "i": crate_id})
|
|
await db.commit()
|
|
if not r.rowcount:
|
|
raise HTTPException(404, "crate not found")
|
|
return {"ok": True}
|
|
|
|
|
|
class ScanAssignIn(BaseModel):
|
|
crate_id: int
|
|
lines: list[str]
|
|
mode: str = "replace" # replace | append | prepend | insert
|
|
insert_at: int | None = None
|
|
dry_run: bool = False
|
|
|
|
|
|
async def _resolve_sku(db, ln):
|
|
"""A scanned line → the inventory SKU it refers to (exact sku, else release_id, else barcode)."""
|
|
ln = ln.strip()
|
|
if not ln:
|
|
return None
|
|
r = (await db.execute(text("SELECT sku FROM inventory WHERE sku = :v LIMIT 1"), {"v": ln})).first()
|
|
if r:
|
|
return r[0]
|
|
if ln.isdigit():
|
|
r = (await db.execute(text("SELECT sku FROM inventory WHERE release_id = :v AND in_stock "
|
|
"ORDER BY (crate_id IS NULL) DESC, sku LIMIT 1"), {"v": int(ln)})).first()
|
|
if r:
|
|
return r[0]
|
|
r = (await db.execute(text("""SELECT i.sku FROM disc_release_identifier di JOIN inventory i ON i.release_id = di.release_id
|
|
WHERE di.value = :v AND i.in_stock ORDER BY (i.crate_id IS NULL) DESC, i.sku LIMIT 1"""), {"v": ln})).first()
|
|
return r[0] if r else None
|
|
|
|
|
|
class InsertOneIn(BaseModel):
|
|
item: str # release id / sku / barcode → resolved to one inventory sku
|
|
crate_id: int
|
|
slot: int # insert AT this slot; existing items at >= slot shift down by one
|
|
|
|
|
|
@router.post("/insert")
|
|
async def insert_one(body: InsertOneIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""Drop a single record into a crate at a chosen slot, shifting the rest down (the Quick Insert)."""
|
|
sku = await _resolve_sku(db, body.item.strip())
|
|
if not sku:
|
|
raise HTTPException(404, "no record found for that ID / SKU / barcode")
|
|
slot = max(1, body.slot)
|
|
# detach the record first so it isn't caught by the shift (handles re-filing within the same crate)
|
|
await db.execute(text("UPDATE inventory SET crate_id=NULL, slot_number=NULL WHERE sku=:sku"), {"sku": sku})
|
|
shifted = (await db.execute(text(
|
|
"UPDATE inventory SET slot_number = slot_number + 1, updated_at = now() "
|
|
"WHERE crate_id = :c AND slot_number >= :s"), {"c": body.crate_id, "s": slot})).rowcount or 0
|
|
await db.execute(text(
|
|
"UPDATE inventory SET crate_id = :c, slot_number = :s, updated_at = now() WHERE sku = :sku"),
|
|
{"c": body.crate_id, "s": slot, "sku": sku})
|
|
await db.execute(text("UPDATE virtual_crate SET updated_at = now() WHERE id = :c"), {"c": body.crate_id})
|
|
await db.commit()
|
|
return {"ok": True, "sku": sku, "slot": slot, "shifted": shifted}
|
|
|
|
|
|
@router.post("/scan")
|
|
async def scan_assign(body: ScanAssignIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
resolved, not_found = [], []
|
|
for ln in body.lines:
|
|
if not ln.strip():
|
|
continue
|
|
sku = await _resolve_sku(db, ln)
|
|
if sku:
|
|
resolved.append(sku)
|
|
else:
|
|
not_found.append(ln.strip())
|
|
res = list(dict.fromkeys(resolved)) # unique, keep scan order
|
|
existing = [r[0] for r in (await db.execute(text(
|
|
"SELECT sku FROM inventory WHERE crate_id = :c AND in_stock ORDER BY slot_number NULLS LAST, sku"
|
|
), {"c": body.crate_id})).all()]
|
|
keep = [s for s in existing if s not in res] # existing items not in the scan
|
|
if body.mode == "replace":
|
|
order = res
|
|
elif body.mode == "append":
|
|
order = keep + res
|
|
elif body.mode == "prepend":
|
|
order = res + keep
|
|
elif body.mode == "insert":
|
|
at = max(0, (body.insert_at or 1) - 1)
|
|
order = keep[:at] + res + keep[at:]
|
|
else:
|
|
raise HTTPException(400, "bad mode")
|
|
|
|
if body.dry_run:
|
|
meta = {}
|
|
if order:
|
|
rows = await db.execute(text("""SELECT i.sku, coalesce(i.title, dc.title) AS title, dc.artist
|
|
FROM inventory i LEFT JOIN disc_cache dc ON dc.release_id = i.release_id WHERE i.sku = ANY(:s)"""),
|
|
{"s": order})
|
|
meta = {r["sku"]: r for r in rows.mappings()}
|
|
plan = [{"slot": n, "sku": s, "title": (meta.get(s) or {}).get("title"),
|
|
"artist": (meta.get(s) or {}).get("artist")} for n, s in enumerate(order, 1)]
|
|
return {"ok": True, "preview": True, "plan": plan, "not_found": not_found, "count": len(order)}
|
|
|
|
if body.mode == "replace": # Replace All: items dropped from the crate get unfiled
|
|
removed = [s for s in existing if s not in order]
|
|
if removed:
|
|
await db.execute(text("UPDATE inventory SET crate_id=NULL, slot_number=NULL, updated_at=now() "
|
|
"WHERE sku = ANY(:s)"), {"s": removed})
|
|
for n, sku in enumerate(order, 1):
|
|
await db.execute(text("UPDATE inventory SET crate_id=:c, slot_number=:n, updated_at=now() WHERE sku=:sku"),
|
|
{"c": body.crate_id, "n": n, "sku": sku})
|
|
await db.execute(text("UPDATE virtual_crate SET updated_at=now() WHERE id=:c"), {"c": body.crate_id})
|
|
await db.commit()
|
|
return {"ok": True, "assigned": len(order), "not_found": not_found}
|
|
|
|
|
|
# ── Reorganize — A-Z re-file planner (server scans + applies; client plans the moves) ──────────
|
|
class ScanIn(BaseModel):
|
|
crate_ids: list[int]
|
|
|
|
|
|
class Move(BaseModel):
|
|
sku: str
|
|
new_crate_id: int
|
|
new_slot: int
|
|
|
|
|
|
class Leftover(BaseModel):
|
|
sku: str
|
|
archive_location: str | None = None
|
|
|
|
|
|
class ApplyIn(BaseModel):
|
|
matched: list[Move] = []
|
|
leftovers: list[Leftover] = []
|
|
|
|
|
|
@router.post("/reorg/scan")
|
|
async def reorg_scan(body: ScanIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""Every in-stock item across the source crates — the pool the client sorts + redistributes."""
|
|
ids = [c for c in body.crate_ids if c and c > 0]
|
|
if not ids:
|
|
raise HTTPException(400, "no crate ids")
|
|
rows = [dict(r) for r in (await db.execute(text("""
|
|
SELECT i.sku, i.release_id, i.crate_id, i.slot_number::int AS slot, i.price::float AS price,
|
|
i.condition, coalesce(i.title, dc.title) AS title, dc.artist, dc.year, dc.thumb,
|
|
c.label_text AS crate_label
|
|
FROM inventory i
|
|
LEFT JOIN disc_cache dc ON dc.release_id = i.release_id
|
|
LEFT JOIN virtual_crate c ON c.id = i.crate_id
|
|
WHERE i.crate_id = ANY(:ids) AND i.in_stock
|
|
ORDER BY i.crate_id, i.slot_number NULLS LAST
|
|
"""), {"ids": ids})).mappings()]
|
|
return {"ok": True, "items": rows, "count": len(rows), "crate_ids": ids}
|
|
|
|
|
|
@router.post("/reorg/apply")
|
|
async def reorg_apply(body: ApplyIn, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""Commit the plan in ONE transaction: matched → new crate+slot, leftovers → unfiled/archived."""
|
|
if not body.matched and not body.leftovers:
|
|
raise HTTPException(400, "nothing to apply")
|
|
moved = 0
|
|
for m in body.matched:
|
|
if not m.sku or m.new_crate_id < 1 or m.new_slot < 1:
|
|
continue
|
|
r = await db.execute(text("""
|
|
UPDATE inventory SET crate_id=:c, slot_number=:s, updated_at=now()
|
|
WHERE sku=:sku
|
|
"""), {"c": m.new_crate_id, "s": m.new_slot, "sku": m.sku})
|
|
moved += r.rowcount or 0
|
|
archived = 0
|
|
for lo in body.leftovers:
|
|
if not lo.sku:
|
|
continue
|
|
r = await db.execute(text("""
|
|
UPDATE inventory SET crate_id=NULL, slot_number=NULL, location=:loc, updated_at=now()
|
|
WHERE sku=:sku
|
|
"""), {"loc": lo.archive_location, "sku": lo.sku})
|
|
archived += r.rowcount or 0
|
|
if moved == 0 and body.matched:
|
|
# nothing matched a real SKU — roll back rather than half-apply
|
|
await db.rollback()
|
|
raise HTTPException(409, f"0 of {len(body.matched)} items matched an inventory SKU — nothing written")
|
|
await db.commit()
|
|
return {"ok": True, "matched_updated": moved, "leftovers_archived": archived}
|
|
|
|
|
|
@router.post("/reorg/compress/{crate_id}")
|
|
async def reorg_compress(crate_id: int, ident=Depends(require_token), db=Depends(get_db)):
|
|
"""Close gaps in a crate's slot numbering — renumber 1..N by current slot order."""
|
|
await db.execute(text("""
|
|
WITH ranked AS (
|
|
SELECT sku, row_number() OVER (ORDER BY slot_number NULLS LAST, sku) AS rn
|
|
FROM inventory WHERE crate_id = :c AND in_stock)
|
|
UPDATE inventory i SET slot_number = ranked.rn, updated_at = now()
|
|
FROM ranked WHERE i.sku = ranked.sku
|
|
"""), {"c": crate_id})
|
|
n = (await db.execute(text(
|
|
"SELECT count(*) FROM inventory WHERE crate_id=:c AND in_stock"), {"c": crate_id})).scalar()
|
|
await db.commit()
|
|
return {"ok": True, "slots": n}
|