206 lines
8.8 KiB
Python
206 lines
8.8 KiB
Python
from fastapi import APIRouter, HTTPException, Request
|
|
|
|
from app.services.repository import repo
|
|
from app.services.recipe_search import recipe_search
|
|
from app.services.store import JsonStore
|
|
|
|
|
|
router = APIRouter(prefix="/api", tags=["dashboard"])
|
|
store = JsonStore()
|
|
|
|
|
|
def usable_results(items):
|
|
return [entry for entry in items if str(entry.get("status") or "suggested") != "rejected"]
|
|
|
|
|
|
def _find_suggestion(suggestion_id: str | None):
|
|
if not suggestion_id:
|
|
return None
|
|
return next((item for item in repo.list_suggestions() if str(item.get("id")) == str(suggestion_id)), None)
|
|
|
|
|
|
def _find_existing_open_import_flag(recipe_url: str, kitchenowl_recipe_id: str | int | None):
|
|
recipe_url = str(recipe_url or "").strip().lower()
|
|
recipe_id = str(kitchenowl_recipe_id or "").strip()
|
|
for item in repo.list_import_flags():
|
|
if str(item.get("status") or "open") != "open":
|
|
continue
|
|
item_url = str(item.get("recipe_url") or "").strip().lower()
|
|
item_recipe_id = str(item.get("kitchenowl_recipe_id") or "").strip()
|
|
if recipe_id and item_recipe_id and recipe_id == item_recipe_id:
|
|
return item
|
|
if recipe_url and item_url and recipe_url == item_url:
|
|
return item
|
|
return None
|
|
|
|
|
|
@router.get("/health")
|
|
async def health():
|
|
return {"status": "ok", "backend": repo.backend}
|
|
|
|
|
|
@router.get("/dashboard/summary")
|
|
async def summary():
|
|
profile = repo.get_profile()
|
|
suggestions = repo.list_suggestions()
|
|
plans = repo.list_meal_plans()
|
|
failed_searches = repo.recent_failed_searches(limit=6)
|
|
import_flags = repo.list_import_flags()
|
|
counts = {
|
|
"suggested": sum(1 for item in suggestions if item.get("status") == "suggested"),
|
|
"approved": sum(1 for item in suggestions if item.get("status") == "approved"),
|
|
"saved": sum(1 for item in suggestions if item.get("status") == "saved"),
|
|
"rejected": sum(1 for item in suggestions if item.get("status") == "rejected"),
|
|
"plans": len(plans),
|
|
"failed_searches": len(repo.list_failed_searches()),
|
|
"open_import_flags": sum(1 for item in import_flags if str(item.get("status") or "open") == "open"),
|
|
}
|
|
return {
|
|
"backend": repo.backend,
|
|
"profile": profile,
|
|
"counts": counts,
|
|
"recent_suggestions": repo.recent_suggestions(),
|
|
"recent_plans": list(reversed(plans[-4:])),
|
|
"recent_failed_searches": failed_searches,
|
|
"recent_import_flags": repo.recent_import_flags(limit=6),
|
|
}
|
|
|
|
|
|
@router.get("/failed-searches")
|
|
async def failed_searches():
|
|
return {"status": "ok", "items": repo.list_failed_searches()}
|
|
|
|
|
|
@router.get("/failed-searches/{failed_search_id}/results")
|
|
async def failed_search_results(failed_search_id: str):
|
|
item = next((entry for entry in repo.list_failed_searches() if str(entry.get("id")) == str(failed_search_id)), None)
|
|
if not item:
|
|
raise HTTPException(status_code=404, detail="Failed search not found.")
|
|
query = str(item.get("query") or "").strip()
|
|
if not query:
|
|
raise HTTPException(status_code=400, detail="Failed search query is empty.")
|
|
all_results = recipe_search.search(query, limit=10)
|
|
results = usable_results(all_results)
|
|
updates = {
|
|
"last_checked_at": store.now(),
|
|
"updated_at": store.now(),
|
|
"result_count": len(results),
|
|
"sample_titles": [str(entry.get("title") or "") for entry in results[:4]],
|
|
}
|
|
if results:
|
|
updates["status"] = "resolved-with-recipes"
|
|
updates["resolved_at"] = str(item.get("resolved_at") or store.now())
|
|
saved = repo.update_failed_search(str(item.get("id")), updates) or {**item, **updates}
|
|
return {"status": "ok", "item": saved, "results": results}
|
|
|
|
|
|
@router.post("/failed-searches/refresh")
|
|
async def refresh_failed_searches():
|
|
items = repo.list_failed_searches()
|
|
refreshed = []
|
|
for item in items:
|
|
query = str(item.get("query") or "").strip()
|
|
status = str(item.get("status") or "open")
|
|
if not query or status != "open":
|
|
refreshed.append(item)
|
|
continue
|
|
all_results = recipe_search.search(query, limit=10)
|
|
results = usable_results(all_results)
|
|
preview_titles = [str(entry.get("title") or "") for entry in results[:4] if str(entry.get("title") or "").strip()]
|
|
result_count = len(results)
|
|
updates = {
|
|
"last_checked_at": store.now(),
|
|
"result_count": result_count,
|
|
"sample_titles": preview_titles,
|
|
}
|
|
if result_count > 0:
|
|
updates["status"] = "resolved-with-recipes"
|
|
updates["resolved_at"] = store.now()
|
|
saved = repo.update_failed_search(str(item.get("id")), updates) or {**item, **updates}
|
|
refreshed.append(saved)
|
|
return {"status": "ok", "items": refreshed}
|
|
|
|
|
|
@router.get("/import-flags")
|
|
async def list_import_flags():
|
|
return {"status": "ok", "items": repo.list_import_flags()}
|
|
|
|
|
|
@router.post("/import-flags")
|
|
async def create_import_flag(request: Request):
|
|
payload = await request.json()
|
|
suggestion_id = str(payload.get("suggestion_id") or "").strip() or None
|
|
suggestion = _find_suggestion(suggestion_id)
|
|
if suggestion_id and not suggestion:
|
|
raise HTTPException(status_code=404, detail="Suggestion not found.")
|
|
|
|
recipe_title = str(payload.get("recipe_title") or (suggestion or {}).get("title") or ((suggestion or {}).get("payload") or {}).get("name") or "").strip()
|
|
recipe_url = str(payload.get("recipe_url") or ((suggestion or {}).get("payload") or {}).get("source") or (suggestion or {}).get("url") or "").strip()
|
|
issue_type = str(payload.get("issue_type") or "formatting").strip().lower() or "formatting"
|
|
notes = str(payload.get("notes") or "").strip()
|
|
kitchenowl_recipe_id = payload.get("kitchenowl_recipe_id")
|
|
if kitchenowl_recipe_id in {None, "", 0}:
|
|
kitchenowl_recipe_id = (((suggestion or {}).get("kitchenowl_result") or {}).get("recipe") or {}).get("id")
|
|
|
|
if not notes:
|
|
raise HTTPException(status_code=400, detail="Issue notes are required.")
|
|
if not recipe_title and not recipe_url and not kitchenowl_recipe_id:
|
|
raise HTTPException(status_code=400, detail="Provide at least a recipe title, recipe URL, or KitchenOwl recipe id.")
|
|
|
|
existing = _find_existing_open_import_flag(recipe_url, kitchenowl_recipe_id)
|
|
if existing:
|
|
history = list(existing.get("notes_history") or [])
|
|
history.append({"at": store.now(), "issue_type": issue_type, "notes": notes})
|
|
updates = {
|
|
"updated_at": store.now(),
|
|
"last_flagged_at": store.now(),
|
|
"issue_type": issue_type,
|
|
"notes": notes,
|
|
"notes_history": history[-20:],
|
|
"flag_count": int(existing.get("flag_count") or 1) + 1,
|
|
"recipe_title": recipe_title or existing.get("recipe_title"),
|
|
"recipe_url": recipe_url or existing.get("recipe_url"),
|
|
"kitchenowl_recipe_id": kitchenowl_recipe_id or existing.get("kitchenowl_recipe_id"),
|
|
"suggestion_id": suggestion_id or existing.get("suggestion_id"),
|
|
"kitchenowl_status": (suggestion or {}).get("kitchenowl_status") or existing.get("kitchenowl_status"),
|
|
}
|
|
saved = repo.update_import_flag(str(existing.get("id")), updates) or {**existing, **updates}
|
|
return {"status": "ok", "item": saved, "deduplicated": True}
|
|
|
|
item = {
|
|
"id": store.new_id("import-flag"),
|
|
"status": "open",
|
|
"issue_type": issue_type,
|
|
"notes": notes,
|
|
"notes_history": [{"at": store.now(), "issue_type": issue_type, "notes": notes}],
|
|
"flag_count": 1,
|
|
"created_at": store.now(),
|
|
"updated_at": store.now(),
|
|
"last_flagged_at": store.now(),
|
|
"suggestion_id": suggestion_id,
|
|
"recipe_title": recipe_title,
|
|
"recipe_url": recipe_url,
|
|
"kitchenowl_recipe_id": kitchenowl_recipe_id,
|
|
"kitchenowl_status": (suggestion or {}).get("kitchenowl_status"),
|
|
}
|
|
saved = repo.log_import_flag(item)
|
|
return {"status": "ok", "item": saved, "deduplicated": False}
|
|
|
|
|
|
@router.post("/import-flags/{import_flag_id}/resolve")
|
|
async def resolve_import_flag(import_flag_id: str, request: Request):
|
|
payload = await request.json()
|
|
current = next((entry for entry in repo.list_import_flags() if str(entry.get("id")) == str(import_flag_id)), None)
|
|
if not current:
|
|
raise HTTPException(status_code=404, detail="Import flag not found.")
|
|
resolution_notes = str(payload.get("resolution_notes") or "").strip()
|
|
updates = {
|
|
"status": "resolved",
|
|
"updated_at": store.now(),
|
|
"resolved_at": store.now(),
|
|
}
|
|
if resolution_notes:
|
|
updates["resolution_notes"] = resolution_notes
|
|
saved = repo.update_import_flag(import_flag_id, updates) or {**current, **updates}
|
|
return {"status": "ok", "item": saved}
|