feat:Added Steps backend

alembic/versions/0875ad9f64a9_add_steps_count_to_water_logs.py

@@ -0,0 +1,41 @@
+"""add steps_count to water_logs
+
+Revision ID: 0875ad9f64a9
+Revises: 53622d9fbc8d
+Create Date: 2025-12-26 21:45:42.492758
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '0875ad9f64a9'
+down_revision: Union[str, Sequence[str], None] = '53622d9fbc8d'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+
+    op.add_column('water_logs', sa.Column('steps_count', sa.Integer(), nullable=True))
+    op.alter_column('water_logs', 'amount_ml',
+               existing_type=sa.INTEGER(),
+               nullable=True)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('water_logs', 'amount_ml',
+               existing_type=sa.INTEGER(),
+               nullable=False)
+    op.drop_column('water_logs', 'steps_count')
+    
+    # ### end Alembic commands ###

src/wellbeing/models.py

@@ -1,18 +1,37 @@
-from sqlmodel import Field, SQLModel, Relationship, ForeignKey,Column
+from sqlmodel import Field, SQLModel, Relationship
+from sqlalchemy import Column, ForeignKey
+from sqlalchemy.dialects.postgresql import UUID
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
-from sqlalchemy.dialects.postgresql import UUID
+
 
 class WaterLogs(SQLModel, table=True):
     __tablename__ = "water_logs"
+
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+
     user_id: uuid.UUID = Field(
-        sa_column=Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+        sa_column=Column(
+            UUID(as_uuid=True),
+            ForeignKey("users.id", ondelete="CASCADE"),
+            nullable=False,
+        )
     )
-    amount_ml: int = Field(..., nullable=False)
-    logged_at: datetime = Field(default_factory=datetime.now, nullable=False)
-    goal_ml: Optional[int] = Field(default=None, nullable=True)
-    recommended_ml: Optional[int] = Field(default=None, nullable=True)
-    
+
+    # Water (manual)
+    amount_ml: Optional[int] = Field(default=None)
+
+    # Steps (auto)
+    steps_count: Optional[int] = Field(default=None)
+
+    # Single timestamp (UPDATED on every water OR steps update)
+    logged_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), nullable=False
+    )
+
+    # Goals
+    goal_ml: Optional[int] = Field(default=None)
+    recommended_ml: Optional[int] = Field(default=None)
+
     user: "Users" = Relationship(back_populates="water_logs")

src/wellbeing/router.py

@@ -3,7 +3,13 @@ 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 src.wellbeing.schemas import (
+    WaterLogCreate,
+    WaterLogUpdate,
+    WaterLog,
+    StepsLog,
+    StepsLogCreate,
+)
 from . import service
 from sqlalchemy.ext.asyncio.session import AsyncSession
 
@@ -39,10 +45,10 @@ async def update_water_log(
     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)
+    updated_log = await 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
+    return updated_log
 
 
 # Delete a water log
@@ -56,3 +62,32 @@ async def delete_water_log(
     if not success:
         raise HTTPException(status_code=404, detail="Water log not found")
     return {"message": "Water log deleted successfully"}
+
+
+@router.post("/steps", response_model=StepsLog)
+async def create_or_update_steps(
+    steps: StepsLogCreate,
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    return await service.create_or_update_steps(
+        session=session,
+        steps=steps,
+        user_id=user_id,
+    )
+
+
+@router.get("/getsteps", response_model=list[StepsLog])
+async def get_steps(
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    return await service.get_steps_logs(session, user_id)
+
+@router.get("/steps/weekly")
+async def get_weekly_steps(
+    session: AsyncSession = Depends(get_async_session),
+    user_id: UUID = Depends(get_current_user),
+):
+    return await service.get_weekly_steps(session, user_id)
+

src/wellbeing/schemas.py

@@ -3,17 +3,23 @@ from typing import Optional
 import uuid
 from datetime import datetime
 
+
 class WaterLogBase(BaseModel):
-    amount_ml: int
+
+    amount_ml: Optional[int] = None
+
     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
@@ -21,3 +27,18 @@ class WaterLog(WaterLogBase):
 
     model_config = {"from_attributes": True}
 
+
+class StepsLogBase(BaseModel):
+    steps_count: int
+
+
+class StepsLogCreate(StepsLogBase):
+    pass
+
+
+class StepsLog(StepsLogBase):
+    id: uuid.UUID
+    user_id: uuid.UUID
+    logged_at: datetime
+
+    model_config = {"from_attributes": True}

src/wellbeing/service.py

@@ -1,17 +1,17 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
-from typing import List
+from typing import List , Dict
 from .models import WaterLogs
 import uuid
-from .schemas import WaterLogCreate, WaterLogUpdate
-from datetime import date, datetime
+from .schemas import WaterLogCreate, WaterLogUpdate, StepsLogCreate
+from datetime import date, datetime , timedelta
+
 
 
 # Create or update today's water log
 async def create_water_log(
     session: AsyncSession, water_log: WaterLogCreate, user_id: uuid.UUID
 ) -> WaterLogs:
-    
 
     today = date.today()
 
@@ -29,6 +29,7 @@ async def create_water_log(
         existing_log.amount_ml = water_log.amount_ml
         existing_log.goal_ml = water_log.goal_ml
         existing_log.recommended_ml = water_log.recommended_ml
+        existing_log.logged_at = datetime.utcnow()
         await session.commit()
         await session.refresh(existing_log)
         return existing_log
@@ -71,6 +72,7 @@ async def update_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
+        db_water_log.logged_at = datetime.utcnow()
         await session.commit()  # Commit asynchronously
         await session.refresh(db_water_log)  # Refresh asynchronously
         return db_water_log
@@ -88,3 +90,115 @@ async def delete_water_log(session: AsyncSession, water_log_id: uuid.UUID) -> bo
         await session.commit()  # Commit asynchronously
         return True
     return False
+
+
+async def create_or_update_steps(
+    session: AsyncSession,
+    steps: StepsLogCreate,
+    user_id: uuid.UUID,
+) -> WaterLogs:
+
+    today = date.today()
+
+    stmt = select(WaterLogs).filter(
+        WaterLogs.user_id == user_id,
+        WaterLogs.logged_at >= datetime.combine(today, datetime.min.time()),
+        WaterLogs.logged_at <= datetime.combine(today, datetime.max.time()),
+    )
+
+    result = await session.execute(stmt)
+    existing_log = result.scalar_one_or_none()
+
+    # UPDATE existing row
+    if existing_log:
+        existing_log.steps_count = steps.steps_count  # overwrite
+        existing_log.logged_at = datetime.utcnow()
+        await session.commit()
+        await session.refresh(existing_log)
+        return existing_log
+
+    # CREATE new row
+    new_log = WaterLogs(
+        id=uuid.uuid4(),
+        user_id=user_id,
+        steps_count=steps.steps_count,
+        logged_at=datetime.utcnow(),
+    )
+
+    session.add(new_log)
+    await session.commit()
+    await session.refresh(new_log)
+    return new_log
+
+async def get_steps_logs(
+    session: AsyncSession,
+    user_id: uuid.UUID,
+    skip: int = 0,
+    limit: int = 30,
+) -> List[WaterLogs]:
+    """
+    Get step logs for a user (latest first)
+    """
+
+    stmt = (
+        select(WaterLogs)
+        .filter(
+            WaterLogs.user_id == user_id,
+            WaterLogs.steps_count.isnot(None),
+        )
+        .order_by(WaterLogs.logged_at.desc())
+        .offset(skip)
+        .limit(limit)
+    )
+
+    result = await session.execute(stmt)
+    return result.scalars().all()
+
+
+
+
+
+
+async def get_weekly_steps(
+    session: AsyncSession,
+    user_id: uuid.UUID,
+) -> Dict[str, int]:
+    """
+    Returns steps grouped by weekday for current week
+    Example:
+    {
+      "Mon": 3200,
+      "Tue": 4500,
+      ...
+    }
+    """
+
+    today = date.today()
+    start_of_week = today - timedelta(days=today.weekday())  # Monday
+    end_of_week = start_of_week + timedelta(days=6)
+
+    stmt = select(WaterLogs).filter(
+        WaterLogs.user_id == user_id,
+        WaterLogs.steps_count.isnot(None),
+        WaterLogs.logged_at >= start_of_week,
+        WaterLogs.logged_at <= end_of_week,
+    )
+
+    result = await session.execute(stmt)
+    logs = result.scalars().all()
+
+    week_map = {
+        "Mon": 0,
+        "Tue": 0,
+        "Wed": 0,
+        "Thu": 0,
+        "Fri": 0,
+        "Sat": 0,
+        "Sun": 0,
+    }
+
+    for log in logs:
+        day = log.logged_at.strftime("%a")
+        week_map[day] = log.steps_count
+
+    return week_map