Caine
d0de1b44ea
- Move items between fridge↔freezer (freezer→fridge sets +7d or shelf life expiry, fridge→freezer clears expiry)
- Inline expiry date editor on fridge items (📅 button)
- Smart shopping list now shows recipe gaps (missing required slot ingredients)
- Summary card shows breakdown: X staple restocks, Y expiring, Z recipe gaps
431 lines
14 KiB
Python
431 lines
14 KiB
Python
"""
|
|
HTMX views — return HTML fragments for the frontend.
|
|
Separate from the DRF JSON API views.
|
|
"""
|
|
from datetime import date, timedelta
|
|
from decimal import Decimal
|
|
|
|
from django.http import HttpResponse
|
|
from django.shortcuts import render, get_object_or_404
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.decorators.http import require_POST, require_http_methods
|
|
|
|
from .models import (
|
|
Ingredient, PantryItem, MetaRecipe, Slot, SlotOption,
|
|
Recipe, CookLog, ShoppingListItem,
|
|
)
|
|
|
|
|
|
# --- Helpers ---
|
|
|
|
def _pantry_context():
|
|
"""Build pantry items grouped by location with expiry annotations."""
|
|
items = PantryItem.objects.select_related("ingredient").filter(quantity__gt=0)
|
|
today = date.today()
|
|
|
|
for item in items:
|
|
item.is_expired = item.expiry_date and item.expiry_date < today
|
|
item.expiring_soon = (
|
|
item.expiry_date
|
|
and not item.is_expired
|
|
and (item.expiry_date - today).days <= 2
|
|
)
|
|
|
|
return {
|
|
"fridge_items": [i for i in items if i.location == "fridge"],
|
|
"freezer_items": [i for i in items if i.location == "freezer"],
|
|
"cupboard_items": [i for i in items if i.location == "cupboard"],
|
|
}
|
|
|
|
|
|
def _get_pantry_total(ingredient_id):
|
|
total = Decimal("0")
|
|
for item in PantryItem.objects.filter(ingredient_id=ingredient_id, quantity__gt=0):
|
|
total += item.quantity
|
|
return total
|
|
|
|
|
|
def _find_ingredient(name):
|
|
"""Find ingredient by name or alias (case-insensitive)."""
|
|
try:
|
|
return Ingredient.objects.get(name__iexact=name)
|
|
except Ingredient.DoesNotExist:
|
|
pass
|
|
for ingredient in Ingredient.objects.all():
|
|
if ingredient.aliases and any(a.lower() == name.lower() for a in ingredient.aliases):
|
|
return ingredient
|
|
return None
|
|
|
|
|
|
# --- Page Views ---
|
|
|
|
def pantry_page(request):
|
|
ctx = _pantry_context()
|
|
ctx["active_tab"] = "pantry"
|
|
return render(request, "kitchen/pantry.html", ctx)
|
|
|
|
|
|
def recipes_page(request):
|
|
servings = 2
|
|
today = date.today()
|
|
|
|
# Build pantry lookup
|
|
pantry = {}
|
|
for item in PantryItem.objects.select_related("ingredient").filter(quantity__gt=0):
|
|
if item.ingredient_id not in pantry:
|
|
pantry[item.ingredient_id] = []
|
|
pantry[item.ingredient_id].append({
|
|
"quantity": item.quantity,
|
|
"unit": item.unit,
|
|
"location": item.location,
|
|
"expiry_date": item.expiry_date,
|
|
})
|
|
|
|
def get_total(ing_id):
|
|
return sum(p["quantity"] for p in pantry.get(ing_id, []))
|
|
|
|
def get_warnings(ing_id):
|
|
warnings = []
|
|
for p in pantry.get(ing_id, []):
|
|
if p["expiry_date"]:
|
|
if p["expiry_date"] < today:
|
|
warnings.append(f"EXPIRED in {p['location']}")
|
|
elif (p["expiry_date"] - today).days <= 2:
|
|
warnings.append(f"expiring soon in {p['location']}")
|
|
return warnings
|
|
|
|
recipes = []
|
|
|
|
for meta in MetaRecipe.objects.prefetch_related(
|
|
"slots__options__ingredient", "base_ingredients__ingredient"
|
|
).all():
|
|
result = {
|
|
"type": "meta_recipe",
|
|
"name": meta.name,
|
|
"gear": meta.gear_needed,
|
|
"slots": [],
|
|
"base_missing": [],
|
|
"warnings": [],
|
|
"status": "ready",
|
|
}
|
|
|
|
for base in meta.base_ingredients.all():
|
|
needed = base.quantity_per_serving * servings
|
|
available = get_total(base.ingredient_id)
|
|
ws = get_warnings(base.ingredient_id)
|
|
is_staple = PantryItem.objects.filter(ingredient=base.ingredient, is_staple=True).exists()
|
|
if available < needed and not is_staple:
|
|
result["base_missing"].append({
|
|
"ingredient": base.ingredient.name,
|
|
"needed": f"{needed} {base.unit}",
|
|
})
|
|
result["warnings"].extend([f"{base.ingredient.name}: {w}" for w in ws])
|
|
|
|
for slot in meta.slots.all():
|
|
slot_data = {
|
|
"name": slot.name,
|
|
"required": slot.required,
|
|
"available_options": [],
|
|
"missing_options": [],
|
|
}
|
|
for opt in slot.options.all():
|
|
needed = opt.quantity_per_serving * servings
|
|
available = get_total(opt.ingredient_id)
|
|
ws = get_warnings(opt.ingredient_id)
|
|
info = {
|
|
"ingredient": opt.ingredient.name,
|
|
"needed": f"{needed} {opt.unit}",
|
|
"have": f"{available} {opt.unit}",
|
|
"notes": opt.notes,
|
|
"warnings": ws,
|
|
}
|
|
if available >= needed:
|
|
slot_data["available_options"].append(info)
|
|
else:
|
|
slot_data["missing_options"].append(info)
|
|
|
|
if slot.required and not slot_data["available_options"]:
|
|
result["status"] = "missing"
|
|
|
|
result["slots"].append(slot_data)
|
|
|
|
if result["status"] == "ready" and result["base_missing"]:
|
|
result["status"] = "partial"
|
|
|
|
recipes.append(result)
|
|
|
|
# Sort: ready > partial > missing
|
|
order = {"ready": 0, "partial": 1, "missing": 2}
|
|
recipes.sort(key=lambda r: order.get(r["status"], 3))
|
|
|
|
return render(request, "kitchen/recipes.html", {
|
|
"recipes": recipes,
|
|
"active_tab": "recipes",
|
|
})
|
|
|
|
|
|
def shopping_page(request):
|
|
items = ShoppingListItem.objects.select_related("ingredient").all()
|
|
# Add section info
|
|
for item in items:
|
|
item.section = _get_section_for_item(item)
|
|
return render(request, "kitchen/shopping.html", {
|
|
"items": items,
|
|
"active_tab": "shopping",
|
|
})
|
|
|
|
|
|
def log_page(request):
|
|
entries = CookLog.objects.select_related("meta_recipe", "recipe").order_by("-date")[:50]
|
|
log_data = []
|
|
for entry in entries:
|
|
log_data.append({
|
|
"date": entry.date,
|
|
"recipe_name": entry.meta_recipe.name if entry.meta_recipe else (entry.recipe.name if entry.recipe else "Unknown"),
|
|
"rating": entry.rating,
|
|
"slot_choices": entry.slot_choices,
|
|
"notes": entry.notes,
|
|
"servings": entry.servings,
|
|
})
|
|
return render(request, "kitchen/log.html", {
|
|
"entries": log_data,
|
|
"active_tab": "log",
|
|
})
|
|
|
|
|
|
# --- HTMX Actions ---
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def pantry_add(request):
|
|
name = request.POST.get("ingredient_name", "").strip()
|
|
quantity = Decimal(request.POST.get("quantity", "0"))
|
|
unit = request.POST.get("unit", "items")
|
|
location = request.POST.get("location", "fridge")
|
|
|
|
if not name:
|
|
return HttpResponse("", status=400)
|
|
|
|
ingredient = _find_ingredient(name)
|
|
if not ingredient:
|
|
ingredient = Ingredient.objects.create(
|
|
name=name.lower(),
|
|
default_unit=unit,
|
|
)
|
|
|
|
expiry_date = None
|
|
if location == "fridge" and ingredient.shelf_life_days:
|
|
expiry_date = date.today() + timedelta(days=ingredient.shelf_life_days)
|
|
|
|
# Check for existing in same location
|
|
existing = PantryItem.objects.filter(
|
|
ingredient=ingredient, location=location, quantity__gt=0
|
|
).first()
|
|
|
|
if existing:
|
|
existing.quantity += quantity
|
|
if expiry_date:
|
|
existing.expiry_date = expiry_date
|
|
existing.save(update_fields=["quantity", "expiry_date"])
|
|
else:
|
|
PantryItem.objects.create(
|
|
ingredient=ingredient,
|
|
quantity=quantity,
|
|
unit=unit,
|
|
location=location,
|
|
expiry_date=expiry_date,
|
|
)
|
|
|
|
ctx = _pantry_context()
|
|
return render(request, "kitchen/partials/pantry_table.html", ctx)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_http_methods(["DELETE"])
|
|
def pantry_delete(request, item_id):
|
|
item = get_object_or_404(PantryItem, id=item_id)
|
|
item.delete()
|
|
ctx = _pantry_context()
|
|
return render(request, "kitchen/partials/pantry_table.html", ctx)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def pantry_move(request, item_id):
|
|
"""Move item between fridge/freezer."""
|
|
item = get_object_or_404(PantryItem, id=item_id)
|
|
target = request.POST.get("to", "fridge")
|
|
|
|
if target == "freezer":
|
|
item.location = "freezer"
|
|
item.expiry_date = None
|
|
elif target == "fridge":
|
|
item.location = "fridge"
|
|
# Default +7 days when defrosting
|
|
if item.ingredient.shelf_life_days:
|
|
item.expiry_date = date.today() + timedelta(days=item.ingredient.shelf_life_days)
|
|
else:
|
|
item.expiry_date = date.today() + timedelta(days=7)
|
|
|
|
item.save(update_fields=["location", "expiry_date"])
|
|
ctx = _pantry_context()
|
|
return render(request, "kitchen/partials/pantry_table.html", ctx)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def pantry_edit_expiry(request, item_id):
|
|
"""Show inline expiry date editor."""
|
|
item = get_object_or_404(PantryItem, id=item_id)
|
|
return render(request, "kitchen/partials/pantry_expiry_edit.html", {"item": item})
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def pantry_save_expiry(request, item_id):
|
|
"""Save edited expiry date."""
|
|
item = get_object_or_404(PantryItem, id=item_id)
|
|
expiry = request.POST.get("expiry_date")
|
|
if expiry:
|
|
item.expiry_date = expiry
|
|
else:
|
|
item.expiry_date = None
|
|
item.save(update_fields=["expiry_date"])
|
|
ctx = _pantry_context()
|
|
return render(request, "kitchen/partials/pantry_table.html", ctx)
|
|
|
|
|
|
def pantry_cancel_edit(request):
|
|
"""Cancel expiry edit — just re-render the table."""
|
|
ctx = _pantry_context()
|
|
return render(request, "kitchen/partials/pantry_table.html", ctx)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def shopping_generate(request):
|
|
"""Generate smart shopping list and return updated HTML."""
|
|
from .views import _get_section
|
|
|
|
staple_count = 0
|
|
expiring_count = 0
|
|
recipe_gap_count = 0
|
|
|
|
suggestions = []
|
|
|
|
# Staples at zero
|
|
for item in PantryItem.objects.filter(is_staple=True, quantity=0).select_related("ingredient"):
|
|
suggestions.append({
|
|
"ingredient": item.ingredient.name,
|
|
"reason": "restock staple",
|
|
"section": _get_section(item.ingredient),
|
|
"type": "staple",
|
|
})
|
|
staple_count += 1
|
|
|
|
# Expiring items
|
|
cutoff = date.today() + timedelta(days=2)
|
|
for item in PantryItem.objects.filter(
|
|
expiry_date__isnull=False, expiry_date__lte=cutoff, quantity__gt=0
|
|
).select_related("ingredient"):
|
|
suggestions.append({
|
|
"ingredient": item.ingredient.name,
|
|
"reason": f"expiring {item.expiry_date}",
|
|
"section": _get_section(item.ingredient),
|
|
"type": "expiring",
|
|
})
|
|
expiring_count += 1
|
|
|
|
# Recipe gaps — check required slots with zero available options
|
|
for meta in MetaRecipe.objects.prefetch_related(
|
|
"slots__options__ingredient", "base_ingredients__ingredient"
|
|
).all():
|
|
for slot in meta.slots.all():
|
|
if not slot.required:
|
|
continue
|
|
any_available = False
|
|
first_option = None
|
|
for opt in slot.options.all():
|
|
if not first_option:
|
|
first_option = opt
|
|
available = _get_pantry_total(opt.ingredient_id)
|
|
if available >= opt.quantity_per_serving * 2:
|
|
any_available = True
|
|
break
|
|
if not any_available and first_option:
|
|
suggestions.append({
|
|
"ingredient": first_option.ingredient.name,
|
|
"reason": f"for {meta.name} ({slot.name})",
|
|
"section": _get_section(first_option.ingredient),
|
|
"type": "recipe",
|
|
})
|
|
recipe_gap_count += 1
|
|
|
|
# Dedupe and save
|
|
seen = set()
|
|
for s in suggestions:
|
|
if s["ingredient"] not in seen:
|
|
seen.add(s["ingredient"])
|
|
ingredient = _find_ingredient(s["ingredient"])
|
|
ShoppingListItem.objects.get_or_create(
|
|
name=s["ingredient"],
|
|
checked=False,
|
|
defaults={
|
|
"ingredient": ingredient,
|
|
"reason": s["reason"],
|
|
},
|
|
)
|
|
|
|
items = ShoppingListItem.objects.select_related("ingredient").all()
|
|
for item in items:
|
|
item.section = _get_section_for_item(item)
|
|
|
|
summary = {
|
|
"total": len(set(s["ingredient"] for s in suggestions)),
|
|
"staples": staple_count,
|
|
"expiring": expiring_count,
|
|
"recipe_gaps": recipe_gap_count,
|
|
}
|
|
|
|
return render(request, "kitchen/partials/shopping_list.html", {
|
|
"items": items,
|
|
"summary": summary,
|
|
})
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def shopping_toggle(request, item_id):
|
|
item = get_object_or_404(ShoppingListItem, id=item_id)
|
|
item.checked = not item.checked
|
|
item.save(update_fields=["checked"])
|
|
|
|
items = ShoppingListItem.objects.select_related("ingredient").all()
|
|
for i in items:
|
|
i.section = _get_section_for_item(i)
|
|
return render(request, "kitchen/partials/shopping_list.html", {"items": items})
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def shopping_clear(request):
|
|
ShoppingListItem.objects.filter(checked=True).delete()
|
|
items = ShoppingListItem.objects.select_related("ingredient").all()
|
|
for item in items:
|
|
item.section = _get_section_for_item(item)
|
|
return render(request, "kitchen/partials/shopping_list.html", {"items": items})
|
|
|
|
|
|
def _get_section_for_item(item):
|
|
if item.ingredient:
|
|
tag_names = set(item.ingredient.tags.values_list("name", flat=True))
|
|
if "protein" in tag_names:
|
|
return "Protein"
|
|
if "veg" in tag_names:
|
|
return "Veg"
|
|
if "carb" in tag_names:
|
|
return "Carbs"
|
|
if "dairy" in tag_names:
|
|
return "Dairy"
|
|
return "Other"
|