598 lines
22 KiB
Python
598 lines
22 KiB
Python
"""
|
|
routes/collection.py
|
|
====================
|
|
Collection management endpoints:
|
|
GET /api/collection
|
|
GET /api/collection/export
|
|
GET /api/collection/sets
|
|
GET /api/collection/keywords
|
|
POST /api/collection/import
|
|
GET /api/collection/{cardId}
|
|
PATCH /api/collection/{cardId}
|
|
GET /api/cache/scryfall
|
|
DELETE /api/cache/scryfall
|
|
POST /api/cache/scryfall/evict
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import csv
|
|
import io
|
|
import json
|
|
import re
|
|
from datetime import datetime
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, HTTPException
|
|
from fastapi.responses import JSONResponse, StreamingResponse
|
|
|
|
from models.state import CFG
|
|
from services.card_analysis import _detect_card_roles
|
|
from services.database import (
|
|
_get_db_conn, _row_to_dict, _add_image_url, _build_collection_filters,
|
|
_snake_to_camel, VALID_SORT_FIELDS, _JSON_FIELDS,
|
|
)
|
|
from services.deck_service import _classify_card_type
|
|
from services.import_service import (
|
|
_parse_finish, _parse_text_line, _parse_csv_content, _auto_infer_mapping,
|
|
)
|
|
from services.logging import log_collect, log_cache
|
|
from services.scryfall import (
|
|
SCRYFALL_CACHE_DB_PATH, SCRYFALL_CACHE_TTL_SECONDS, _API_HEADERS,
|
|
_scryfall_cache, _scryfall_rate_limit,
|
|
_enrich_from_scryfall, _fetch_scryfall_api,
|
|
)
|
|
|
|
router = APIRouter(tags=["collection"])
|
|
|
|
|
|
@router.get("/api/collection/stats")
|
|
async def collection_stats():
|
|
"""Aggregate collection statistics for the dashboard."""
|
|
conn = _get_db_conn()
|
|
stats = {}
|
|
|
|
# Total cards and unique cards
|
|
row = conn.execute(
|
|
"SELECT COUNT(*) as total_rows, COALESCE(SUM(quantity),0) as total_cards, "
|
|
"COALESCE(SUM(tcg_price * quantity),0) as total_value "
|
|
"FROM collection_entries"
|
|
).fetchone()
|
|
stats["totalUniqueCards"] = row["total_rows"]
|
|
stats["totalCards"] = row["total_cards"]
|
|
stats["totalValue"] = round(row["total_value"], 2)
|
|
|
|
# CMC distribution (0-7+)
|
|
cmc_rows = conn.execute(
|
|
"SELECT CASE WHEN cmc >= 7 THEN 7 ELSE CAST(cmc AS INTEGER) END as cmc_bucket, "
|
|
"SUM(quantity) as count FROM collection_entries GROUP BY cmc_bucket ORDER BY cmc_bucket"
|
|
).fetchall()
|
|
stats["cmcCurve"] = {str(r["cmc_bucket"]): r["count"] for r in cmc_rows}
|
|
|
|
# Color identity distribution
|
|
color_rows = conn.execute(
|
|
"SELECT color_identity, SUM(quantity) as count FROM collection_entries GROUP BY color_identity"
|
|
).fetchall()
|
|
color_counts = {"W": 0, "U": 0, "B": 0, "R": 0, "G": 0, "C": 0}
|
|
for r in color_rows:
|
|
ci = r["color_identity"] or "[]"
|
|
try:
|
|
colors = json.loads(ci) if isinstance(ci, str) else ci
|
|
except (json.JSONDecodeError, TypeError):
|
|
colors = []
|
|
qty = r["count"] or 0
|
|
if not colors:
|
|
color_counts["C"] += qty
|
|
else:
|
|
for c in colors:
|
|
if c in color_counts:
|
|
color_counts[c] += qty
|
|
stats["colorDistribution"] = color_counts
|
|
|
|
# Type distribution
|
|
type_rows = conn.execute(
|
|
"SELECT type_line, SUM(quantity) as count FROM collection_entries GROUP BY type_line"
|
|
).fetchall()
|
|
type_counts = {}
|
|
for r in type_rows:
|
|
tl = r["type_line"] or ""
|
|
qty = r["count"] or 0
|
|
for t in ["Creature", "Instant", "Sorcery", "Artifact", "Enchantment", "Planeswalker", "Land"]:
|
|
if t in tl:
|
|
type_counts[t] = type_counts.get(t, 0) + qty
|
|
stats["typeDistribution"] = type_counts
|
|
|
|
# Category/role distribution
|
|
cat_rows = conn.execute(
|
|
"SELECT category, SUM(quantity) as count FROM collection_entries "
|
|
"WHERE category != '' AND category != '[]' GROUP BY category"
|
|
).fetchall()
|
|
cat_counts = {}
|
|
for r in cat_rows:
|
|
raw = r["category"] or "[]"
|
|
qty = r["count"] or 0
|
|
try:
|
|
cats = json.loads(raw) if isinstance(raw, str) else raw
|
|
except (json.JSONDecodeError, TypeError):
|
|
cats = []
|
|
if isinstance(cats, list):
|
|
for c in cats:
|
|
cat_counts[c] = cat_counts.get(c, 0) + qty
|
|
stats["categoryDistribution"] = cat_counts
|
|
|
|
# Rarity distribution
|
|
rarity_rows = conn.execute(
|
|
"SELECT LOWER(rarity) as rarity, SUM(quantity) as count FROM collection_entries "
|
|
"WHERE rarity != '' GROUP BY LOWER(rarity)"
|
|
).fetchall()
|
|
stats["rarityDistribution"] = {r["rarity"]: r["count"] for r in rarity_rows}
|
|
|
|
# Top 10 most valuable cards
|
|
top_value = conn.execute(
|
|
"SELECT name, tcg_price, quantity FROM collection_entries "
|
|
"WHERE tcg_price > 0 ORDER BY tcg_price DESC LIMIT 10"
|
|
).fetchall()
|
|
stats["topValueCards"] = [{"name": r["name"], "price": r["tcg_price"], "qty": r["quantity"]} for r in top_value]
|
|
|
|
# Average CMC (excluding lands)
|
|
avg_row = conn.execute(
|
|
"SELECT AVG(cmc) as avg_cmc FROM collection_entries WHERE type_line NOT LIKE '%Land%'"
|
|
).fetchone()
|
|
stats["avgCmc"] = round(avg_row["avg_cmc"] or 0, 2)
|
|
|
|
return stats
|
|
|
|
|
|
@router.get("/api/collection/export")
|
|
async def export_collection(
|
|
format: str = "INTERNAL_CSV",
|
|
q: Optional[str] = None,
|
|
colors: Optional[str] = None,
|
|
types: Optional[str] = None,
|
|
isLegendary: Optional[bool] = None,
|
|
isBasic: Optional[bool] = None,
|
|
isGameChanger: Optional[bool] = None,
|
|
highSalt: Optional[bool] = None,
|
|
finish: Optional[str] = None,
|
|
cmcMin: Optional[float] = None,
|
|
cmcMax: Optional[float] = None,
|
|
priceMin: Optional[float] = None,
|
|
priceMax: Optional[float] = None,
|
|
category: Optional[str] = None,
|
|
rarity: Optional[str] = None,
|
|
setCode: Optional[str] = None,
|
|
powerMin: Optional[str] = None,
|
|
powerMax: Optional[str] = None,
|
|
toughMin: Optional[str] = None,
|
|
toughMax: Optional[str] = None,
|
|
keyword: Optional[str] = None,
|
|
edhrecMin: Optional[int] = None,
|
|
edhrecMax: Optional[int] = None,
|
|
qtyMin: Optional[int] = None,
|
|
qtyMax: Optional[int] = None,
|
|
):
|
|
"""Export collection in various formats with optional filters."""
|
|
where_str, params = _build_collection_filters(
|
|
q=q, colors=colors, types=types, isLegendary=isLegendary,
|
|
isBasic=isBasic, isGameChanger=isGameChanger, highSalt=highSalt,
|
|
finish=finish, cmcMin=cmcMin, cmcMax=cmcMax,
|
|
priceMin=priceMin, priceMax=priceMax, category=category,
|
|
rarity=rarity, setCode=setCode,
|
|
powerMin=powerMin, powerMax=powerMax,
|
|
toughMin=toughMin, toughMax=toughMax,
|
|
keyword=keyword,
|
|
edhrecMin=edhrecMin, edhrecMax=edhrecMax,
|
|
qtyMin=qtyMin, qtyMax=qtyMax,
|
|
)
|
|
|
|
sql = f"SELECT * FROM collection_entries {where_str} ORDER BY name ASC"
|
|
conn = _get_db_conn()
|
|
rows = [_row_to_dict(r) for r in conn.execute(sql, params).fetchall()]
|
|
|
|
fmt = format.upper()
|
|
output = io.StringIO()
|
|
|
|
if fmt == "INTERNAL_CSV":
|
|
if rows:
|
|
fieldnames = list(rows[0].keys())
|
|
else:
|
|
fieldnames = [
|
|
"id", "name", "type_line", "subtypes", "is_legendary", "is_basic",
|
|
"color_identity", "cmc", "oracle_text", "keywords", "tcg_price",
|
|
"salt_score", "is_game_changer", "category", "scryfall_id", "tcgplayer_id",
|
|
"quantity", "finish", "condition", "language", "notes", "tags",
|
|
"set_code", "collector_number", "created_at", "updated_at",
|
|
]
|
|
writer = csv.DictWriter(output, fieldnames=fieldnames)
|
|
writer.writeheader()
|
|
writer.writerows(rows)
|
|
filename = "collection_export.csv"
|
|
media_type = "text/csv"
|
|
|
|
elif fmt == "MOXFIELD_CSV":
|
|
fieldnames = ["Count", "Name", "Edition", "Condition", "Language", "Foil", "Collector Number"]
|
|
writer = csv.DictWriter(output, fieldnames=fieldnames)
|
|
writer.writeheader()
|
|
for row in rows:
|
|
finish_val = row.get("finish", "NORMAL").upper()
|
|
foil_val = "foil" if finish_val == "FOIL" else ("etched" if finish_val == "ETCHED" else "")
|
|
writer.writerow({
|
|
"Count": row.get("quantity", 1),
|
|
"Name": row.get("name", ""),
|
|
"Edition": row.get("set_code", "").upper(),
|
|
"Condition": row.get("condition", ""),
|
|
"Language": row.get("language", ""),
|
|
"Foil": foil_val,
|
|
"Collector Number": row.get("collector_number", ""),
|
|
})
|
|
filename = "collection_moxfield.csv"
|
|
media_type = "text/csv"
|
|
|
|
elif fmt == "TEXT":
|
|
lines = []
|
|
for row in rows:
|
|
qty = row.get("quantity", 1)
|
|
name = row.get("name", "")
|
|
set_code = row.get("set_code", "").upper()
|
|
coll_num = row.get("collector_number", "")
|
|
if set_code and coll_num:
|
|
lines.append(f"{qty} {name} ({set_code}) {coll_num}")
|
|
elif set_code:
|
|
lines.append(f"{qty} {name} ({set_code})")
|
|
else:
|
|
lines.append(f"{qty} {name}")
|
|
output.write("\n".join(lines))
|
|
filename = "collection_export.txt"
|
|
media_type = "text/plain"
|
|
|
|
else:
|
|
raise HTTPException(400, f"Unknown format: {format}. Use INTERNAL_CSV, MOXFIELD_CSV, or TEXT.")
|
|
|
|
content = output.getvalue()
|
|
|
|
def iter_content():
|
|
yield content.encode("utf-8")
|
|
|
|
return StreamingResponse(
|
|
iter_content(),
|
|
media_type=media_type,
|
|
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
|
|
)
|
|
|
|
|
|
@router.get("/api/collection/sets")
|
|
async def collection_sets():
|
|
"""Return distinct set codes + names in the collection (for filter autocomplete)."""
|
|
conn = _get_db_conn()
|
|
rows = conn.execute(
|
|
"SELECT DISTINCT UPPER(set_code) as code, set_name as name FROM collection_entries WHERE set_code != '' ORDER BY set_name ASC"
|
|
).fetchall()
|
|
result = []
|
|
for r in rows:
|
|
code = r["code"] if "code" in r.keys() else r[0]
|
|
name = r["name"] if "name" in r.keys() else r[1]
|
|
if code:
|
|
result.append({"code": code, "name": name or code})
|
|
return JSONResponse(result)
|
|
|
|
|
|
@router.get("/api/collection/keywords")
|
|
async def collection_keywords():
|
|
"""Return distinct keywords found in the collection."""
|
|
conn = _get_db_conn()
|
|
rows = conn.execute("SELECT keywords FROM collection_entries WHERE keywords != '' AND keywords != '[]'").fetchall()
|
|
kw_set = set()
|
|
for r in rows:
|
|
try:
|
|
kws = json.loads(r["keywords"]) if isinstance(r["keywords"], str) else r["keywords"]
|
|
if isinstance(kws, list):
|
|
for k in kws:
|
|
if k:
|
|
kw_set.add(k)
|
|
except (json.JSONDecodeError, TypeError):
|
|
pass
|
|
return JSONResponse(sorted(kw_set))
|
|
|
|
|
|
@router.get("/api/collection")
|
|
async def list_collection(
|
|
page: int = 1,
|
|
pageSize: int = 50,
|
|
q: Optional[str] = None,
|
|
sortField: Optional[str] = None,
|
|
sortDir: Optional[str] = None,
|
|
colors: Optional[str] = None,
|
|
types: Optional[str] = None,
|
|
isLegendary: Optional[bool] = None,
|
|
isBasic: Optional[bool] = None,
|
|
isGameChanger: Optional[bool] = None,
|
|
highSalt: Optional[bool] = None,
|
|
finish: Optional[str] = None,
|
|
cmcMin: Optional[float] = None,
|
|
cmcMax: Optional[float] = None,
|
|
priceMin: Optional[float] = None,
|
|
priceMax: Optional[float] = None,
|
|
category: Optional[str] = None,
|
|
deck_id: Optional[int] = None,
|
|
rarity: Optional[str] = None,
|
|
setCode: Optional[str] = None,
|
|
powerMin: Optional[str] = None,
|
|
powerMax: Optional[str] = None,
|
|
toughMin: Optional[str] = None,
|
|
toughMax: Optional[str] = None,
|
|
keyword: Optional[str] = None,
|
|
edhrecMin: Optional[int] = None,
|
|
edhrecMax: Optional[int] = None,
|
|
qtyMin: Optional[int] = None,
|
|
qtyMax: Optional[int] = None,
|
|
):
|
|
"""List collection entries with search, sort, and filter.
|
|
Optional deck_id: when provided, includes in_deck_quantity for each result.
|
|
"""
|
|
where_str, params = _build_collection_filters(
|
|
q=q, colors=colors, types=types, isLegendary=isLegendary,
|
|
isBasic=isBasic, isGameChanger=isGameChanger, highSalt=highSalt,
|
|
finish=finish, cmcMin=cmcMin, cmcMax=cmcMax,
|
|
priceMin=priceMin, priceMax=priceMax, category=category,
|
|
rarity=rarity, setCode=setCode, powerMin=powerMin, powerMax=powerMax,
|
|
toughMin=toughMin, toughMax=toughMax, keyword=keyword,
|
|
edhrecMin=edhrecMin, edhrecMax=edhrecMax, qtyMin=qtyMin, qtyMax=qtyMax,
|
|
)
|
|
|
|
# Validate sort
|
|
sort_field = sortField if sortField in VALID_SORT_FIELDS else "name"
|
|
sort_dir = "DESC" if (sortDir or "").upper() == "DESC" else "ASC"
|
|
|
|
conn = _get_db_conn()
|
|
|
|
# Count total
|
|
count_sql = f"SELECT COUNT(*) FROM collection_entries {where_str}"
|
|
total = conn.execute(count_sql, params).fetchone()[0]
|
|
|
|
# Paginate
|
|
offset = (max(1, page) - 1) * pageSize
|
|
data_sql = f"""
|
|
SELECT * FROM collection_entries {where_str}
|
|
ORDER BY {sort_field} {sort_dir}
|
|
LIMIT ? OFFSET ?
|
|
"""
|
|
rows = conn.execute(data_sql, params + [pageSize, offset]).fetchall()
|
|
items = [_add_image_url(_row_to_dict(r)) for r in rows]
|
|
|
|
# If deck_id provided, annotate each item with how many copies are already in that deck
|
|
if deck_id is not None:
|
|
# Build a map of scryfall_id -> quantity in deck
|
|
deck_card_rows = conn.execute(
|
|
"SELECT scryfall_id, SUM(quantity) as qty FROM deck_cards WHERE deck_id = ? GROUP BY scryfall_id",
|
|
(deck_id,)
|
|
).fetchall()
|
|
in_deck_map = {row["scryfall_id"]: row["qty"] for row in deck_card_rows}
|
|
for item in items:
|
|
item["in_deck_quantity"] = in_deck_map.get(item.get("scryfall_id", ""), 0)
|
|
|
|
return {"items": items, "page": page, "pageSize": pageSize, "total": total}
|
|
|
|
|
|
@router.get("/api/collection/{cardId}")
|
|
async def get_collection_card(cardId: int):
|
|
"""Get a single collection entry by ID."""
|
|
conn = _get_db_conn()
|
|
row = conn.execute("SELECT * FROM collection_entries WHERE id = ?", (cardId,)).fetchone()
|
|
if not row:
|
|
raise HTTPException(404, f"Card with id {cardId} not found")
|
|
return _add_image_url(_row_to_dict(row))
|
|
|
|
|
|
@router.patch("/api/collection/{cardId}")
|
|
async def update_collection_card(cardId: int, body: dict):
|
|
"""Update mutable fields of a collection entry."""
|
|
conn = _get_db_conn()
|
|
row = conn.execute("SELECT * FROM collection_entries WHERE id = ?", (cardId,)).fetchone()
|
|
if not row:
|
|
raise HTTPException(404, f"Card with id {cardId} not found")
|
|
|
|
updates = {}
|
|
if "category" in body:
|
|
cat = body["category"]
|
|
if isinstance(cat, list):
|
|
updates["category"] = json.dumps(cat)
|
|
else:
|
|
updates["category"] = cat
|
|
if "tags" in body:
|
|
updates["tags"] = str(body["tags"])
|
|
if "notes" in body:
|
|
updates["notes"] = str(body["notes"])
|
|
if "finish" in body:
|
|
finish_val = str(body["finish"]).upper()
|
|
if finish_val not in ("NORMAL", "FOIL", "ETCHED"):
|
|
raise HTTPException(400, "finish must be NORMAL, FOIL, or ETCHED")
|
|
updates["finish"] = finish_val
|
|
if "quantity" in body:
|
|
qty_val = int(body["quantity"])
|
|
if qty_val < 0:
|
|
raise HTTPException(400, "quantity must be >= 0")
|
|
updates["quantity"] = qty_val
|
|
|
|
if not updates:
|
|
return _add_image_url(_row_to_dict(row))
|
|
|
|
updates["updated_at"] = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
|
|
set_clause = ", ".join(f"{k} = ?" for k in updates)
|
|
values = list(updates.values()) + [cardId]
|
|
conn.execute(f"UPDATE collection_entries SET {set_clause} WHERE id = ?", values)
|
|
conn.commit()
|
|
|
|
updated_row = conn.execute("SELECT * FROM collection_entries WHERE id = ?", (cardId,)).fetchone()
|
|
return _add_image_url(_row_to_dict(updated_row))
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════
|
|
# Collection Import Endpoint
|
|
# ══════════════════════════════════════════════════════════════
|
|
|
|
@router.post("/api/collection/import")
|
|
async def import_collection(body: dict):
|
|
"""
|
|
Import cards into the collection from CSV, Moxfield, Archidekt, or plain text.
|
|
|
|
Body:
|
|
{
|
|
"source": "CSV" | "MOXFIELD" | "ARCHIDEKT" | "TEXT",
|
|
"mode": "MERGE" | "REPLACE",
|
|
"content": "...csv or text content...",
|
|
"mapping": { ... optional column mapping ... }
|
|
}
|
|
"""
|
|
source = str(body.get("source", "CSV")).upper()
|
|
mode = str(body.get("mode", "MERGE")).upper()
|
|
content = str(body.get("content", ""))
|
|
mapping = body.get("mapping", {})
|
|
|
|
if not content.strip():
|
|
raise HTTPException(400, "content is required")
|
|
|
|
imported_count = 0
|
|
updated_count = 0
|
|
failed_count = 0
|
|
errors = []
|
|
|
|
conn = _get_db_conn()
|
|
|
|
# REPLACE mode: clear existing entries
|
|
if mode == "REPLACE":
|
|
conn.execute("DELETE FROM collection_entries")
|
|
conn.commit()
|
|
|
|
# Parse the content into raw rows
|
|
try:
|
|
raw_rows = _parse_csv_content(content, source, mapping if mapping else None)
|
|
except Exception as e:
|
|
raise HTTPException(400, f"Failed to parse content: {str(e)}")
|
|
|
|
for raw in raw_rows:
|
|
name = raw.get("name", "").strip()
|
|
if not name:
|
|
continue
|
|
|
|
quantity = int(raw.get("quantity", 1))
|
|
set_code = raw.get("set_code", "").lower()
|
|
collector_number = raw.get("collector_number", "")
|
|
finish = _parse_finish(raw.get("finish", ""))
|
|
condition = raw.get("condition", "")
|
|
language = raw.get("language", "")
|
|
notes = raw.get("notes", "")
|
|
tags = raw.get("tags", "")
|
|
|
|
# Scryfall enrichment
|
|
try:
|
|
enriched = _enrich_from_scryfall(name, set_code, collector_number)
|
|
except Exception as e:
|
|
errors.append(f"Scryfall error for '{name}': {str(e)}")
|
|
failed_count += 1
|
|
continue
|
|
|
|
if not enriched or "_error" in enriched:
|
|
err_msg = enriched.get("_error", f"Card not found on Scryfall: '{name}'") if enriched else f"Card not found on Scryfall: '{name}'"
|
|
errors.append(err_msg)
|
|
failed_count += 1
|
|
continue
|
|
|
|
# Use Scryfall-resolved name if available
|
|
resolved_name = enriched.get("name", name)
|
|
|
|
# Check for existing entry (identity key)
|
|
existing = conn.execute(
|
|
"""SELECT id, quantity FROM collection_entries
|
|
WHERE name = ? AND set_code = ? AND collector_number = ? AND finish = ?""",
|
|
(resolved_name, set_code, collector_number, finish),
|
|
).fetchone()
|
|
|
|
if existing and mode == "MERGE":
|
|
# Update quantity
|
|
new_qty = existing["quantity"] + quantity
|
|
conn.execute(
|
|
"UPDATE collection_entries SET quantity = ?, updated_at = datetime('now') WHERE id = ?",
|
|
(new_qty, existing["id"]),
|
|
)
|
|
conn.commit()
|
|
updated_count += 1
|
|
else:
|
|
# Insert new row
|
|
conn.execute(
|
|
"""INSERT INTO collection_entries
|
|
(name, type_line, subtypes, is_legendary, is_basic, color_identity,
|
|
cmc, mana_cost, oracle_text, keywords,
|
|
power, toughness, rarity, set_name, edhrec_rank,
|
|
tcg_price, salt_score, is_game_changer,
|
|
category, scryfall_id, tcgplayer_id,
|
|
quantity, finish, condition, language, notes, tags,
|
|
set_code, collector_number)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
|
|
(
|
|
resolved_name,
|
|
enriched.get("type_line", ""),
|
|
enriched.get("subtypes", "[]"),
|
|
enriched.get("is_legendary", 0),
|
|
enriched.get("is_basic", 0),
|
|
enriched.get("color_identity", "[]"),
|
|
enriched.get("cmc", 0.0),
|
|
enriched.get("mana_cost", ""),
|
|
enriched.get("oracle_text", ""),
|
|
enriched.get("keywords", "[]"),
|
|
enriched.get("power", ""),
|
|
enriched.get("toughness", ""),
|
|
enriched.get("rarity", ""),
|
|
enriched.get("set_name", ""),
|
|
enriched.get("edhrec_rank", 0),
|
|
enriched.get("tcg_price", 0.0),
|
|
enriched.get("salt_score", 0.0),
|
|
enriched.get("is_game_changer", 0),
|
|
enriched.get("category", "[]"),
|
|
enriched.get("scryfall_id", ""),
|
|
enriched.get("tcgplayer_id", ""),
|
|
quantity,
|
|
finish,
|
|
condition,
|
|
language,
|
|
notes,
|
|
tags,
|
|
set_code,
|
|
collector_number,
|
|
),
|
|
)
|
|
conn.commit()
|
|
imported_count += 1
|
|
|
|
return {
|
|
"importedCount": imported_count,
|
|
"updatedCount": updated_count,
|
|
"failedCount": failed_count,
|
|
"errors": errors,
|
|
}
|
|
|
|
|
|
# ══════════════════════════════════════════════════════════════
|
|
# Scryfall Cache Management Endpoints
|
|
# ══════════════════════════════════════════════════════════════
|
|
|
|
|
|
@router.get("/api/cache/scryfall")
|
|
async def scryfall_cache_stats():
|
|
"""Return Scryfall response cache statistics."""
|
|
return _scryfall_cache.stats()
|
|
|
|
|
|
@router.delete("/api/cache/scryfall")
|
|
async def scryfall_cache_clear():
|
|
"""Clear all cached Scryfall responses."""
|
|
deleted = _scryfall_cache.clear()
|
|
return {"cleared": deleted, "message": f"Deleted {deleted} cached entries"}
|
|
|
|
|
|
@router.post("/api/cache/scryfall/evict")
|
|
async def scryfall_cache_evict_expired():
|
|
"""Remove only expired entries (older than TTL) from the cache."""
|
|
evicted = _scryfall_cache.evict_expired()
|
|
return {"evicted": evicted, "message": f"Evicted {evicted} expired entries"}
|
|
|
|
|