Feat/rezeptanzeige

project/backend/core/Models.py

@@ -50,4 +50,5 @@ class IngredientSearch(BaseModel):
 
 class RecipeSearchRequest(BaseModel):
     zutaten: list[IngredientSearch]
-    servings: int
+    servings: int = 1
+    index: int = 0

project/backend/dao/IngredientDAO.py

@@ -35,19 +35,20 @@ def getAllIngredients() -> list[dict]:
 
 
 def getIngredientsForRecipe(rid: int) -> list[Ingredient]:
-    """Gibt die Zutaten eines Rezepts als Ingredient-Objekte zurück."""
     with getDB() as con:
         cur = con.cursor()
-        cur.execute(
-            """
-            SELECT Ingredient.name, Exists_from.amount
-            FROM Ingredient
-            JOIN Exists_from ON Ingredient.id = Exists_from.zid
-            WHERE Exists_from.rid = ?
-            """,
-            (rid,),
-        )
-        return [Ingredient(row["name"], row["amount"]) for row in cur.fetchall()]
+        cur.execute("""
+                    SELECT Ingredient.name, Exists_from.amount, Ingredient.amountType
+                    FROM Ingredient
+                             JOIN Exists_from ON Ingredient.id = Exists_from.zid
+                    WHERE Exists_from.rid = ?
+                    """, (rid,))
+        ingredients = []
+        for row in cur.fetchall():
+            ing = Ingredient(row["name"], row["amount"])
+            ing.setAmountType(row["amountType"])
+            ingredients.append(ing)
+        return ingredients
 
 
 def incrementIngredientUsage(AccountID: int, name: str, unit: str | None) -> None:

project/backend/dao/RecipeDAO.py

@@ -76,3 +76,57 @@ def getAllocatedRecipes(name: str) -> list[dict]:
             (name,),
         )
         return [dict(row) for row in cur.fetchall()]
+def getAllRecipesPaginated(offset: int) -> list[dict]:
+    with getDB() as con:
+        cur = con.cursor()
+        cur.execute("""
+                    SELECT r.id, r.name, r.description
+                    FROM Recipe r
+                    ORDER BY r.name
+                        LIMIT 12 OFFSET ?
+                    """, (offset,))
+        return [dict(row) for row in cur.fetchall()]
+
+
+def searchRecipesByIngredients(likeConditions: str, likeParams: list, offset: int) -> list[dict]:
+    with getDB() as con:
+        cur = con.cursor()
+        cur.execute(f"""
+            SELECT
+                r.id, r.name, r.description,
+                COUNT(DISTINCT CASE WHEN {likeConditions} THEN i.id END) AS matching,
+                COUNT(DISTINCT ef.zid) AS total
+            FROM Recipe r
+            LEFT JOIN Exists_from ef ON ef.rid = r.id
+            LEFT JOIN Ingredient i ON i.id = ef.zid
+            GROUP BY r.id
+            ORDER BY matching DESC, r.name
+            LIMIT 12 OFFSET ?
+        """, (*likeParams, offset))
+        return [dict(row) for row in cur.fetchall()]
+
+def getAllRecipesWithIngredients() -> list[dict]:
+    with getDB() as con:
+        cur = con.cursor()
+        cur.execute("""
+                    SELECT r.id, r.name, r.description,
+                           i.name as ing_name, ef.amount, i.amountType
+                    FROM Recipe r
+                             LEFT JOIN Exists_from ef ON ef.rid = r.id
+                             LEFT JOIN Ingredient i ON i.id = ef.zid
+                    ORDER BY r.id
+                    """)
+        rows = cur.fetchall()
+
+    recipes = {}
+    for row in rows:
+        rid = row["id"]
+        if rid not in recipes:
+            recipes[rid] = {"id": rid, "name": row["name"], "description": row["description"], "ingredients": []}
+        if row["ing_name"]:
+            recipes[rid]["ingredients"].append({
+                "name": row["ing_name"],
+                "amount": row["amount"],
+                "amountType": row["amountType"]
+            })
+    return list(recipes.values())

project/backend/domain/recipe.py

@@ -1,5 +1,6 @@
 from domain.ingredient import Ingredient
-
+from dao.RecipeDAO import addRecipe, addIngredientToRecipe
+from dao.IngredientDAO import getIngredientByName
 
 class Recipe:
     def __init__(self, name: str, ingredients: list[Ingredient], description: str):
@@ -12,6 +13,16 @@ def __init__(self, name: str, ingredients: list[Ingredient], description: str):
         self.__countPersons = 1
         self.__matching = 0
 
+    def saveInDB(self) -> bool:
+        rid = addRecipe(self.__name, self.__description, None)
+        for ingredient in self.__ingredients:
+            result = getIngredientByName(ingredient.getName())
+            if not result:
+                return False
+            zid = result["id"]
+            addIngredientToRecipe(zid, rid, ingredient.getAmount())
+        return True
+
     def getName(self) -> str:
         return self.__name
 

project/backend/routes/RecipeRoutes.py

@@ -9,39 +9,63 @@
 from core.Auth import getCurrentUser
 from dao import AccountDAO, IngredientDAO
 from core.Models import User, RecipeSearchRequest
+from domain.ingredient import Ingredient
+from services.RecipeSUCUK import findRecipes
 
 router = APIRouter()
 
 
 @router.post("/recipes/search")
 async def searchRecipes(
-    body: RecipeSearchRequest,
-    currentUser: Annotated[User, Depends(getCurrentUser)],
+        body: RecipeSearchRequest,
+        currentUser: Annotated[User, Depends(getCurrentUser)],
 ):
-    """Sucht Rezepte basierend auf den übergebenen Zutaten und trackt die Nutzung."""
     account = AccountDAO.getAccountByEmail(currentUser.email)
     if account is None:
         raise HTTPException(status_code=404, detail="Account nicht gefunden")
 
     for zutat in body.zutaten:
         IngredientDAO.incrementIngredientUsage(account["id"], zutat.name, zutat.unit)
 
+    # Echte Rezept-Suche
+    ingredients = [Ingredient(z.name, z.amount) for z in body.zutaten]
+    index = getattr(body, "index", 0)
+    recipes = findRecipes(ingredients, body.index)
+
     topRows = IngredientDAO.getTopIngredients(account["id"], limit=5)
     topIngredients = [
         {"name": r["displayName"], "unit": r["lastUnit"]} for r in topRows
     ]
 
-    # TODO: eigentliche Rezept-Suche implementieren
-    return {"rezepte": [], "topIngredients": topIngredients}
+    return {
+        "rezepte": [
+            {
+                "name": r.getName(),
+                "description": r.getDescription(),
+                "rating": r.getRating(),
+                "duration": r.getDuration() if hasattr(r, "getDuration") else "",
+                "matching": r.getMatching(),
+                "ingredients": [
+                    {
+                        "name": i.getName(),
+                        "amount": i.getAmount(),
+                        "unit": i.getAmountType() or ""
+                    }
+                    for i in r.getIngredients()
+                ]
+            }
+            for r in recipes
+        ],
+        "topIngredients": topIngredients
+    }
 
 
 @router.get("/ingredients/top")
 async def getTopIngredientsForUser(
-    response: Response,
-    currentUser: Annotated[User, Depends(getCurrentUser)],
-    limit: int = 5,
+        response: Response,
+        currentUser: Annotated[User, Depends(getCurrentUser)],
+        limit: int = 5,
 ):
-    """Liefert die meistgenutzten Zutaten des aktuellen Users."""
     account = AccountDAO.getAccountByEmail(currentUser.email)
     if account is None:
         raise HTTPException(status_code=404, detail="Account nicht gefunden")
@@ -52,4 +76,4 @@ async def getTopIngredientsForUser(
     rows = IngredientDAO.getTopIngredients(account["id"], limit=limit)
     return {
         "ingredients": [{"name": r["displayName"], "unit": r["lastUnit"]} for r in rows]
-    }
+    }

project/backend/seed.py

@@ -0,0 +1,75 @@
+import json
+import re
+import sys
+import os
+
+sys.path.insert(0, '/app')
+os.chdir('/app')
+
+from dao.RecipeDAO import addRecipe, addIngredientToRecipe
+from dao.IngredientDAO import addIngredient, getIngredientByName
+from core.Database import getConnection, initDB
+
+def getOrCreateIngredient(name: str) -> int:
+    existing = getIngredientByName(name)
+    if existing:
+        return existing["id"]
+    return addIngredient(name, "mixed")
+
+def extractIngredientName(raw: str) -> str:
+    """Extrahiert den Zutatennamen aus einem String wie '41 g Butter' → 'Butter'"""
+    # Entferne führende Mengenangaben: Zahlen, Einheiten, Sonderzeichen
+    cleaned = re.sub(r'^[\d\s.,/]+', '', raw).strip()
+    # Entferne bekannte Einheiten am Anfang
+    units = ['g ', 'kg ', 'ml ', 'l ', 'EL ', 'TL ', 'Stück ', 'Prise ',
+             'tsp ', 'tbsp ', 'cup ', 'oz ', 'lb ', 'cl ']
+    for unit in units:
+        if cleaned.startswith(unit):
+            cleaned = cleaned[len(unit):].strip()
+    # Alles nach Klammer oder Komma abschneiden
+    cleaned = re.split(r'[,(]', cleaned)[0].strip()
+    # Maximal 50 Zeichen
+    return cleaned[:50].strip()
+
+def main():
+    initDB()
+
+    with open('/app/recipes_imported.json', 'r', encoding='utf-8') as f:
+        recipes = json.load(f)
+
+    print(f"Lade {len(recipes)} Rezepte...")
+    success = 0
+    skipped = 0
+
+    for recipe in recipes:
+        name = recipe.get("Name", "").strip()
+        description = recipe.get("Description", "").strip()
+        rawIngredients = recipe.get("Ingredients", [])
+
+        if not name:
+            continue
+
+        try:
+            rid = addRecipe(name, description)
+        except Exception as e:
+            skipped += 1
+            continue
+
+        for rawIng in rawIngredients:
+            ingName = extractIngredientName(rawIng)
+            if not ingName:
+                continue
+            try:
+                zid = getOrCreateIngredient(ingName)
+                addIngredientToRecipe(zid, rid, 1.0)
+            except Exception:
+                pass
+
+        success += 1
+        if success % 50 == 0:
+            print(f"  {success} Rezepte verarbeitet...")
+
+    print(f"Fertig! {success} Rezepte importiert, {skipped} übersprungen.")
+
+if __name__ == "__main__":
+    main()

project/backend/services/RecipeSUCUK.py

@@ -4,7 +4,8 @@
 """
 
 from domain.recipe import Recipe
-from dao import RecipeDAO, IngredientDAO
+from domain.ingredient import Ingredient
+from dao import IngredientDAO, RecipeDAO
 
 
 def findRecipes(ingredients: list, index: int) -> list[Recipe]:
@@ -17,7 +18,6 @@ def findRecipes(ingredients: list, index: int) -> list[Recipe]:
     recipes.sort(key=lambda r: r.getRating(), reverse=True)
     return recipes[12 * index : 12 * (index + 1)]
 
-
 def getMatchingRecipeNames(searchTerm: str) -> list[Recipe]:
     """Gibt Rezepte zurück, deren Name den Suchbegriff enthält."""
     searchTerm = searchTerm.lower()
@@ -31,17 +31,21 @@ def getMatchingRecipeNames(searchTerm: str) -> list[Recipe]:
 
 
 def _initRecipes() -> list[Recipe]:
-    return [
-        Recipe(
-            r["name"], IngredientDAO.getIngredientsForRecipe(r["id"]), r["description"]
-        )
-        for r in RecipeDAO.getAllRecipes()
-    ]
+    rows = RecipeDAO.getAllRecipesWithIngredients()
+    result = []
+    for r in rows:
+        ingredients = []
+        for i in r["ingredients"]:
+            ing = Ingredient(i["name"], i["amount"])
+            ing.setAmountType(i["amountType"])
+            ingredients.append(ing)
+        result.append(Recipe(r["name"], ingredients, r["description"] or ""))
+    return result
 
 
 def _scoreRecipes(recipes: list[Recipe], ingredient) -> None:
     for recipe in recipes:
         for recipeIngredient in recipe.getIngredients():
-            if recipeIngredient.getName() == ingredient.getName():
+            if ingredient.getName() in recipeIngredient.getName():
                 recipe.incrementMatching()
-                recipe.setRating(recipe.getMatching() / len(recipe.getIngredients()))
+                recipe.setRating(recipe.getMatching() / len(recipe.getIngredients()))