add product complete with vuforia

.env.example

@@ -29,4 +29,10 @@ GOOGLE_CSE_ID=google_cse_id # for google search tool more info on langchain tool
 USDA_API_KEY=usda_api_key # for searching usda dataset
 
 # pg db url
-DATABASE_URL=postgresql://user:password@localhost/food_analyzer_db
+DATABASE_URL=postgresql://user:password@localhost/food_analyzer_db
+
+# Vuforia keys
+VUFORIA_SERVER_ACCESS_KEY=your_vuforia_server_access_key
+VUFORIA_SERVER_SECRET_KEY=your_vuforia_server_secret_key
+VUFORIA_TARGET_DATABASE_NAME=your_vuforia_target_database_name
+VUFORIA_TARGET_DATABASE_ID=your_vuforia_target_db_id

db/models.py

@@ -1,5 +1,5 @@
-from sqlalchemy import Column, Integer, String, Float, Boolean, Text, JSON, ForeignKey, DateTime
-from sqlalchemy.orm import relationship
+from sqlalchemy import Column, Integer, String, Boolean, Text, JSON, ForeignKey, DateTime
+from sqlalchemy.orm import relationship, Mapped, mapped_column
 from sqlalchemy.sql import func
 from .database import Base
 from typing import List, Optional
@@ -36,7 +36,17 @@ class IngredientSource(Base):
     # Relationships
     ingredient = relationship("Ingredient", back_populates="sources")
     
+class Marker(Base):
+    __tablename__ = "markers"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    image_name: Mapped[str]
+    vuforia_id: Mapped[str]
+    product_id: Mapped[int] = mapped_column(ForeignKey("products.id"))
+
+    product: Mapped["Product"] = relationship(back_populates="markers")
+
 class Product(Base):
+    
     __tablename__ = "products"
 
     id = Column(Integer, primary_key=True, index=True)
@@ -50,6 +60,8 @@ class Product(Base):
     nutrient_levels = Column(JSON, nullable=True)
     nutriments = Column(JSON, nullable=True)
     data_quality_warnings = Column(JSON, nullable=True)
+    
+    markers: Mapped[List["Marker"]] = relationship(back_populates="product")
 
 
 class User(Base):

routers/product.py

@@ -1,42 +1,154 @@
 import io
-from fastapi import APIRouter, File, Request, UploadFile
+from fastapi import APIRouter, Request, HTTPException
 from fastapi.responses import JSONResponse
-from typing import List
+from typing import List, Dict, Any
 from logger_manager import log_info, log_error
-from fastapi.encoders import jsonable_encoder
 from PIL import Image
 import os
-import uuid
+from services.product_service import ProductService
+from db.models import Marker, Ingredient
+from sqlalchemy.orm import Session
+from db.database import get_db
+from fastapi import Depends
+from typing import Generator
+from dotenv import load_dotenv
+import requests
+import json
+from services.ingredients import IngredientService
+
+load_dotenv()
 
 UPLOADED_IMAGES_DIR = "uploaded_images"
 if not os.path.exists(UPLOADED_IMAGES_DIR):
     os.makedirs(UPLOADED_IMAGES_DIR)
 
+
+VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY")
+VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY")
+VUFORIA_TARGET_DATABASE_NAME = os.getenv("VUFORIA_TARGET_DATABASE_NAME")
+VUFORIA_TARGET_DATABASE_ID = os.getenv("VUFORIA_TARGET_DATABASE_ID")
+
 router = APIRouter()
 
 
+def get_vuforia_auth_headers():
+    """
+    Returns the authentication headers for Vuforia API requests.
+    """
+    return {
+        "Authorization": f"VWS {VUFORIA_SERVER_ACCESS_KEY}:{VUFORIA_SERVER_SECRET_KEY}",
+        "Content-Type": "application/json",
+    }
+
+
+async def add_target_to_vuforia(image_name: str, image_path: str) -> str:
+    """
+    Adds a target to the Vuforia database and returns the Vuforia target ID.
+    """
+    log_info(f"Adding target {image_name} to Vuforia")
+
+    try:
+        with open(image_path, "rb") as image_file:
+            image_data = image_file.read()
+
+        url = f"https://vws.vuforia.com/targets"
+
+        headers = get_vuforia_auth_headers()
+        payload = {
+            "name": image_name,
+            "width": 1.0,  # Default width
+            "image": image_data.hex(),  # Convert image data to hex
+            "active_flag": True,
+        }
+
+        response = await requests.post(url, headers=headers, json=payload)
+        response_data = json.loads(response.text)
+        if response.status_code == 201:
+            log_info(
+                f"Target {image_name} added successfully with Vuforia ID: {response_data['target_id']}"
+            )
+            return response_data["target_id"]
+        else:
+            log_error(f"Failed to add target {image_name}: {response.text}")
+            raise Exception(f"Failed to add target {image_name}: {response.text}")
+    except Exception as e:
+        log_error(f"Error adding target {image_name}: {e}")
+        raise
+
+
+async def add_product_to_database(
+    product_id: int,
+    image_names: List[str],
+    db: Session,
+    product_data: Dict[str, Any],
+):
+    """
+    Adds markers for the product, or updates it if it exists.
+    """
+    try:
+        log_info(f"Adding markers to product with ID {product_id} in database")
+        product_service = ProductService(db)
+        product = product_service.get_product_by_id(product_id)
+        if not product:
+            raise Exception(f"Product with ID {product_id} not found")
+
+        # Add or update markers for the product
+        for image_name in image_names:
+            image_path = os.path.join(UPLOADED_IMAGES_DIR, image_name)
+
+            vuforia_id = await add_target_to_vuforia(image_name, image_path)
+            existing_marker = db.query(Marker).filter_by(image_name=image_name, product_id=product.id).first()
+
+            if not existing_marker:
+                marker = Marker(image_name=image_name, vuforia_id=vuforia_id, product_id=product.id)
+                db.add(marker)
+            else:
+                log_info(f"Marker {image_name} already exists for product {product_id}. Updating Vuforia ID.")
+                existing_marker.vuforia_id = vuforia_id
+
+        db.commit()
+        log_info(f"Product markers added/updated successfully in database")
+        return True
+    except Exception as e:
+        db.rollback()
+        log_error(f"Error adding/updating markers for product {product_id} in database: {e}")
+        raise HTTPException(status_code=500, detail=f"Error adding/updating markers for product {product_id}: {e}")
+
+
 @router.post("/add")
 async def create_product(
-    request: Request, image: UploadFile = File(...)
-):  # Changed to accept pre-processed image
-    log_info("Create product endpoint called")
+    request: Request, db: Session = Depends(get_db)
+):
+    """Endpoint to add a new product, its ingredients, and associated markers."""
     try:
+        log_info("Create product endpoint called")
         data = await request.json()
         print("Received data:", data)
 
-        # Extract product details from the request body
-        name = data.get("name")
-        ingredients: List[str] = data.get("ingredients")
-        image_path: str = data.get("image_path")
+        # Extract product details and data from request body
+        product_id = data.get("product_id")
+
+        image_names: List[str] = data.get("image_names")
 
-        # TODO actual adding product to DB and Vuforia Target linking 
-        print("Product Name:", name)
-        print("Ingredients:", ingredients)
-        print("Image_path:", image_path)
+        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)
         return JSONResponse(
-            {"message": "Product data and image received and processed successfully"}
+            {"message": "Product data and image processed successfully"}
         )
 
+    except HTTPException as e:
+        return JSONResponse({"error": e.detail}, status_code=e.status_code)
     except Exception as e:
-        print("Error:", e)
-        return JSONResponse({"error": str(e)}, status_code=500)
+         return JSONResponse({"error": str(e)}, status_code=500)

services/ingredients.py

@@ -4,54 +4,57 @@ from fastapi import HTTPException
 from cachetools import cached, TTLCache
 from typing import List, Dict, Any
 import requests
-from utils.fetch_data import fetch_product_data_from_api
 
 cache = TTLCache(maxsize=100, ttl=300)
 
-def get_ingredient_by_name(db: Session, name: str) -> Ingredient:
-    return db.query(Ingredient).filter(Ingredient.name == name).first()
+class IngredientService:
+    def __init__(self, db: Session):
+        self.db = db
 
-@cached(cache)
-def fetch_ingredient_data_from_api(name: str) -> Dict[str, Any]:
-    url = f"https://api.example.com/ingredients/{name}"
-    response = requests.get(url)
-    if response.status_code != 200:
-        raise HTTPException(status_code=response.status_code, detail=f"Failed to fetch data for ingredient {name}")
-    data = response.json()
-    return {
-        "nutritional_info": data.get("nutritional_info", {}),
-        "description": data.get("description", ""),
-        "origin": data.get("origin", ""),
-        "allergens": data.get("allergens", ""),
-        "vegan": data.get("vegan", False),
-        "vegetarian": data.get("vegetarian", False)
-    }
+    def get_ingredient_by_name(self, name: str) -> Ingredient:
+        return self.db.query(Ingredient).filter(Ingredient.name == name).first()
 
-def get_ingredient_data(db: Session, name: str) -> Dict[str, Any]:
-    ingredient = get_ingredient_by_name(db, name)
-    if ingredient:
+    @cached(cache)
+    def fetch_ingredient_data_from_api(self, name: str) -> Dict[str, Any]:
+        url = f"https://api.example.com/ingredients/{name}"
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail=f"Failed to fetch data for ingredient {name}")
+        data = response.json()
         return {
-            "nutritional_info": ingredient.nutritional_info,
-            "description": ingredient.description,
-            "origin": ingredient.origin,
-            "allergens": ingredient.allergens,
-            "vegan": ingredient.vegan,
-            "vegetarian": ingredient.vegetarian
+            "nutritional_info": data.get("nutritional_info", {}),
+            "description": data.get("description", ""),
+            "origin": data.get("origin", ""),
+            "allergens": data.get("allergens", ""),
+            "vegan": data.get("vegan", False),
+            "vegetarian": data.get("vegetarian", False)
         }
-    data = fetch_ingredient_data_from_api(name)
-    save_ingredient_data(db, name, data)
-    return data
 
-def save_ingredient_data(db: Session, name: str, data: Dict[str, Any]):
-    ingredient = Ingredient(
-        name=name,
-        nutritional_info=data.get("nutritional_info", {}),
-        description=data.get("description", ""),
-        origin=data.get("origin", ""),
-        allergens=data.get("allergens", ""),
-        vegan=data.get("vegan", False),
-        vegetarian=data.get("vegetarian", False)
-    )
-    db.add(ingredient)
-    db.commit()
-    db.refresh(ingredient)
+    def get_ingredient_data(self, name: str) -> Dict[str, Any]:
+        ingredient = self.get_ingredient_by_name(name)
+        if ingredient:
+            return {
+                "nutritional_info": ingredient.nutritional_info,
+                "description": ingredient.description,
+                "origin": ingredient.origin,
+                "allergens": ingredient.allergens,
+                "vegan": ingredient.vegan,
+                "vegetarian": ingredient.vegetarian
+            }
+        data = self.fetch_ingredient_data_from_api(name)
+        self.save_ingredient_data(name, data)
+        return data
+
+    def save_ingredient_data(self, name: str, data: Dict[str, Any]):
+        ingredient = Ingredient(
+            name=name,
+            nutritional_info=data.get("nutritional_info", {}),
+            description=data.get("description", ""),
+            origin=data.get("origin", ""),
+            allergens=data.get("allergens", ""),
+            vegan=data.get("vegan", False),
+            vegetarian=data.get("vegetarian", False)
+        )
+        self.db.add(ingredient)
+        self.db.commit()
+        self.db.refresh(ingredient)

services/product_service.py

@@ -0,0 +1,17 @@
+from sqlalchemy.orm import Session
+from typing import Optional
+from db.models import Product
+
+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)
+        self.db.commit()
+        self.db.refresh(product)
+        return product
+
+    def get_product_by_id(self, product_id: int) -> Optional[Product]:
+        return self.db.query(Product).filter(Product.id == product_id).first()