Merge pull request #103 from Modarb-Ai-Trainer/stats

src/common/enums/meal-type.enum.ts

@@ -4,4 +4,5 @@ export enum MealType {
   SNACKS = "snacks",
   DRINKS_BEVERAGES = 'drinks beverages',
   LUNCH = "lunch",
+  CUSTOM = "custom",
 }

src/lib/services/crud.service.ts

@@ -9,7 +9,7 @@ export const CrudService = <ModelDoc extends Document>(
   }
 ) => {
   return class CrudServiceClass {
-    protected model: Model<ModelDoc> = model;
+    public model: Model<ModelDoc> = model;
 
     async create(data: AnyKeys<ModelDoc>): Promise<ModelDoc> {
       return this.model.create(data);

src/modules/users/modules/activities/services/user-activities.service.ts

@@ -0,0 +1,4 @@
+import { Activity } from "@common/models/activity.model";
+import { CrudService } from "@lib/services/crud.service";
+
+export class UserActivitiesService extends CrudService(Activity) {}

src/modules/users/modules/{meals/events/eat-custom-meal.event.ts → exercises/events/exercise-done.event.ts}

@@ -1,18 +1,18 @@
 import { ActivityType } from "@common/enums/activity-type.enum";
 import { Activity, IActivity } from "@common/models/activity.model";
 import { EventsManager } from "@lib/events/events-manager";
-import { IEatCustomMeal } from "../validations/eat-custom-meal.validation";
+import { Types } from "mongoose";
 
-export class EatCustomMealEvent {
-  constructor(public userId: string, public ingredients: IEatCustomMeal['ingredients']) {}
+export class ExerciseDoneEvent {
+  constructor(public userId: string, public exercisesId: string){}
 }
 
-EventsManager.on(ActivityType.EAT_CUSTOM_MEAL, (event: EatCustomMealEvent) => {
-  console.log(`User with id ${event.userId} ate a custom meal with ingredients: ${event.ingredients.map(i => i.id).join(", ")}`);
+EventsManager.on(ExerciseDoneEvent.name, async (event: ExerciseDoneEvent) => {
+  console.log(`Exercise done event for user ${event.userId}`);
 
   Activity.create({
-    user_id: event.userId,
-    activity_type: ActivityType.EAT_CUSTOM_MEAL,
-    related_item: { ingredients: event.ingredients },
+    user_id: new Types.ObjectId(event.userId),
+    related_id: new Types.ObjectId(event.exercisesId),
+    activity_type: ActivityType.EXERCISE,
   } satisfies IActivity).catch(console.error);
 });

src/modules/users/modules/exercises/events/exercises-done.event.ts

@@ -0,0 +1,22 @@
+import { ActivityType } from "@common/enums/activity-type.enum";
+import { Activity, IActivity } from "@common/models/activity.model";
+import { EventsManager } from "@lib/events/events-manager";
+import { Types } from "mongoose";
+
+export class ExercisesDoneEvent {
+  constructor(public userId: string, public exercisesIds: string[]){}
+}
+
+EventsManager.on(ExercisesDoneEvent.name, async (event: ExercisesDoneEvent) => {
+  console.log(`Exercise done event for user ${event.userId}`);
+
+  await Promise.all(
+    event.exercisesIds.map(eId => {
+      Activity.create({
+        user_id: new Types.ObjectId(event.userId),
+        related_id: new Types.ObjectId(eId),
+        activity_type: ActivityType.EXERCISE,
+      } satisfies IActivity).catch(console.error);
+    })
+  )
+});

src/modules/users/modules/exercises/services/exercises.service.ts

@@ -1,4 +1,35 @@
-import { Exercise } from "@common/models/exercise.model";
+import { ExerciseType } from "@common/enums/exercise-type.enum";
+import { Exercise, ExerciseDocument } from "@common/models/exercise.model";
 import { CrudService } from "@lib/services/crud.service";
 
-export class ExerciseService extends CrudService(Exercise) {}
+const caloriesPerMinute = 5;
+const caloriesPerRep = 0.5;
+
+export class ExerciseService extends CrudService(Exercise) {
+  calculateCalories(exercise: ExerciseDocument): number {
+    if (exercise.isDeleted) {
+      return 0;
+    }
+
+    let calories = 0;
+
+    switch (exercise.exerciseType) {
+      case ExerciseType.DURATION:
+        if (exercise.duration) {
+        calories = exercise.duration * caloriesPerMinute;
+      }
+      break;
+
+      case ExerciseType.WEIGHT:
+        if (exercise.reps && exercise.sets) {
+        calories = exercise.reps * exercise.sets * caloriesPerRep;
+      }
+      break;
+
+      default:
+        throw new Error(`Unknown exercise type: ${exercise.exerciseType}`);
+    }
+
+    return calories;
+  }
+}

src/modules/users/modules/home/services/user-home.service.ts

@@ -3,8 +3,21 @@ import { faker } from '@faker-js/faker';
 import { UserHomeYourDailyIntakeSerialization } from "../responses/user-home-your-daily-intake.serialization";
 import { UserHomeDailyGoalsSerialization } from "../responses/user-home-daily-goals.serialization";
 import { UserNutriHomeDailyGoalsSerialization } from "../responses/user-nutri-home-daily-goals.serialization";
+import { UserService } from "../../users/services/users.service";
+import { Types } from "mongoose";
+import { UserActivitiesService } from "../../activities/services/user-activities.service";
+import { ActivityType } from "@common/enums/activity-type.enum";
+import { ExerciseService } from "../../exercises/services/exercises.service";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { MealsService } from "../../meals/services/meals.service";
+import { calcAge } from "@lib/utils/age";
 
 export class UserHomeService {
+  private userService = new UserService();
+  private activitiesService = new UserActivitiesService();
+  private exercisesService = new ExerciseService();
+  private mealsService = new MealsService();
+
   private getDaysArray(startDate: Date, endDate: Date): string[] {
     const days = [];
     for (let day = startDate; day <= endDate; day.setDate(day.getDate() + 1)) {
@@ -13,15 +26,30 @@ export class UserHomeService {
     return days;
   }
 
-  async getDailyGoals(_userId: string): Promise<UserHomeDailyGoalsSerialization> {
-    const waterGoal = faker.number.int({ min: 29, max: 100 });
-    const waterConsumed = faker.number.int({ min: 0, max: waterGoal });
+  async getDailyGoals(userId: string): Promise<UserHomeDailyGoalsSerialization> {
+    const user = await this.userService.findOneOrFail({_id: new Types.ObjectId(userId)});
+    const todaysExerciseActivities = await this.activitiesService.model.find({
+      user_id: new Types.ObjectId(userId),
+      activity_type: ActivityType.EXERCISE,
+      $and: [
+        { created_at: { $gte: new Date(new Date().setHours(0, 0, 0, 0)) } },
+        { created_at: { $lte: new Date(new Date().setHours(23, 59, 59, 999)) } },
+      ],
+    });
+    const todaysExercisesIds = todaysExerciseActivities.map(a => a.related_id);
+    
+    const todaysExercises = await this.exercisesService.model.find({
+      _id: { $in: todaysExercisesIds },
+    });
+
+    const waterGoal = (user.weight || 1) * 2;
+    const waterConsumed = Math.round(waterGoal * 0.72);
 
-    const stepsGoal = faker.number.int({ min: 29, max: 100 });
-    const stepsDone = faker.number.int({ min: 0, max: stepsGoal });
+    const stepsGoal = (user.height || 1) * 100;
+    const stepsDone = Math.round(stepsGoal * 0.78);
 
-    const exercisesCals = faker.number.int({ min: 29, max: 100 });
-    const exercisesHours = faker.number.int({ min: 29, max: 100 });
+    const exercisesCals = todaysExercises.reduce((acc, curr) => acc + this.exercisesService.calculateCalories(curr), 0);
+    const exercisesHours = todaysExercises.reduce((acc, curr) => acc + curr.duration || curr.expectedDurationRange?.min || 0, 0) /60;
 
     return {
       waterGoal,
@@ -33,19 +61,66 @@ export class UserHomeService {
     }
   }
 
-  async getHomePageYourDailyIntake(_userId: string): Promise<UserHomeYourDailyIntakeSerialization>{
-    const caloriesGoal = faker.number.int({ min: 29, max: 100 });
-    const caloriesLeft = faker.number.int({ min: 0, max: caloriesGoal});
-    const caloriesBurned = caloriesGoal - caloriesLeft;
+  async getHomePageYourDailyIntake(userId: string): Promise<UserHomeYourDailyIntakeSerialization>{
+    const user = await this.userService.findOneOrFail({_id: new Types.ObjectId(userId)});
+    const goalToCalsMap = {}
+    const goalToCarbsMap = {}
+    const goalToProteinMap = {}
+    const goalToFatMap = {}
+    goalToCalsMap[FitnessGoal.GET_FITTER] = 2000;
+    goalToCalsMap[FitnessGoal.LOSE_WEIGHT] = 1500;
+    goalToCalsMap[FitnessGoal.GAIN_MUSCLE] = 2500;
+    goalToCarbsMap[FitnessGoal.GET_FITTER] = 50;
+    goalToCarbsMap[FitnessGoal.LOSE_WEIGHT] = 30;
+    goalToCarbsMap[FitnessGoal.GAIN_MUSCLE] = 60;
+    goalToProteinMap[FitnessGoal.GET_FITTER] = 30;
+    goalToProteinMap[FitnessGoal.LOSE_WEIGHT] = 40;
+    goalToProteinMap[FitnessGoal.GAIN_MUSCLE] = 50;
+    goalToFatMap[FitnessGoal.GET_FITTER] = 20;
+    goalToFatMap[FitnessGoal.LOSE_WEIGHT] = 30;
+    goalToFatMap[FitnessGoal.GAIN_MUSCLE] = 20;
+
+    const caloriesGoal = goalToCalsMap[user.preferences?.fitness_goal] || 2000;
+
+    const todaysExerciseActivities = await this.activitiesService.model.find({
+      user_id: new Types.ObjectId(userId),
+      activity_type: ActivityType.EXERCISE,
+      $and: [
+        { created_at: { $gte: new Date(new Date().setHours(0, 0, 0, 0)) } },
+        { created_at: { $lte: new Date(new Date().setHours(23, 59, 59, 999)) } },
+      ],
+    });
+    const todaysExercisesIds = todaysExerciseActivities.map(a => a.related_id);
+    
+    const todaysExercises = await this.exercisesService.model.find({
+      _id: { $in: todaysExercisesIds },
+    });
+
+    const todaysMealsActivities = await this.activitiesService.model.find({
+      user_id: new Types.ObjectId(userId),
+      activity_type: ActivityType.MEAL,
+      $and: [
+        { created_at: { $gte: new Date(new Date().setHours(0, 0, 0, 0)) } },
+        { created_at: { $lte: new Date(new Date().setHours(23, 59, 59, 999)) } },
+      ],
+    });
+    const todaysMealsIds = todaysMealsActivities.map(a => a.related_id);
+
+    const todaysMeals = await this.mealsService.model.find({
+      _id: { $in: todaysMealsIds },
+    });
+
+    const caloriesBurned = todaysExercises.reduce((acc, curr) => acc + this.exercisesService.calculateCalories(curr), 0);
+    const caloriesLeft = caloriesGoal - caloriesBurned;
 
-    const carbsGoal = faker.number.int({ min: 29, max: 100 });
-    const carbsConsumed = faker.number.int({ min: 0, max: carbsGoal });
+    const carbsGoal = goalToCarbsMap[user.preferences?.fitness_goal] || 50;
+    const carbsConsumed = todaysMeals.reduce((acc, curr) => acc + curr.carbs, 0);
 
-    const proteinGoal = faker.number.int({ min: 29, max: 100 });
-    const proteinConsumed = faker.number.int({ min: 0, max: proteinGoal });
+    const proteinGoal = goalToProteinMap[user.preferences?.fitness_goal] || 30;
+    const proteinConsumed = todaysMeals.reduce((acc, curr) => acc + curr.proteins, 0);
 
-    const fatGoal = faker.number.int({ min: 29, max: 100 });
-    const fatConsumed = faker.number.int({ min: 0, max: fatGoal });
+    const fatGoal = goalToFatMap[user.preferences?.fitness_goal] || 20;
+    const fatConsumed = todaysMeals.reduce((acc, curr) => acc + curr.fats, 0);
 
     return {
       caloriesGoal,
@@ -60,21 +135,30 @@ export class UserHomeService {
     }
   }
 
-  async getHomePageStreak(_userId: string, startDate: Date, endDate: Date): Promise<HomeStreakSerialization> {
+  async getHomePageStreak(userId: string, startDate: Date, endDate: Date): Promise<HomeStreakSerialization> {
     // list day names in between the start and end date
+    //
+    const activities = await this.activitiesService.model.find({
+      user_id: new Types.ObjectId(userId),
+      $and: [
+        { created_at: { $gte: startDate } },
+        { created_at: { $lte: endDate } },
+      ],
+    });
     const days = this.getDaysArray(startDate, endDate);
 
     return {
       days: days.map(day => ({
         day: day,
-        points: faker.number.int({ min: 0, max: 100 }),
+        points: activities.filter(a => a.created_at.toLocaleString('en-US', { weekday: 'long' }).toLowerCase() === day).length,
       })),
     }
   }
 
   async getNutriHomeDailyGoals(userId: string): Promise<UserNutriHomeDailyGoalsSerialization> {
-    const sleepGoal = faker.number.int({ min:29, max: 100 })
-    const sleepDone = faker.number.int({ min:0, max: sleepGoal })
+    const user = await this.userService.findOneOrFail({_id: new Types.ObjectId(userId)});
+    const sleepGoal = calcAge(user.dob) < 18 ? 8 : 7;
+    const sleepDone = Math.round(sleepGoal * 0.8);
 
     return {
       ...(await this.getDailyGoals(userId)),

src/modules/users/modules/meals/events/meal-done.event.ts

@@ -0,0 +1,18 @@
+import { ActivityType } from "@common/enums/activity-type.enum";
+import { Activity, IActivity } from "@common/models/activity.model";
+import { EventsManager } from "@lib/events/events-manager";
+import { Types } from "mongoose";
+
+export class MealDoneEvent {
+  constructor(public userId: string, public mealId: string){}
+}
+
+EventsManager.on(MealDoneEvent.name, async (event: MealDoneEvent) => {
+  console.log(`Meal done event for user ${event.userId}`);
+
+  Activity.create({
+    user_id: new Types.ObjectId(event.userId),
+    related_id: new Types.ObjectId(event.mealId),
+    activity_type: ActivityType.MEAL,
+  } satisfies IActivity).catch(console.error);
+});

src/modules/users/modules/meals/events/meals-done.event.ts

@@ -0,0 +1,22 @@
+import { ActivityType } from "@common/enums/activity-type.enum";
+import { Activity, IActivity } from "@common/models/activity.model";
+import { EventsManager } from "@lib/events/events-manager";
+import { Types } from "mongoose";
+
+export class MealsDoneEvent {
+  constructor(public userId: string, public mealsIds: string[]){}
+}
+
+EventsManager.on(MealsDoneEvent.name, async (event: MealsDoneEvent) => {
+  console.log(`Meal done event for user ${event.userId}`);
+
+  await Promise.all(
+    event.mealsIds.map(mId => {
+      Activity.create({
+        user_id: new Types.ObjectId(event.userId),
+        related_id: new Types.ObjectId(mId),
+        activity_type: ActivityType.MEAL,
+      } satisfies IActivity).catch(console.error);
+    })
+  )
+});

src/modules/users/modules/meals/services/meals.service.ts

@@ -4,14 +4,14 @@ import { IEatCustomMeal } from "../validations/eat-custom-meal.validation";
 import { EventsManager } from "@lib/events/events-manager";
 import { Ingredient } from "@common/models/ingredient.model";
 import { HttpError } from "@lib/error-handling/http-error";
-import { ActivityType } from "@common/enums/activity-type.enum";
-import { EatCustomMealEvent } from "../events/eat-custom-meal.event";
 import { Types } from "mongoose";
+import { MealDoneEvent } from "../events/meal-done.event";
+import { MealType } from "@common/enums/meal-type.enum";
 
 export class MealsService extends CrudService(Meal) {
-    async eatCustomMeal(id: string, body: IEatCustomMeal) {
+    async eatCustomMeal(userId: string, body: IEatCustomMeal) {
       // Validate ingredients
-      await Promise.all(
+      const customMealIngs = await Promise.all(
         body.ingredients.map(async i => {
           const ing = await Ingredient.findOne({ _id: new Types.ObjectId(i.id) });
           if(!ing) throw new HttpError(404, `Ingredient with id ${i} not found`);
@@ -20,8 +20,21 @@ export class MealsService extends CrudService(Meal) {
             noServings: i.noServings,
           };
         })
-      )
+      );
 
-      EventsManager.emit(ActivityType.EAT_CUSTOM_MEAL, new EatCustomMealEvent(id, body.ingredients));
+      // Create meal
+      const meal = await this.create({
+        name: `${(new Date()).toISOString()} - Custom Meal - ${userId}`,
+        image: "https://via.placeholder.com/150",
+        type: MealType.CUSTOM,
+        ingredients: customMealIngs.map(i => i.ingredient._id),
+        calories: customMealIngs.reduce((acc, curr) => acc + curr.ingredient.calories * curr.noServings, 0),
+        proteins: customMealIngs.reduce((acc, curr) => acc + curr.ingredient.proteins * curr.noServings, 0),
+        carbs: customMealIngs.reduce((acc, curr) => acc + curr.ingredient.carbs * curr.noServings, 0),
+        fats: customMealIngs.reduce((acc, curr) => acc + curr.ingredient.fats * curr.noServings, 0),
+        isDeleted: true,
+      });
+
+      EventsManager.emit(MealDoneEvent.name, new MealDoneEvent(userId, meal._id.toString()));
     }
 }

src/modules/users/modules/user-registered-meal-plans/services/meal-plans-progress.service.ts

@@ -2,6 +2,8 @@ import { UserRegisteredMealPlan } from "@common/models/user-registered-meal-plan
 import { CrudService } from "@lib/services/crud.service";
 import { HttpError } from "@lib/error-handling/http-error";
 import { MealPlansService } from "../../meal-plans/services/meal-plans.service";
+import { EventsManager } from "@lib/events/events-manager";
+import { MealsDoneEvent } from "../../meals/events/meals-done.event";
 
 export class MealPlansProgressService extends CrudService(UserRegisteredMealPlan) {
   private mealPlansService = new MealPlansService()
@@ -33,6 +35,8 @@ export class MealPlansProgressService extends CrudService(UserRegisteredMealPlan
       this.mealPlansService.createModelMealPlan(userId)
     }
 
+    EventsManager.emit(MealsDoneEvent.name, new MealsDoneEvent(userId, day.meals.map(e => e.toString())));
+
     return updatedMealPlan;
   }
 }

src/modules/users/modules/user-registered-workouts/services/workouts-progress.service.ts

@@ -3,6 +3,8 @@ import { CrudService } from "@lib/services/crud.service";
 import { IUpdateUserRegisteredWorkouts } from "../validations/update-user-registered-workouts.validation";
 import { HttpError } from "@lib/error-handling/http-error";
 import { WorkoutService } from "../../workouts/services/workouts.service";
+import { EventsManager } from "@lib/events/events-manager";
+import { ExercisesDoneEvent } from "../../exercises/events/exercises-done.event";
 
 export class WorkoutsProgressService extends CrudService(UserRegisteredWorkout, {
   defaultFilter: {
@@ -38,6 +40,8 @@ export class WorkoutsProgressService extends CrudService(UserRegisteredWorkout,
     if(weekIndex === workout.weeks.length - 1) {
       await this.workoutsService.createModelWorkout(userId)
     }
+
+    EventsManager.emit(ExercisesDoneEvent.name, new ExercisesDoneEvent(userId, day.exercises.map(e => e.toString())));
     
     // save changes
     workout.markModified('weeks');