added pb backend logic, working on displaying errors

KushK04 · KushK04 · commit d7addeefcdf2 · 2025-05-27T09:33:03.000-07:00
diff --git a/KonditionExpo/contexts/AuthContext.tsx b/KonditionExpo/contexts/AuthContext.tsx
@@ -0,0 +1,47 @@
+import React, { createContext, useContext, useState, ReactNode } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+type AuthContextType = {
+  login: (email: string, password: string) => Promise<void>;
+  logout: () => Promise<void>;
+  token: string | null;
+};
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const AuthProvider = ({ children }: { children: ReactNode }) => {
+  const [token, setToken] = useState<string | null>(null);
+
+  const login = async (email: string, password: string) => {
+    const res = await fetch('http://localhost:8000/api/v1/login', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+
+    const data = await res.json();
+    if (res.ok) {
+      await AsyncStorage.setItem('access_token', data.access_token); 
+      setToken(data.access_token);
+    } else {
+      throw new Error(data.detail || 'Login failed');
+    }
+  };
+
+  const logout = async () => {
+    await AsyncStorage.removeItem('access_token');
+    setToken(null);
+  };
+
+  return (
+    <AuthContext.Provider value={{ login, logout, token }}>
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+export const useAuth = () => {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error("useAuth must be used within an AuthProvider");
+  return ctx;
+};
diff --git a/KonditionExpo/hooks/usePersonalBests.ts b/KonditionExpo/hooks/usePersonalBests.ts
@@ -0,0 +1,41 @@
+import { useEffect, useState } from "react";
+import { getAccessToken } from "@/scripts/auth"; // adjust based on your token handling
+
+export const usePersonalBests = () => {
+  const [pbs, setPbs] = useState([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    console.log("🔁 usePersonalBests hook loaded");
+  
+    const fetchPBs = async () => {
+      console.log("📡 Fetching personal bests...");
+      setLoading(true);
+      try {
+        console.log("🔑 Attempting to get token...");
+        const token = await getAccessToken();
+        console.log("Got token:", token);
+  
+        const res = await fetch("http://localhost:8000/api/v1/personal-bests", {
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        });
+  
+        const data = await res.json();
+        console.log("📬 Fetched PBs:", data);
+        setPbs(data.data); // Adjust if shape differs
+      } catch (err) {
+        console.error("Failed to fetch personal bests", err);
+      } finally {
+        setLoading(false);
+      }
+    };
+  
+    fetchPBs();
+  }, []);
+  
+  
+
+  return { pbs, loading };
+};
diff --git a/KonditionExpo/scripts/auth.ts b/KonditionExpo/scripts/auth.ts
@@ -0,0 +1,12 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export const getAccessToken = async (): Promise<string | null> => {
+  try {
+    const token = await AsyncStorage.getItem('access_token');
+    console.log("Token from AsyncStorage:", token);
+    return token;
+  } catch (err) {
+    console.error("Error getting token", err);
+    return null;
+  }
+};
diff --git a/backend/app/api/routes/p_bests.py b/backend/app/api/routes/p_bests.py
@@ -0,0 +1,47 @@
+# TODO test PB dedicated router,  3 REST routes, 1 post & 2 gets  
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlmodel import Session
+
+from app import crud
+from app.core.db import get_session
+from app.core.security import get_current_active_user
+from app.models import PersonalBestCreate, PersonalBestRead, PersonalBestsList
+
+router = APIRouter(tags=["personal-bests"], prefix="/personal-bests")
+
+@router.post("/", response_model=PersonalBestRead, status_code=status.HTTP_201_CREATED)
+def record_personal_best(
+    pb_in: PersonalBestCreate,
+    session: Session = Depends(get_session),
+    current_user=Depends(get_current_active_user),
+):
+    """
+    Record or update a personal best for the current user.
+    """
+    pb = crud.create_or_update_personal_best(
+        session=session, user_id=current_user.id, pb_in=pb_in
+    )
+    return pb
+
+@router.get("/", response_model=PersonalBestsList)
+def list_personal_bests(
+    session: Session = Depends(get_session),
+    current_user=Depends(get_current_active_user),
+):
+    all_pbs = crud.get_personal_bests(session=session, user_id=current_user.id)
+    return {"data": all_pbs, "count": len(all_pbs)}
+
+@router.get("/{metric}", response_model=PersonalBestRead)
+def get_personal_best(
+    metric: str,
+    session: Session = Depends(get_session),
+    current_user=Depends(get_current_active_user),
+):
+    pb = crud.get_personal_best(
+        session=session, user_id=current_user.id, metric=metric
+    )
+    if not pb:
+        raise HTTPException(status_code=404, detail="No personal best for that metric")
+    return pb
diff --git a/backend/app/api/routes/workouts.py b/backend/app/api/routes/workouts.py
@@ -19,6 +19,8 @@
     ExerciseUpdate,
     ExercisePublic,
 )
+from app.crud import update_personal_bests_after_workout
+
 
 router = APIRouter(prefix="/workouts", tags=["workouts"])
 
@@ -247,6 +249,7 @@ def delete_workout(
     
     return Message(message="Workout deleted successfully")
 
+# TODO - Kush, added PB updating, test
 
 @router.post("/{workout_id}/complete", response_model=WorkoutPublic)
 def complete_workout(
@@ -289,6 +292,10 @@ def complete_workout(
     session.add(workout)
     session.commit()
     session.refresh(workout)
+
+    #added for updating personalbests
+    update_personal_bests_after_workout(session=session, workout=workout)
+
     
     return workout
 
diff --git a/backend/app/crud.py b/backend/app/crud.py
@@ -2,10 +2,20 @@
 from typing import Any
 
 from sqlmodel import Session, select
-
 from app.core.security import get_password_hash, verify_password
 from app.models import Item, ItemCreate, User, UserCreate, UserUpdate
+from app.models import Workout, Exercise, PersonalBest, PersonalBestCreate
+from datetime import date
 
+# Define metric keys for exercises we want to track personal bests for
+TRACKED_EXERCISES = {
+    "bench press": "bench-press",
+    "squat": "squat",
+    "deadlift": "deadlift",
+    "push-ups": "pushups",
+    "pull-ups": "pullups",
+    # extend as needed
+}
 
 def create_user(*, session: Session, user_create: UserCreate) -> User:
     db_obj = User.model_validate(
@@ -52,3 +62,71 @@ def create_item(*, session: Session, item_in: ItemCreate, owner_id: uuid.UUID) -
     session.commit()
     session.refresh(db_item)
     return db_item
+
+
+
+#TODO test, create_or_update_personal_best will upsert only if the new value is strictly better.
+# Two getters: one for all metrics, one for a single metric.
+
+def create_or_update_personal_best(
+    *, session: Session, user_id: uuid.UUID, pb_in: PersonalBestCreate
+) -> PersonalBest:
+    # see if user already has a PB on this metric
+    stmt = select(PersonalBest).where(
+        PersonalBest.user_id == user_id,
+        PersonalBest.metric == pb_in.metric
+    )
+    existing = session.exec(stmt).one_or_none()
+
+    # update if new value is "better" (you define the logic per metric)
+    if existing:
+        if pb_in.value > existing.value:
+            existing.value = pb_in.value
+            existing.date = pb_in.date
+            session.add(existing)
+    else:
+        existing = PersonalBest.model_validate(pb_in, update={"user_id": user_id})
+        session.add(existing)
+
+    session.commit()
+    session.refresh(existing)
+    return existing
+
+def get_personal_bests(
+    *, session: Session, user_id: uuid.UUID
+) -> list[PersonalBest]:
+    stmt = select(PersonalBest).where(PersonalBest.user_id == user_id)
+    return session.exec(stmt).all()
+
+def get_personal_best(
+    *, session: Session, user_id: uuid.UUID, metric: str
+) -> PersonalBest | None:
+    stmt = select(PersonalBest).where(
+        PersonalBest.user_id == user_id,
+        PersonalBest.metric == metric
+    )
+    return session.exec(stmt).one_or_none()
+
+def update_personal_bests_after_workout(*, session: Session, workout: Workout):
+    user_id = workout.user_id
+
+    # Fetch all exercises associated with this workout
+    exercises = workout.exercises
+
+    for exercise in exercises:
+        name = exercise.name.lower()
+        metric_key = TRACKED_EXERCISES.get(name)
+        if not metric_key:
+            #
+            continue  # skip exercises we don't track
+
+        # Use weight * reps as performance metric for now
+        value = (exercise.weight or 0) * (exercise.reps or 0)
+        if value <= 0:
+            #continue
+            value = 0
+
+        pb_in = PersonalBestCreate(metric=metric_key, value=value, date=date.today())
+
+        from app.crud import create_or_update_personal_best  # to avoid circular imports
+        create_or_update_personal_best(session=session, user_id=user_id, pb_in=pb_in)
diff --git a/backend/app/models.py b/backend/app/models.py
@@ -2,6 +2,7 @@
 
 from pydantic import EmailStr
 from sqlmodel import Field, Relationship, SQLModel
+from dates import date
 
 
 # Shared properties
@@ -45,6 +46,9 @@ class User(UserBase, table=True):
     hashed_password: str
     items: list["Item"] = Relationship(back_populates="owner", cascade_delete=True)
 
+    # TODO test
+    personal_bests: list["PB"] = Relationship(back_populates="user", cascade_delete=True)
+
 
 # Properties to return via API, id is always required
 class UserPublic(UserBase):
@@ -81,6 +85,25 @@ class Item(ItemBase, table=True):
     owner: User | None = Relationship(back_populates="items")
 
 
+
+
+# TODO test, one-to-many User.personal_bests relationship.
+# expose PersonalBestBase for writes, PersonalBest for reads, and wrapper list.
+
+class PersonalBestBase(SQLModel):
+    metric: str = Field(max_length=100, description = "e.g. deadlift, 5k-run, pushups")
+    value: float = Field(..., description="numeric value of the best (e.g. kg, seconds, reps)")
+    date: date = Field(default_factory=date.today)
+
+class PersonalBest(PersonalBestBase, table=True):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    user_id: uuid.UUID = Field(foreign_key="user.id", nullable=False, ondelete="CASCADE")
+    user: User = Relationship(back_populates="personal_bests")
+
+class PersonalBestsList(SQLModel):
+    data: list[PersonalBest]
+    count: int
+
 # Properties to return via API, id is always required
 class ItemPublic(ItemBase):
     id: uuid.UUID
diff --git a/backend/app/models/user.py b/backend/app/models/user.py
@@ -14,7 +14,7 @@ class UserBase(SQLModel):
 
 # Properties to receive via API on creation
 class UserCreate(UserBase):
-    password: str = Field(min_length=8, max_length=40)
+    password: str = Field(min_length=8, max_length=50)
 
 
 class UserRegister(SQLModel):
