product model update

db/models.py

@@ -51,16 +51,21 @@ class Product(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     product_name = Column(String, nullable=False)
-    generic_name = Column(String, nullable=True)
-    brands = Column(String, nullable=True)
     ingredients = Column(JSON, nullable=True)
-    ingredients_text = Column(String, nullable=True)
     ingredients_analysis = Column(JSON, nullable=True)
-    nutriscore = Column(JSON, nullable=True)
-    nutrient_levels = Column(JSON, nullable=True)
-    nutriments = Column(JSON, nullable=True)
-    data_quality_warnings = Column(JSON, nullable=True)
+    overall_safety_score = Column(Integer, nullable=True)
+    suitable_diet_types = Column(String, nullable=True)
+    allergy_warnings = Column(JSON, nullable=True)
+    usage_recommendations = Column(String, nullable=True)
+    health_insights = Column(JSON, nullable=True)
+    ingredient_interactions = Column(JSON, nullable=True)
+    key_takeaway = Column(String, nullable=True)
+    ingredients_count = Column(Integer, nullable=True)
+    user_id = Column(Integer, nullable=True)
+    timestamp = Column(DateTime, nullable=True)
+    ingredient_ids= Column(JSON, nullable=True)
     
+    data_quality_warnings = Column(JSON, nullable=True)
     markers: Mapped[List["Marker"]] = relationship(back_populates="product")
 
 

db/repositories.py

@@ -2,8 +2,10 @@ from sqlalchemy.orm import Session
 from sqlalchemy import cast, or_, String
 from sqlalchemy.dialects.postgresql import JSONB
 from . import models
-from interfaces.ingredientModels import IngredientAnalysisResult
-
+from interfaces.ingredientModels import IngredientAnalysisResult 
+from interfaces.productModels import ProductCreate
+from datetime import datetime
+    
 class IngredientRepository:
     def __init__(self, db: Session):
         self.db = db
@@ -87,4 +89,28 @@ class IngredientRepository:
             self.db.commit()
             self.db.refresh(db_ingredient)
             return db_ingredient
-        return None
+        return None
+class ProductRepository:
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def add_product(self, product_create: ProductCreate):
+        db_product = models.Product(
+            product_name=product_create.product_name,
+            ingredients=product_create.ingredients,
+            overall_safety_score=product_create.overall_safety_score,
+            suitable_diet_types=product_create.suitable_diet_types,
+            allergy_warnings=product_create.allergy_warnings,
+            usage_recommendations=product_create.usage_recommendations,
+            health_insights=product_create.health_insights,
+            ingredient_interactions=product_create.ingredient_interactions,
+            key_takeaway=product_create.key_takeaway,
+            ingredients_count=product_create.ingredients_count,
+            user_id=product_create.user_id,
+            timestamp=product_create.timestamp,
+            ingredient_ids=product_create.ingredient_ids
+        )
+        self.db.add(db_product)
+        self.db.commit()
+        self.db.refresh(db_product)
+        return db_product

interfaces/productModels.py

@@ -1,6 +1,24 @@
-from typing import List
+from typing import List, Dict
 from pydantic import BaseModel
+from datetime import datetime
 
 # Add this class to define the request body structure
 class ProductIngredientsRequest(BaseModel):
     ingredients: List[str]
+
+class ProductCreate(BaseModel):
+    product_name: str
+    ingredients: List[str]
+    overall_safety_score: int
+    suitable_diet_types: str
+    allergy_warnings: List[str]
+    usage_recommendations: str
+    health_insights: Dict[str, List[str]]
+    ingredient_interactions: List[str]
+    key_takeaway: str
+    ingredients_count: int
+    user_id: int
+    timestamp: datetime
+    ingredient_ids: List[int]
+
+

routers/product.py

@@ -6,10 +6,12 @@ from logger_manager import log_info, log_error
 from PIL import Image
 import os
 from services.product_service import ProductService
-from db.models import Marker, Ingredient
+from db.models import Marker
 from sqlalchemy.orm import Session
 from db.database import get_db
 from fastapi import Depends
+from db.repositories import ProductRepository, IngredientRepository
+from interfaces.productModels import ProductCreate
 from typing import Generator
 from dotenv import load_dotenv
 import requests
@@ -126,26 +128,46 @@ async def create_product(
         print("Received data:", data)
 
         # Extract product details and data from request body
-        product_id = data.get("product_id")
-
+        
         image_names: List[str] = data.get("image_names")
+        
+        # Parse ProductCreate model from data
+        product_create_data = ProductCreate(
+            product_name=data.get("name"),
+            ingredients=data.get("ingredients"),
+            overall_safety_score=data.get("overall_safety_score"),
+            suitable_diet_types=data.get("suitable_diet_types"),
+            allergy_warnings=data.get("allergy_warnings"),
+            usage_recommendations=data.get("usage_recommendations"),
+            health_insights=data.get("health_insights"),
+            ingredient_interactions=data.get("ingredient_interactions"),
+            key_takeaway=data.get("key_takeaway"),
+            ingredients_count=data.get("ingredients_count"),
+            user_id=data.get("user_id"),
+            timestamp=data.get("timestamp"),
+            ingredient_ids=[]  
+        )
 
-        product_data = {
-            "ingredients_text": data.get("ingredients_text", ""),
-            "brands": data.get("brands", ""),
-            "generic_name": data.get("generic_name", ""),
-            "nutriscore": data.get("nutriscore", None),
-            "nutrient_levels": data.get("nutrient_levels", None),
-            "nutriments": data.get("nutriments", None),
-            "data_quality_warnings": data.get("data_quality_warnings", None),
-        }
-        product_service = ProductService(db)
-        if not product_id:
-            product = product_service.add_product(data.get("name"), product_data["ingredients_text"])
-            product_id = product.id
-        await add_product_to_database(product_id, image_names, db, product_data)
+        # Find ingredients and append their IDs
+        ingredient_repo = IngredientRepository(db)
+        for ingredient_name in product_create_data.ingredients:
+            ingredient = ingredient_repo.get_ingredient_by_name(ingredient_name)
+            if ingredient:
+                product_create_data.ingredient_ids.append(ingredient.id)
+
+        # use repository to add product
+        product_repo = ProductRepository(db)
+        product = product_repo.add_product(product_create_data)
+        product_id=product.id
+        await add_product_to_database(product_id, image_names, db, data)
         return JSONResponse(
-            {"message": "Product data and image processed successfully"}
+            {
+                 "message": "Product data and image processed successfully",
+                "product_id":product_id,
+                 "data":data,
+                "product_data": product_create_data.model_dump()
+                
+             }
         )
 
     except HTTPException as e:

services/ingredientFinderAgent.py

@@ -681,6 +681,7 @@ class IngredientInfoAgentLangGraph:
         # Run each tool directly in sequence and collect results
         logger.info(f"Searching local database for {ingredient}")
         result = search_local_db.invoke(ingredient)
+
         if result.get("found", False):
             sources_data.append(result)
             logger.info(f"Local DB found data for {ingredient}")
@@ -716,20 +717,10 @@ class IngredientInfoAgentLangGraph:
             sources_data.append(result)
             logger.info(f"PubChem found data for {ingredient}")
         
-        # Create a state for analysis
-        state = {
-            "ingredient": ingredient,
-            "sources_data": sources_data,
-            "result": None,
-            "status": "ready_for_analysis",
-            "analysis_done": False,
-            "local_db_checked": True,
-            "web_search_done": True,
-            "wikipedia_checked": True,
-            "open_food_facts_checked": True,
-            "usda_checked": True,
-            "pubchem_checked": True
-        }
+        state = IngredientState(ingredient=ingredient,
+                                 sources_data=sources_data,
+                                 status="ready_for_analysis"
+                                 )
         
         # Run the analysis with the collected data
         final_state = analyze_ingredient(state)
@@ -737,6 +728,7 @@ class IngredientInfoAgentLangGraph:
         # Extract the result or create a default
         if final_state.get("result"):
             logger.info(f"Analysis complete for {ingredient}")
+
             return IngredientAnalysisResult(**final_state["result"])
         else:
             logger.info(f"No result in final state for {ingredient}, returning default")

services/product_service.py

@@ -1,14 +1,16 @@
 from sqlalchemy.orm import Session
 from typing import Optional
 from db.models import Product
+from interfaces.productModels import ProductCreate
 
 class ProductService:
     def __init__(self, db: Session):
         self.db = db
 
-    def add_product(self, name: str, ingredients_text: str) -> Product:
-        product = Product(product_name=name, ingredients_text=ingredients_text)
-        self.db.add(product)
+    def add_product(self, product_create: ProductCreate) -> Product:
+        product = Product(**product_create.model_dump())
+        
+        self.db.add(product)        
         self.db.commit()
         self.db.refresh(product)
         return product