Merge pull request #34 from yuvabe-ai-labs/feat/notify

src/main.py

@@ -1,3 +1,4 @@
+from src.wellbeing.router import router as wellbeing
 from fastapi import FastAPI
 
 import os
@@ -12,10 +13,12 @@ from fastapi.staticfiles import StaticFiles
 
 app = FastAPI(title="Yuvabe App API")
 
+
 @app.on_event("startup")
 async def on_startup():
     await init_db()
-    
+
+
 app.include_router(home_router, prefix="/home", tags=["Home"])
 
 # init_db()
@@ -26,6 +29,8 @@ app.include_router(auth_router)
 
 app.include_router(chatbot_router)
 
+app.include_router(wellbeing)
+
 app.include_router(notifications_router)
 
 

src/wellbeing/router.py

@@ -0,0 +1,58 @@
+from src.core.database import get_async_session
+from src.auth.utils import get_current_user
+from fastapi import APIRouter, Depends, HTTPException
+from uuid import UUID
+from typing import List
+from src.wellbeing.schemas import WaterLogCreate, WaterLogUpdate, WaterLog
+from . import service
+from sqlalchemy.ext.asyncio.session import AsyncSession
+
+router = APIRouter(prefix="/wellbeing", tags=["Wellbeing"])
+
+
+# Create a new water log
+@router.post("/water_logs/", response_model=WaterLog)
+async def create_water_log(
+    water_log: WaterLogCreate,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    return await service.create_water_log(session, water_log, user_id)
+
+
+# Get all water logs for a user
+@router.get("/water_logs/", response_model=List[WaterLog])
+async def get_water_logs(
+    skip: int = 0,
+    limit: int = 100,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    return await service.get_water_logs(session, user_id, skip=skip, limit=limit)
+
+
+# Update a water log
+@router.put("/water_logs/{water_log_id}", response_model=WaterLog)
+async def update_water_log(
+    water_log_id: UUID,
+    water_log: WaterLogUpdate,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    updated_log = service.update_water_log(session, water_log_id, water_log)
+    if not updated_log:
+        raise HTTPException(status_code=404, detail="Water log not found")
+    return await updated_log
+
+
+# Delete a water log
+@router.delete("/water_logs/{water_log_id}")
+async def delete_water_log(
+    water_log_id: UUID,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    success = service.delete_water_log(session, water_log_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Water log not found")
+    return {"message": "Water log deleted successfully"}

src/wellbeing/schemas.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from typing import Optional
+import uuid
+from datetime import datetime
+
+class WaterLogBase(BaseModel):
+    amount_ml: int
+    goal_ml: Optional[int] = None
+    recommended_ml: Optional[int] = None
+
+class WaterLogCreate(WaterLogBase):
+    pass
+
+class WaterLogUpdate(WaterLogBase):
+    pass
+
+class WaterLog(WaterLogBase):
+    id: uuid.UUID
+    user_id: uuid.UUID
+    logged_at: datetime
+
+    model_config = {"from_attributes": True}
+

src/wellbeing/service.py

@@ -0,0 +1,66 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from datetime import datetime
+from typing import List
+from .models import WaterLogs
+import uuid
+from .schemas import WaterLogCreate, WaterLogUpdate
+
+
+# Create a new water log
+async def create_water_log(
+    session: AsyncSession, water_log: WaterLogCreate, user_id: uuid.UUID
+) -> WaterLogs:
+    db_water_log = WaterLogs(
+        user_id=user_id,
+        amount_ml=water_log.amount_ml,
+        logged_at=datetime.now(),
+        goal_ml=water_log.goal_ml,
+        recommended_ml=water_log.recommended_ml,
+    )
+    session.add(db_water_log)
+    await session.commit()  # Commit asynchronously
+    await session.refresh(db_water_log)  # Refresh asynchronously
+    return db_water_log
+
+
+# Get all water logs for a user
+async def get_water_logs(
+    session: AsyncSession, user_id: uuid.UUID, skip: int = 0, limit: int = 100
+) -> List[WaterLogs]:
+    stmt = (
+        select(WaterLogs).filter(WaterLogs.user_id == user_id).offset(skip).limit(limit)
+    )
+    result = await session.execute(stmt)  # Execute asynchronously
+    return result.scalars().all()  # Fetch results asynchronously
+
+
+# Update a water log
+async def update_water_log(
+    session: AsyncSession, water_log_id: uuid.UUID, water_log: WaterLogUpdate
+) -> WaterLogs:
+    stmt = select(WaterLogs).filter(WaterLogs.id == water_log_id)
+    result = await session.execute(stmt)  # Execute asynchronously
+    db_water_log = result.scalar_one_or_none()
+
+    if db_water_log:
+        db_water_log.amount_ml = water_log.amount_ml
+        db_water_log.goal_ml = water_log.goal_ml
+        db_water_log.recommended_ml = water_log.recommended_ml
+        await session.commit()  # Commit asynchronously
+        await session.refresh(db_water_log)  # Refresh asynchronously
+        return db_water_log
+    return None
+
+
+# Delete a water log
+async def delete_water_log(session: AsyncSession, water_log_id: uuid.UUID) -> bool:
+    stmt = select(WaterLogs).filter(WaterLogs.id == water_log_id)
+    result = await session.execute(stmt)  # Execute asynchronously
+    db_water_log = result.scalar_one_or_none()
+
+    if db_water_log:
+        await session.delete(db_water_log)  # Delete asynchronously
+        await session.commit()  # Commit asynchronously
+        return True
+    return False