router update

routers/analysis.py

@@ -1,36 +1,69 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from typing import List, Dict, Any
-from database import get_db
-from models.user import User
-from models.ingredient import Ingredient
-from models.product import Product
-from services.analysis_agent import analyze_ingredients, provide_personalized_recommendations
+from interfaces.ingredientModels import IngredientAnalysisResult, IngredientRequest
 from services.auth_service import get_current_user
-from services.ai_agent import process_data
+from logger_manager import log_info, log_error,logger
+from db.database import get_db
+from db.repositories import IngredientRepository
+
+from services.ingredientFinderAgent import IngredientInfoAgentLangGraph
+
 
 router = APIRouter()
 
-@router.post("/analyze_ingredients")
-def analyze_ingredients_endpoint(ingredients: List[Dict[str, Any]], db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    try:
-        analysis_results = analyze_ingredients(db, ingredients, current_user.id)
-        return analysis_results
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+def ingredient_db_to_pydantic(db_ingredient):
+    """Convert a database ingredient model to a Pydantic model."""
+    return IngredientAnalysisResult(
+        name=db_ingredient.name,
+        alternate_names=db_ingredient.alternate_names or [],
+        is_found=True,
+        safety_rating=db_ingredient.safety_rating or 5,
+        description=db_ingredient.description or "No description available",
+        health_effects=db_ingredient.health_effects or ["Unknown"],
+        details_with_source=[source.data for source in db_ingredient.sources]
+    )
 
-@router.get("/personalized_recommendations")
-def personalized_recommendations_endpoint(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    try:
-        recommendations = provide_personalized_recommendations(db, current_user.id)
-        return recommendations
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
 
-@router.post("/process_product")
-def process_product_endpoint(barcode: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+# process single ingredient 
+@router.post("/process_ingredient", response_model=IngredientAnalysisResult)
+async def process_ingredient_endpoint(request: IngredientRequest, db: Session = Depends(get_db)):
     try:
-        product_data = process_data(db, barcode)
-        return product_data
+        logger.info(f"Received request to process ingredient: {request.name}")
+        
+        # Check if we already have this ingredient in the database
+        repo = IngredientRepository(db)
+        db_ingredient = repo.get_ingredient_by_name(request.name)
+        
+        if db_ingredient:
+            logger.info(f"Found existing ingredient in database: {request.name}")
+            # Convert DB model to Pydantic model
+            # (This would need a function to correctly map the data)
+            return ingredient_db_to_pydantic(db_ingredient)
+        
+        # If not in database, get from agent
+        ingredient_finder = IngredientInfoAgentLangGraph()
+        result = ingredient_finder.process_ingredient(request.name)
+        
+        # Save to database
+        repo.create_ingredient(result)
+        logger.info(f"Saved new ingredient to database: {request.name}")
+        
+        return result
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Error processing ingredient: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+
+# @router.post("/process_ingredients")
+# def process_ingredients_endpoint(ingredients: List[str], db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+#     log_info("process_ingredients_endpoint called")
+#     print(ingredients)
+#     try:
+#         # result = process_ingredients(db, ingredients, current_user.id)
+#         result = None
+#         log_info("process_ingredients_endpoint completed successfully")
+#         return result
+#     except Exception as e:
+#         log_error(f"Error in process_ingredients_endpoint: {str(e)}")
+#         raise HTTPException(status_code=500, detail=str(e))

routers/auth.py

@@ -1,46 +1,58 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from fastapi.security import OAuth2PasswordRequestForm
-from pydantic import BaseModel
-from database import get_db
+from db.database import get_db
 from services.auth_service import authenticate_user, create_access_token, create_user, get_current_active_user
 from datetime import timedelta
+from db.models import User
+from logger_manager import log_info, log_error
+from interfaces.authModels import UserCreate,UserResponse,Token
 
 router = APIRouter()
 
-class UserCreate(BaseModel):
-    username: str
-    email: str
-    password: str
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
 
 @router.post("/register", response_model=Token)
 def register(user: UserCreate, db: Session = Depends(get_db)):
-    db_user = create_user(db, user.username, user.email, user.password)
-    access_token_expires = timedelta(minutes=30)
-    access_token = create_access_token(
-        data={"sub": db_user.username}, expires_delta=access_token_expires
-    )
-    return {"access_token": access_token, "token_type": "bearer"}
+    log_info("Register endpoint called")
+    try:
+        db_user = create_user(db, user.username, user.email, user.password)
+        access_token_expires = timedelta(minutes=30)
+        access_token = create_access_token(
+            data={"sub": db_user.username}, expires_delta=access_token_expires
+        )
+        log_info("User registered successfully")
+        return {"access_token": access_token, "token_type": "bearer"}
+    except Exception as e:
+        log_error(f"Error in register endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @router.post("/login", response_model=Token)
 def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
-    user = authenticate_user(db, form_data.username, form_data.password)
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Incorrect username or password",
-            headers={"WWW-Authenticate": "Bearer"},
+    log_info("Login endpoint called")
+    try:
+        user = authenticate_user(db, form_data.username, form_data.password)
+        if not user:
+            log_error("Incorrect username or password")
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Incorrect username or password",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        access_token_expires = timedelta(weeks=4)
+        access_token = create_access_token(
+            data={"sub": user.username}, expires_delta=access_token_expires
         )
-    access_token_expires = timedelta(minutes=30)
-    access_token = create_access_token(
-        data={"sub": user.username}, expires_delta=access_token_expires
-    )
-    return {"access_token": access_token, "token_type": "bearer"}
+        log_info("User logged in successfully")
+        return {"access_token": access_token, "token_type": "bearer"}
+    except Exception as e:
+        log_error(f"Error in login endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
-@router.get("/users/me", response_model=UserCreate)
-def read_users_me(current_user: UserCreate = Depends(get_current_active_user)):
-    return current_user
+@router.get("/user", response_model=UserResponse)
+def read_users_me(current_user: User = Depends(get_current_active_user)):
+    log_info("Read users/me endpoint called")
+    try:
+        return current_user
+    except Exception as e:
+        log_error(f"Error in read_users_me endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")

routers/history.py

@@ -1,9 +1,10 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from pydantic import BaseModel
-from database import get_db
+from db.database import get_db
 from services.scan_history import record_scan, get_scan_history
-from models.scan_history import ScanHistory
+from db.models import ScanHistory
+from logger_manager import log_info, log_error
 
 router = APIRouter()
 
@@ -19,12 +20,25 @@ class ScanHistoryResponse(BaseModel):
 
 @router.post("/scan", response_model=ScanHistoryResponse)
 def create_scan(scan: ScanHistoryCreate, db: Session = Depends(get_db)):
-    scan_entry = record_scan(db, scan.user_id, scan.product_id)
-    return scan_entry
+    log_info("Create scan endpoint called")
+    try:
+        scan_entry = record_scan(db, scan.user_id, scan.product_id)
+        log_info("Scan recorded successfully")
+        return scan_entry
+    except Exception as e:
+        log_error(f"Error in create_scan endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
-@router.get("/history/{user_id}", response_model=list[ScanHistoryResponse])
+@router.get("/scan/{user_id}", response_model=list[ScanHistoryResponse])
 def read_scan_history(user_id: int, db: Session = Depends(get_db)):
-    scan_history = get_scan_history(db, user_id)
-    if not scan_history:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Scan history not found")
-    return scan_history
+    log_info("Read scan history endpoint called")
+    try:
+        scan_history = get_scan_history(db, user_id)
+        if not scan_history:
+            log_error("Scan history not found")
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Scan history not found")
+        log_info("Scan history retrieved successfully")
+        return scan_history
+    except Exception as e:
+        log_error(f"Error in read_scan_history endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")