fix: resolve calorie limit auto-update issue and add optimized goal achievement date calculation

Author: SuyashBhavalkar3

app.db

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, Float, Date, ForeignKey, DateTime
+from sqlalchemy import Column, Integer, Float, Date, ForeignKey, DateTime, String
 from sqlalchemy.sql import func
 from database.database import Base
 
@@ -9,6 +9,7 @@ class UserGoal(Base):
 
     target_weight = Column(Float, nullable=False)
     weekly_goal_kg = Column(Float, nullable=False)
+    goal_type = Column(String(20), default="lose", nullable=False)
 
     target_date = Column(Date, nullable=False)
 

backend/database/models/user_goal_setup.py

@@ -29,14 +29,16 @@ def set_goal(
         profile, 
         payload.target_weight, 
         payload.weekly_goal_kg,
-        target_calories=payload.target_calories  # Use user input as primary source
+        target_calories=payload.target_calories,
+        goal_type=payload.goal_type
     )
 
     if existing:
         # Update existing goal
         existing.target_weight = payload.target_weight
         existing.weekly_goal_kg = payload.weekly_goal_kg
-        existing.daily_calories = payload.target_calories  # Store user's target, not calculated
+        existing.goal_type = payload.goal_type
+        existing.daily_calories = payload.target_calories
         existing.protein_g = result["protein_g"]
         existing.carbs_g = result["carbs_g"]
         existing.fat_g = result["fat_g"]
@@ -50,7 +52,8 @@ def set_goal(
             user_id=current_user.id,
             target_weight=payload.target_weight,
             weekly_goal_kg=payload.weekly_goal_kg,
-            daily_calories=payload.target_calories,  # Store user's target
+            goal_type=payload.goal_type,
+            daily_calories=payload.target_calories,
             protein_g=result["protein_g"],
             carbs_g=result["carbs_g"],
             fat_g=result["fat_g"],
@@ -74,4 +77,4 @@ def get_my_goal(
     if not goal:
         raise HTTPException(404, "Goal not found")
 
-    return goal
+    return goal

backend/goal_service/api.py

@@ -5,7 +5,8 @@
     "sedentary": 1.2,
     "light": 1.375,
     "moderate": 1.55,
-    "active": 1.725
+    "active": 1.725,
+    "very_active": 1.9
 }
 
 def calculate_bmr(weight, height, age, gender):
@@ -15,28 +16,89 @@ def calculate_bmr(weight, height, age, gender):
         return 10*weight + 6.25*height - 5*age - 161
 
 
-def calculate_goal(profile, target_weight, weekly_goal_kg, target_calories=None):
+def calculate_adjusted_calories(bmr, activity_level, goal_type, weekly_rate):
     """
-    Calculate goal with macros based on target calories.
+    Calculate TDEE with adjustment based on goal type and weekly rate.
+    
+    Args:
+        bmr: Basal Metabolic Rate
+        activity_level: User's activity level string
+        goal_type: "lose", "gain", or "maintain"
+        weekly_rate: Weekly weight change rate (kg/week)
+    
+    Returns:
+        Adjusted daily calorie target (int)
+    """
+    # Energy equivalent: 1 kg ≈ 7700 kcal
+    base_tdee = bmr * ACTIVITY_FACTORS.get(activity_level, 1.2)
+    
+    if goal_type == "maintain":
+        return int(round(base_tdee))
+    
+    # Daily calorie adjustment: (weeklyRate * 7700) / 7
+    daily_adjustment = (weekly_rate * 7700) / 7
+    
+    if goal_type == "lose":
+        adjusted = base_tdee - daily_adjustment
+    elif goal_type == "gain":
+        adjusted = base_tdee + daily_adjustment
+    else:
+        adjusted = base_tdee
+    
+    # Ensure minimum of 1000 kcal/day to prevent dangerously low intake
+    return max(1000, int(round(adjusted)))
+
+
+def calculate_estimated_date(current_weight, target_weight, weekly_rate):
+    """
+    Calculate estimated date to reach target weight.
+    
+    Args:
+        current_weight: Current weight in kg
+        target_weight: Target weight in kg
+        weekly_rate: Weekly weight change rate (kg/week)
+    
+    Returns:
+        Estimated completion date
+    """
+    if weekly_rate == 0:
+        return None
+    
+    weight_difference = abs(current_weight - target_weight)
+    weeks_required = math.ceil(weight_difference / weekly_rate)
+    days_required = weeks_required * 7
+    
+    return date.today() + timedelta(days=days_required)
+
+
+def calculate_goal(profile, target_weight, weekly_goal_kg, target_calories=None, goal_type="lose"):
+    """
+    Calculate goal with macros based on target calories and goal type.
     
     Args:
         profile: User profile with health metrics
         target_weight: Target weight in kg
-        weekly_goal_kg: Weekly weight loss goal in kg
+        weekly_goal_kg: Weekly weight loss/gain goal in kg
         target_calories: User's target daily calories (if None, calculated from profile)
+        goal_type: "lose", "gain", or "maintain"
     """
 
-    # If no target_calories provided, calculate from profile
+    # Calculate BMR once
+    bmr = calculate_bmr(
+        profile.weight_kg,
+        profile.height_cm,
+        profile.age,
+        profile.gender
+    )
+    
+    # If no target_calories provided, calculate from profile with adjustment
     if target_calories is None:
-        bmr = calculate_bmr(
-            profile.weight_kg,
-            profile.height_cm,
-            profile.age,
-            profile.gender
+        daily_calories = calculate_adjusted_calories(
+            bmr, 
+            profile.activity_level, 
+            goal_type, 
+            weekly_goal_kg
         )
-        tdee = bmr * ACTIVITY_FACTORS.get(profile.activity_level, 1.2)
-        deficit = 500 if weekly_goal_kg == 0.5 else 1000
-        daily_calories = int(tdee - deficit)
     else:
         # Use provided target_calories as source of truth
         daily_calories = target_calories
@@ -47,10 +109,10 @@ def calculate_goal(profile, target_weight, weekly_goal_kg, target_calories=None)
     carbs_g   = int(daily_calories * 0.40 / 4)
     fat_g     = int(daily_calories * 0.30 / 9)
 
-    weeks = abs(profile.weight_kg - target_weight) / weekly_goal_kg
-    days = math.ceil(weeks * 7)
-
-    target_date = date.today() + timedelta(days=days)
+    # Calculate estimated date
+    target_date = calculate_estimated_date(profile.weight_kg, target_weight, weekly_goal_kg)
+    if target_date is None:
+        target_date = date.today()
 
     return {
         "daily_calories": daily_calories,

backend/goal_service/calculator.py

@@ -5,6 +5,7 @@ class GoalCreate(BaseModel):
     target_weight: float = Field(..., gt=0)
     weekly_goal_kg: float = Field(..., description="0.5 or 1")
     target_calories: int = Field(..., gt=0, description="Daily calorie target")
+    goal_type: str = Field(default="lose", description="lose, gain, or maintain")
 
 
 
@@ -16,8 +17,9 @@ class GoalResponse(BaseModel):
     carbs_g: int
     fat_g: int
     target_date: date
-    target_weight: float  # Use the actual database field name
+    target_weight: float
     weekly_goal_kg: float
+    goal_type: str = "lose"
 
     @field_serializer('target_date')
     def serialize_target_date(self, value: date) -> str:

backend/goal_service/schemas.py

@@ -4,6 +4,7 @@
 from profile_service.schemas import ProfileCreate, ProfileResponse
 from database.models.user_profile_setup import UserProfile
 from auth_service.dependencies import get_current_user
+from goal_service.calculator import calculate_bmr, ACTIVITY_FACTORS
 
 router = APIRouter(prefix="/profile", tags=["Profile"])
 
@@ -33,13 +34,29 @@ def setup_profile(
         db.add(profile)
 
     db.commit()
-    
-    if existing:
-        db.refresh(existing)
-        return existing
-    else:
-        db.refresh(profile)
-        return profile
+
+    # Calculate recommended calories using Mifflin-St Jeor + activity multiplier
+    # Use payload values (updated values) for calculation
+    try:
+        bmr = calculate_bmr(payload.weight_kg, payload.height_cm, payload.age, payload.gender)
+        multiplier = ACTIVITY_FACTORS.get(payload.activity_level, 1.2)
+        recommended = int(round(bmr * multiplier))
+        # Ensure within reasonable validated bounds (frontend expects >=1000)
+        recommended = max(1000, recommended)
+    except Exception:
+        recommended = 0
+
+    response_obj = {
+        "user_id": current_user.id,
+        "age": payload.age,
+        "height_cm": payload.height_cm,
+        "weight_kg": payload.weight_kg,
+        "gender": payload.gender,
+        "activity_level": payload.activity_level,
+        "recommended_calories": recommended,
+    }
+
+    return response_obj
 
 
 @router.get("/me", response_model=ProfileResponse)
@@ -53,4 +70,21 @@ def get_my_profile(
     if not profile:
         raise HTTPException(404, "Profile not found")
 
-    return profile
+    # Compute recommended calories based on stored profile
+    try:
+        bmr = calculate_bmr(profile.weight_kg, profile.height_cm, profile.age, profile.gender)
+        multiplier = ACTIVITY_FACTORS.get(profile.activity_level, 1.2)
+        recommended = int(round(bmr * multiplier))
+        recommended = max(1000, recommended)
+    except Exception:
+        recommended = 0
+
+    return {
+        "user_id": profile.user_id,
+        "age": profile.age,
+        "height_cm": profile.height_cm,
+        "weight_kg": profile.weight_kg,
+        "gender": profile.gender,
+        "activity_level": profile.activity_level,
+        "recommended_calories": recommended,
+    }

backend/profile_service/api.py

@@ -9,4 +9,5 @@ class ProfileCreate(BaseModel):
 
 
 class ProfileResponse(ProfileCreate):
-    user_id: int
+    user_id: int
+    recommended_calories: int = 0

backend/profile_service/schemas.py

@@ -154,6 +154,7 @@ export interface GoalsData {
   fat_goal: number;
   weight_goal: number;
   weekly_goal_kg: number;
+  goal_type?: string;
 }
 
 export const goalsApi = {
@@ -164,6 +165,7 @@ export const goalsApi = {
       target_weight: data.weight_goal,
       weekly_goal_kg: data.weekly_goal_kg,
       target_calories: data.target_calories,  // Calories are primary input
+      goal_type: data.goal_type || "lose",
     });
   },
   me: () => {