rename grocery to product

backend/main.py

@@ -10,8 +10,8 @@ from database import engine, get_db
 models.Base.metadata.create_all(bind=engine)
 
 app = FastAPI(
-    title="Grocery Tracker API",
-    description="API for tracking grocery prices and shopping events",
+    title="Product Tracker API",
+    description="API for tracking product prices and shopping events",
     version="1.0.0"
 )
 
@@ -25,22 +25,22 @@ app.add_middleware(
 )
 
 def build_shopping_event_response(event: models.ShoppingEvent, db: Session) -> schemas.ShoppingEventResponse:
-    """Build a shopping event response with groceries from the association table"""
-    # Get groceries with their event-specific data
-    grocery_data = db.execute(
+    """Build a shopping event response with products from the association table"""
+    # Get products with their event-specific data
+    product_data = db.execute(
         text("""
-            SELECT g.id, g.name, g.category, g.organic, g.weight, g.weight_unit,
-                   seg.amount, seg.price
-            FROM groceries g
-            JOIN shopping_event_groceries seg ON g.id = seg.grocery_id
-            WHERE seg.shopping_event_id = :event_id
+            SELECT p.id, p.name, p.category, p.organic, p.weight, p.weight_unit,
+                   sep.amount, sep.price
+            FROM products p
+            JOIN shopping_event_products sep ON p.id = sep.product_id
+            WHERE sep.shopping_event_id = :event_id
         """),
         {"event_id": event.id}
     ).fetchall()
     
-    # Convert to GroceryWithEventData objects
-    groceries_with_data = [
-        schemas.GroceryWithEventData(
+    # Convert to ProductWithEventData objects
+    products_with_data = [
+        schemas.ProductWithEventData(
             id=row.id,
             name=row.name,
             category=row.category,
@@ -50,7 +50,7 @@ def build_shopping_event_response(event: models.ShoppingEvent, db: Session) -> s
             amount=row.amount,
             price=row.price
         )
-        for row in grocery_data
+        for row in product_data
     ]
     
     return schemas.ShoppingEventResponse(
@@ -61,58 +61,58 @@ def build_shopping_event_response(event: models.ShoppingEvent, db: Session) -> s
         notes=event.notes,
         created_at=event.created_at,
         shop=event.shop,
-        groceries=groceries_with_data
+        products=products_with_data
     )
 
 # Root endpoint
 @app.get("/")
 def read_root():
-    return {"message": "Grocery Tracker API", "version": "1.0.0"}
+    return {"message": "Product Tracker API", "version": "1.0.0"}
 
-# Grocery endpoints
-@app.post("/groceries/", response_model=schemas.Grocery)
-def create_grocery(grocery: schemas.GroceryCreate, db: Session = Depends(get_db)):
-    db_grocery = models.Grocery(**grocery.dict())
-    db.add(db_grocery)
+# Product endpoints
+@app.post("/products/", response_model=schemas.Product)
+def create_product(product: schemas.ProductCreate, db: Session = Depends(get_db)):
+    db_product = models.Product(**product.dict())
+    db.add(db_product)
     db.commit()
-    db.refresh(db_grocery)
-    return db_grocery
+    db.refresh(db_product)
+    return db_product
 
-@app.get("/groceries/", response_model=List[schemas.Grocery])
-def read_groceries(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    groceries = db.query(models.Grocery).offset(skip).limit(limit).all()
-    return groceries
+@app.get("/products/", response_model=List[schemas.Product])
+def read_products(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    products = db.query(models.Product).offset(skip).limit(limit).all()
+    return products
 
-@app.get("/groceries/{grocery_id}", response_model=schemas.Grocery)
-def read_grocery(grocery_id: int, db: Session = Depends(get_db)):
-    grocery = db.query(models.Grocery).filter(models.Grocery.id == grocery_id).first()
-    if grocery is None:
-        raise HTTPException(status_code=404, detail="Grocery not found")
-    return grocery
+@app.get("/products/{product_id}", response_model=schemas.Product)
+def read_product(product_id: int, db: Session = Depends(get_db)):
+    product = db.query(models.Product).filter(models.Product.id == product_id).first()
+    if product is None:
+        raise HTTPException(status_code=404, detail="Product not found")
+    return product
 
-@app.put("/groceries/{grocery_id}", response_model=schemas.Grocery)
-def update_grocery(grocery_id: int, grocery_update: schemas.GroceryUpdate, db: Session = Depends(get_db)):
-    grocery = db.query(models.Grocery).filter(models.Grocery.id == grocery_id).first()
-    if grocery is None:
-        raise HTTPException(status_code=404, detail="Grocery not found")
+@app.put("/products/{product_id}", response_model=schemas.Product)
+def update_product(product_id: int, product_update: schemas.ProductUpdate, db: Session = Depends(get_db)):
+    product = db.query(models.Product).filter(models.Product.id == product_id).first()
+    if product is None:
+        raise HTTPException(status_code=404, detail="Product not found")
     
-    update_data = grocery_update.dict(exclude_unset=True)
+    update_data = product_update.dict(exclude_unset=True)
     for field, value in update_data.items():
-        setattr(grocery, field, value)
+        setattr(product, field, value)
     
     db.commit()
-    db.refresh(grocery)
-    return grocery
+    db.refresh(product)
+    return product
 
-@app.delete("/groceries/{grocery_id}")
-def delete_grocery(grocery_id: int, db: Session = Depends(get_db)):
-    grocery = db.query(models.Grocery).filter(models.Grocery.id == grocery_id).first()
-    if grocery is None:
-        raise HTTPException(status_code=404, detail="Grocery not found")
+@app.delete("/products/{product_id}")
+def delete_product(product_id: int, db: Session = Depends(get_db)):
+    product = db.query(models.Product).filter(models.Product.id == product_id).first()
+    if product is None:
+        raise HTTPException(status_code=404, detail="Product not found")
     
-    db.delete(grocery)
+    db.delete(product)
     db.commit()
-    return {"message": "Grocery deleted successfully"}
+    return {"message": "Product deleted successfully"}
 
 # Shop endpoints
 @app.post("/shops/", response_model=schemas.Shop)
@@ -178,19 +178,19 @@ def create_shopping_event(event: schemas.ShoppingEventCreate, db: Session = Depe
     db.commit()
     db.refresh(db_event)
     
-    # Add groceries to the event
-    for grocery_item in event.groceries:
-        grocery = db.query(models.Grocery).filter(models.Grocery.id == grocery_item.grocery_id).first()
-        if grocery is None:
-            raise HTTPException(status_code=404, detail=f"Grocery with id {grocery_item.grocery_id} not found")
+    # Add products to the event
+    for product_item in event.products:
+        product = db.query(models.Product).filter(models.Product.id == product_item.product_id).first()
+        if product is None:
+            raise HTTPException(status_code=404, detail=f"Product with id {product_item.product_id} not found")
         
         # Insert into association table
         db.execute(
-            models.shopping_event_groceries.insert().values(
+            models.shopping_event_products.insert().values(
                 shopping_event_id=db_event.id,
-                grocery_id=grocery_item.grocery_id,
-                amount=grocery_item.amount,
-                price=grocery_item.price
+                product_id=product_item.product_id,
+                amount=product_item.amount,
+                price=product_item.price
             )
         )
     
@@ -228,26 +228,26 @@ def update_shopping_event(event_id: int, event_update: schemas.ShoppingEventCrea
     event.total_amount = event_update.total_amount
     event.notes = event_update.notes
     
-    # Remove existing grocery associations
+    # Remove existing product associations
     db.execute(
-        models.shopping_event_groceries.delete().where(
-            models.shopping_event_groceries.c.shopping_event_id == event_id
+        models.shopping_event_products.delete().where(
+            models.shopping_event_products.c.shopping_event_id == event_id
         )
     )
     
-    # Add new grocery associations
-    for grocery_item in event_update.groceries:
-        grocery = db.query(models.Grocery).filter(models.Grocery.id == grocery_item.grocery_id).first()
-        if grocery is None:
-            raise HTTPException(status_code=404, detail=f"Grocery with id {grocery_item.grocery_id} not found")
+    # Add new product associations
+    for product_item in event_update.products:
+        product = db.query(models.Product).filter(models.Product.id == product_item.product_id).first()
+        if product is None:
+            raise HTTPException(status_code=404, detail=f"Product with id {product_item.product_id} not found")
         
         # Insert into association table
         db.execute(
-            models.shopping_event_groceries.insert().values(
+            models.shopping_event_products.insert().values(
                 shopping_event_id=event_id,
-                grocery_id=grocery_item.grocery_id,
-                amount=grocery_item.amount,
-                price=grocery_item.price
+                product_id=product_item.product_id,
+                amount=product_item.amount,
+                price=product_item.price
             )
         )
     
@@ -261,10 +261,10 @@ def delete_shopping_event(event_id: int, db: Session = Depends(get_db)):
     if event is None:
         raise HTTPException(status_code=404, detail="Shopping event not found")
     
-    # Delete grocery associations first
+    # Delete product associations first
     db.execute(
-        models.shopping_event_groceries.delete().where(
-            models.shopping_event_groceries.c.shopping_event_id == event_id
+        models.shopping_event_products.delete().where(
+            models.shopping_event_products.c.shopping_event_id == event_id
         )
     )