Merge pull request #92 from Modarb-Ai-Trainer/models-server

.gitignore

@@ -1,3 +1,5 @@
 node_modules/
 dist/
-.env
+.env
+env/
+__pycache__/

models-server/models/fitness_model.py

@@ -0,0 +1,259 @@
+from sklearn.preprocessing import OneHotEncoder
+import random
+import pandas as pd
+import os
+import pickle
+
+SERVER_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
+FITNESS_MODEL_PATH = os.path.join(
+    SERVER_FILE_DIR, *"../resources/models/fitness_model.pkl".split("/")
+)
+
+
+class FitnessModel:
+    def __init__(self, excercise_path, kmeans_path, plan_classifier_path):
+        self.data = pd.read_csv(excercise_path)
+        self.kmeans = None
+        self.plan_classifier = None
+        self.encoder = None
+        self.cluster_data = {}
+        self.X_train_cols = [
+            "level_Advanced",
+            "level_Beginner",
+            "level_Intermediate",
+            "goal_ Get Fitter",
+            "goal_ Lose Weight",
+            "goal_Gain Muscle",
+            "goal_Get Fitter",
+            "goal_Increase Endurance",
+            "goal_Increase Strength",
+            "goal_Sports Performance",
+            "gender_Female",
+            "gender_Male",
+            "gender_Male & Female",
+        ]
+
+        # Load kmeans model
+        with open(kmeans_path, "rb") as f:
+            self.kmeans = pickle.load(f)
+
+        # Load plan classifier model
+        with open(plan_classifier_path, "rb") as f:
+            self.plan_classifier = pickle.load(f)
+
+        # Iterate over each cluster label
+        for cluster_label in range(90):
+            # Filter the dataset to get data for the current cluster
+            cluster_subset = self.data[self.data["cluster"] == cluster_label]
+
+            # Add the cluster data to the dictionary
+            self.cluster_data[cluster_label] = cluster_subset
+
+        features = self.data[["Level", "goal", "bodyPart"]]
+
+        # Perform one-hot encoding for categorical features
+        self.encoder = OneHotEncoder(sparse=False)
+        encoded_features = self.encoder.fit_transform(features)
+
+    def choose_plan(self, level, goal, gender):
+        global plan_classifier
+        # Convert input into a DataFrame
+        input_data = pd.DataFrame(
+            {"level": [level], "goal": [goal], "gender": [gender]}
+        )
+
+        # One-hot encode the input data
+        input_encoded = pd.get_dummies(input_data, columns=["level", "goal", "gender"])
+
+        # Ensure that input has the same columns as the model was trained on
+        # This is necessary in case some categories are missing in the input
+        missing_cols = set(self.X_train_cols) - set(input_encoded.columns)
+        for col in missing_cols:
+            input_encoded[col] = 0
+
+        # Reorder columns to match the order of columns in X_train
+        input_encoded = input_encoded[self.X_train_cols]
+
+        # Make prediction for the given input using the trained model
+        prediction = self.plan_classifier.predict(input_encoded)
+
+        # Convert each string in the list to a list of strings
+        daily_activities_lists = [day.split(", ") for day in prediction[0]]
+
+        return daily_activities_lists
+
+    def get_daily_recommendation(self, home_or_gym, level, goal, bodyParts, equipments):
+        if goal in ["Lose Weight", "Get Fitter"]:
+            goal = "Get Fitter & Lose Weight"
+        daily_recommendations = []
+
+        bodyParts = [bp for bp in bodyParts if "-" not in bp]
+        # Repeat elements in bodyParts until it reaches a size of 6
+        while len(bodyParts) < 6:
+            bodyParts += bodyParts
+
+        # Limit bodyParts to size 6
+        bodyParts = bodyParts[:6]
+
+        for bodyPart in bodyParts:
+            # Predict cluster for the specified combination of goal, level, and body part
+            input_data = [[level, goal, bodyPart]]
+            predicted_cluster = self.kmeans.predict(self.encoder.transform(input_data))[
+                0
+            ]
+            print(predicted_cluster)
+            # Get data for the predicted cluster
+            cluster_subset = self.cluster_data[predicted_cluster]
+
+            # Filter data based on location (home or gym)
+            if home_or_gym == 0:
+                cluster_subset = cluster_subset[
+                    ~cluster_subset["equipment"].isin(equipments)
+                ]
+
+            # Randomly select one exercise from the cluster if any left after equipment filtering
+            if not cluster_subset.empty:
+                selected_exercise = random.choice(
+                    cluster_subset.to_dict(orient="records")
+                )
+                daily_recommendations.append(selected_exercise)
+
+        # Remove duplicates from the list
+        unique_recommendations = []
+        seen_names = set()
+        for exercise in daily_recommendations:
+            if exercise["name"] not in seen_names:
+                unique_recommendations.append(exercise)
+                seen_names.add(exercise["name"])
+
+        return unique_recommendations
+
+    def get_gender_adjustment(self, gender):
+        return 1.0 if gender == "Male" else 0.7
+
+    def get_age_adjustment(self, age):
+        if age < 30:
+            return 1.0
+        elif 30 <= age < 50:
+            return 0.5
+        else:
+            return 0.1
+
+    def get_level_adjustment(self, level):
+        if level == "Beginner":
+            return 0.8
+        elif level == "Intermediate":
+            return 1.0
+        elif level == "Advanced":
+            return 1.2
+
+    def get_body_part_adjustment(self, body_part):
+        body_parts = {
+            "chest": 1,
+            "shoulders": 0.8,
+            "waist": 0.6,
+            "upper legs": 0.7,
+            "back": 0.9,
+            "lower legs": 0.5,
+            "upper arms": 0.8,
+            "cardio": 0.7,
+            "lower arms": 0.6,
+            "neck": 0.5,
+        }
+        return body_parts.get(body_part, 0)
+
+    def adjust_workout(self, gender, age, feedback, body_part, level, old_weight):
+        gender_adjustment = self.get_gender_adjustment(gender)
+        age_adjustment = self.get_age_adjustment(age)
+        level_adjustment = self.get_level_adjustment(level)
+        body_part_adjustment = self.get_body_part_adjustment(body_part)
+
+        increasing_factor_of_weight = (
+            age_adjustment
+            * body_part_adjustment
+            * gender_adjustment
+            * level_adjustment
+            * 0.3
+        )
+
+        if not feedback:
+            increasing_factor_of_weight = (1 - increasing_factor_of_weight) * -0.1
+
+        new_weight = old_weight + increasing_factor_of_weight * old_weight
+
+        return new_weight
+
+    def calculate_new_repetition(self, level, goal):
+        if goal in ["Lose Weight", "Get Fitter"]:
+            if level == "Beginner":
+                return 15
+            elif level == "Intermediate":
+                return 12
+            elif level == "Expert":
+                return 10
+        elif goal == "Gain Muscle":
+            if level == "Beginner":
+                return 10
+            elif level == "Intermediate":
+                return 8
+            elif level == "Advanced":
+                return 6
+
+    def calculate_new_duration(self, level):
+
+        if level == "Beginner":
+            return 20
+        elif level == "Intermediate":
+            return 50
+        elif level == "Advanced":
+            return 80
+
+    def predict(
+        self, home_or_gym, level, goal, gender, age, feedback, old_weight, equipments
+    ):
+
+        plan = self.choose_plan(level, goal, gender)
+        print(plan)
+
+        while len(plan) < 30:
+            plan.extend(plan)
+        plan = plan[:30]
+
+        all_recommendations = []
+        for day_body_parts in plan:
+            daily_exercises = self.get_daily_recommendation(
+                home_or_gym, level, goal, day_body_parts, equipments
+            )
+            daily_recommendations = []
+
+            for exercise in daily_exercises:
+                weights = self.adjust_workout(
+                    gender, age, feedback, exercise["bodyPart"], level, old_weight
+                )
+                repetitions = self.calculate_new_repetition(level, goal)
+                duration = self.calculate_new_duration(level)
+                weights_or_duration = (
+                    weights if exercise["type"] == "weight" else duration
+                )
+                exercise_recommendations = {
+                    "name": exercise["name"],
+                    "type": exercise["type"],
+                    "equipment": exercise["equipment"],
+                    "bodyPart": exercise["bodyPart"],
+                    "target": exercise["target"],
+                    "weights_or_duration": weights_or_duration,
+                    "sets": exercise["sets"],
+                    "repetitions": repetitions,
+                }
+                daily_recommendations.append(exercise_recommendations)
+            all_recommendations.append(daily_recommendations)
+
+        return all_recommendations  # Trim to ensure exactly 30 elements
+
+    @classmethod
+    def load(cls):
+
+        with open(FITNESS_MODEL_PATH, "rb") as f:
+            fitness_model = pickle.load(f)
+
+        return fitness_model

models-server/models/nutrition_model.py

@@ -0,0 +1,94 @@
+import random 
+import pandas as pd
+import numpy as np 
+import pickle
+import sys
+import os
+import pickle
+
+SERVER_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
+NUTRITION_MODEL_PATH = os.path.join(
+    SERVER_FILE_DIR, *"../resources/models/nutrition_model.pkl".split("/")
+)
+
+
+class NutritionModel:
+    def generate_plan(self,calories):
+        the_model = self.nutrition_model
+        lunch_attr = {"Calories":calories*0.5, 
+        "FatContent":random.uniform(19, 97), 
+        "SaturatedFatContent":random.uniform(6, 12), 
+        "CholesterolContent": random.uniform(77, 299), 
+        "SodiumContent":random.uniform(565, 2299), 
+        "CarbohydrateContent":random.uniform(28, 317), 
+        "FiberContent": random.uniform(2, 38), 
+        "SugarContent": random.uniform(0, 38),
+        "ProteinContent":random.uniform(20, 123)}
+        
+        lunch_df = pd.DataFrame(lunch_attr, index=[0])
+        
+        breakfast_attr = {"Calories":calories*0.30, 
+        "FatContent":random.uniform(8.7, 20), 
+        "SaturatedFatContent":random.uniform(1.7, 3.7), 
+        "CholesterolContent": random.uniform(0, 63), 
+        "SodiumContent":random.uniform(163, 650), 
+        "CarbohydrateContent":random.uniform(23, 56), 
+        "FiberContent": random.uniform(2.6, 8), 
+        "SugarContent": random.uniform(3.5, 13),
+        "ProteinContent":random.uniform(6, 25)}
+        
+        breakfast_df = pd.DataFrame(breakfast_attr, index=[0])
+        
+        dinner_attr = {"Calories":calories*0.30, 
+        "FatContent":random.uniform(15, 33), 
+        "SaturatedFatContent":random.uniform(6, 8), 
+        "CholesterolContent": random.uniform(22, 86), 
+        "SodiumContent":random.uniform(265, 775), 
+        "CarbohydrateContent":random.uniform(14, 44), 
+        "FiberContent": random.uniform(101, 110), 
+        "SugarContent": random.uniform(3, 13),
+        "ProteinContent":random.uniform(11, 25)}
+        
+        dinner_df = pd.DataFrame(dinner_attr, index=[0])
+        
+        snack_attr = {"Calories":random.uniform(90, 190), 
+        "FatContent":random.uniform(1.7, 10), 
+        "SaturatedFatContent":random.uniform(0.7, 3), 
+        "CholesterolContent": random.uniform(2, 16), 
+        "SodiumContent":random.uniform(47, 200), 
+        "CarbohydrateContent":random.uniform(10, 31), 
+        "FiberContent": random.uniform(0.4, 2.5), 
+        "SugarContent": random.uniform(5.7, 21),
+        "ProteinContent":random.uniform(3, 20)}
+        
+        snack_df = pd.DataFrame(snack_attr, index=[0])
+        
+        drinks_attr = {"Calories":random.uniform(60, 125), 
+        "FatContent":random.uniform(0.2, 0.6), 
+        "SaturatedFatContent":random.uniform(0, 0.1), 
+        "CholesterolContent": random.uniform(0, 0.1), 
+        "SodiumContent":random.uniform(3.5, 51), 
+        "CarbohydrateContent":random.uniform(14, 30), 
+        "FiberContent": random.uniform(0.2, 3.6), 
+        "SugarContent": random.uniform(109, 122),
+        "ProteinContent":random.uniform(0.4, 6)}
+        
+        drink_df = pd.DataFrame(drinks_attr, index=[0])
+        
+        lunch = the_model.transform(lunch_df)
+        breakfast = the_model.transform(breakfast_df)
+        dinner = the_model.transform(dinner_df)
+        snack = the_model.transform(snack_df)
+        drink = the_model.transform(drink_df)
+
+        meals = np.concatenate((breakfast, lunch, dinner, snack, drink), axis=0)
+        meals = np.transpose(meals)
+        
+        return meals
+    
+
+    def load(self):
+
+        with open(NUTRITION_MODEL_PATH, "rb") as f:
+            self.nutrition_model = pickle.load(f)
+

models-server/resources/models/fitness_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:665d34c71c506fa1cdbd8d74b54f6ca84f1b9f5a397a6bb90d608cc699f2a61d
+size 95457799

models-server/resources/models/nutrition_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cd0dc84cc9dcc0c985725e8d5cda8d9f9b0571c6c3219bdef2309f177b46ae1
+size 258480

models-server/server.py

@@ -0,0 +1,63 @@
+from flask import Flask, request, jsonify
+from dotenv import load_dotenv
+import os
+from models.fitness_model import FitnessModel
+from models.nutrition_model import NutritionModel
+
+load_dotenv()
+
+
+HOST = os.getenv("MODELS_HOST") or "127.0.0.1"
+PORT = os.getenv("MODELS_PORT") or "3030"
+
+
+fitness_model = FitnessModel.load()
+nutrition_model = NutritionModel()
+nutrition_model.load()
+app = Flask("model-server")
+
+
+@app.get("/")
+def health():
+    return "I'm alive!!"
+
+
+@app.post("/fitness")
+def fitness_predict():
+    paramNames = [
+        "home_or_gym",
+        "level",
+        "goal",
+        "gender",
+        "age",
+        "feedback",
+        "old_weight",
+        "equipments",
+    ]
+
+    params = {}
+    for paramName in paramNames:
+        value = request.json.get(paramName)
+        if value is None:
+            return jsonify({"error": f"{paramName} is missing"}), 400
+        params[paramName] = value
+
+    return jsonify({"result": fitness_model.predict(**params)})
+
+
+@app.post("/nutrition")
+def nutrition_predict():
+    paramNames = ["calories"]
+
+    params = {}
+    for paramName in paramNames:
+        value = request.json.get(paramName)
+        if value is None:
+            return jsonify({"error": f"{paramName} is missing"}), 400
+        params[paramName] = value
+    print("nutrition_model", nutrition_model.generate_plan(**params), type(nutrition_model.generate_plan(**params)))
+    return jsonify({"result": list(nutrition_model.generate_plan(**params))})
+
+
+if __name__ == "__main__":
+    app.run(host=HOST, port=PORT, debug=True)

requirements.txt

@@ -0,0 +1,7 @@
+Flask>=3.0.0,<4.0.0
+anakin-language-server>=1.0.0,<2.0.0
+python-dotenv>=1.0.0,<2.0.0
+scikit-learn>=1.2.0,<1.3.0
+black>=24.0.0,<25.0.0
+pandas>=2.2.0,<2.3.0
+python-dotenv>=1.0.0,<2.0.0

src/common/models/user.model.ts

@@ -17,7 +17,7 @@ export interface IUser {
   password: string;
   image: string;
   role: AuthenticatableType;
-  gender: string;
+  gender: Gender;
   dob: Date;
   height: number;
   weight: number;

src/common/models/workout.model.ts

@@ -30,7 +30,8 @@ export interface IWorkout {
                 },
             ],
         },
-    ]
+    ],
+    aiGenerated: boolean;
 }
 
 const workoutSchema = new Schema({
@@ -60,10 +61,11 @@ const workoutSchema = new Schema({
                 },
             ],
         },
-    ]
+    ],
+    aiGenerated: { type: Boolean, required: true, default: false },
 });
 
 
 export type WorkoutDocument = IWorkout & mongoose.Document;
 
-export const Workout = mongoose.model<WorkoutDocument>("workouts", workoutSchema);
+export const Workout = mongoose.model<WorkoutDocument>("workouts", workoutSchema);

src/configs/config.ts

@@ -14,6 +14,7 @@ export interface Config {
     expiresIn: string;
   };
   saltRounds: number;
+  modelsServerUrl: string;
 }
 
 export const config: Config = {
@@ -28,4 +29,5 @@ export const config: Config = {
     expiresIn: Env.get("JWT_EXPIRES_IN").toString(),
   },
   saltRounds: Env.get("SALT_ROUNDS", 5).toNumber(),
+  modelsServerUrl: `${Env.get("MODELS_HOST", 'http://127.0.0.1').toString()}:${Env.get("MODELS_PORT", '3030').toString()}`,
 };

src/lib/models/fitness-model.ts

@@ -0,0 +1,59 @@
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Gender } from "@common/enums/gender.enum";
+import { config } from "@configs/config";
+
+const endpoint = '/fitness';
+
+export interface IFitnessPredictionItem {
+  bodyPart: string;
+  equipment: string;
+  name: string;
+  repetitions: number;
+  sets: number;
+  target: string;
+  type: string;
+  weights_or_duration: number;
+}
+
+// Fitness Workout Params
+export interface IFWParams {
+  home_or_gym: 0 | 1; // 0 for home, 1 for gym
+  level: FitnessLevel;
+  goal: FitnessGoal;
+  gender: Gender;
+  age: number;
+  feedback: boolean;
+  old_weight: number;
+  equipments: string[];
+}
+
+export class FitnessModel {
+  public static async predictWorkout(
+    params: IFWParams
+  ): Promise<IFitnessPredictionItem[][]> {
+    params.level = params.level.split(' ').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' ') as FitnessLevel;
+    params.goal = params.goal.split(' ').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' ') as FitnessGoal;
+    params.gender = params.gender.toUpperCase() as Gender;
+
+    const response = await fetch(
+      `${config.modelsServerUrl}${endpoint}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(params),
+      }
+    );
+
+    if (!response.ok) {
+      console.error(await response.text());
+      throw new Error("Failed to fetch data from the server");
+    }
+
+    return response.json().then((data) => {
+      return data.result;
+    });
+  }
+}

src/lib/services/crud.service.ts

@@ -3,7 +3,10 @@ import { AnyKeys, Document, FilterQuery, Model } from "mongoose";
 
 
 export const CrudService = <ModelDoc extends Document>(
-  model: Model<ModelDoc>
+  model: Model<ModelDoc>,
+  crudOptions?: {
+    defaultFilter?: FilterQuery<ModelDoc>;
+  }
 ) => {
   return class CrudServiceClass {
     protected model: Model<ModelDoc> = model;
@@ -16,6 +19,7 @@ export const CrudService = <ModelDoc extends Document>(
       filter: FilterQuery<ModelDoc>,
       data: AnyKeys<ModelDoc>
     ): Promise<ModelDoc> {
+      filter = { ...crudOptions?.defaultFilter, ...filter };
       await this.existsOrThrow(filter);
       await this.model.updateOne(filter, data);
       return this.findOneOrFail(filter);
@@ -25,12 +29,14 @@ export const CrudService = <ModelDoc extends Document>(
       filter: FilterQuery<ModelDoc>,
       data: AnyKeys<ModelDoc>
     ): Promise<ModelDoc[]> {
+      filter = { ...crudOptions?.defaultFilter, ...filter };
       await this.existsOrThrow(filter);
       await this.model.updateMany(filter, data);
       return this.model.find(filter);
     }
 
     async deleteOne(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+      filter = { ...crudOptions?.defaultFilter, ...filter };
       await this.existsOrThrow(filter);
       return this.model.findOneAndDelete(filter);
     }
@@ -57,6 +63,8 @@ export const CrudService = <ModelDoc extends Document>(
       };
     }> {
       if (options?.filterOptions) filter = { ...filter, ...options.filterOptions };
+      filter = { ...crudOptions?.defaultFilter, ...filter };
+      
       const queryInstruction = this.model
         .find(filter)
         .limit(paginationOptions.limit)
@@ -74,6 +82,18 @@ export const CrudService = <ModelDoc extends Document>(
       return { docs, paginationData };
     }
 
+    async listAll(
+      filter: FilterQuery<ModelDoc>,
+      options?: {
+        populateArray: any
+      },
+    ): Promise<ModelDoc[]> {
+      filter = { ...crudOptions?.defaultFilter, ...filter };
+      const queryInstruction = this.model.find(filter);
+      if (options?.populateArray) queryInstruction.populate(options.populateArray);
+      return queryInstruction;
+    }
+
     async search(
       filter: FilterQuery<ModelDoc>,
       paginationOptions: {
@@ -94,6 +114,7 @@ export const CrudService = <ModelDoc extends Document>(
         perPage: number;
       };
     }> {
+      filter = { ...crudOptions?.defaultFilter, ...filter };
       const queryInstruction = this.model
         .find(filter)
         .limit(paginationOptions.limit)
@@ -116,7 +137,7 @@ export const CrudService = <ModelDoc extends Document>(
       options?: {
         populateArray: any
       }): Promise<ModelDoc | null> {
-      const queryInstruction = this.model.findOne(filter);
+      const queryInstruction = this.model.findOne();
       if (options?.populateArray) queryInstruction.populate(options.populateArray);
       const document = await queryInstruction
       return document;

src/lib/utils/age.ts

@@ -0,0 +1,5 @@
+export const calcAge = (dob: Date): number => {
+  const diff = Date.now() - dob.getTime();
+  const ageDate = new Date(diff);
+  return Math.abs(ageDate.getUTCFullYear() - 1970);
+}

src/modules/users/modules/auth/services/users-auth.service.ts

@@ -5,13 +5,18 @@ import { JwtHelper } from "@helpers/jwt.helper";
 import { User } from "@common/models/user.model";
 import { IUserRegister } from "@common/validations/user-register.validation";
 import { CrudService } from "@lib/services/crud.service";
+import { WorkoutService } from "../../workouts/services/workouts.service";
 
 export class UsersAuthService extends CrudService(User) {
+  private workoutsService = new WorkoutService();
+
   async register(createParams: IUserRegister) {
     if (createParams.password !== createParams.confirmPassword) {
       throw new HttpError(400, "passwords do not match");
     }
-    return this.create(createParams);
+    const user = await this.create(createParams);
+    await this.workoutsService.createModelWorkout(user);
+    return user;
   }
 
   async login(loginRequest: ILogin) {

src/modules/users/modules/user-registered-workouts/controllers/user-registered-workouts.controller.ts

@@ -1,5 +1,5 @@
 import { UserRegisteredWorkoutsService } from "../services/user-registered-workouts.service";
-import { Request, Response } from "express";
+import { Response } from "express";
 import { JsonResponse } from "@lib/responses/json-response";
 import { parsePaginationQuery } from "@helpers/pagination";
 import { bodyValidator } from "@helpers/validation.helper";
@@ -21,13 +21,10 @@ import { SwaggerSummary } from "@lib/decorators/swagger-summary.decorator";
 import { SwaggerDescription } from "@lib/decorators/swagger-description.decorator";
 import { SwaggerResponse } from "@lib/decorators/swagger-response.decorator";
 import { SwaggerRequest } from "@lib/decorators/swagger-request.decorator";import { updateUserRegisteredWorkoutsSchema } from "../validations/update-user-registered-workouts.validation";
+import { IUserRequest } from "@common/interfaces/user-request.interface";
  4
 
 
-interface userRequest extends Request {
-  jwtPayload?: any;
-}
-
 @Controller("/user/myWorkouts")
 @ControllerMiddleware(UsersGuardMiddleware())
 export class userRegisteredWorkoutsController extends BaseController {
@@ -52,7 +49,7 @@ export class userRegisteredWorkoutsController extends BaseController {
   @SwaggerResponse([UserRegisteredWorkoutsPopulateSerialization])
   @SwaggerSummary("List my workouts")
   @SwaggerDescription("List all user registered workouts (workouts that the user had started)")
-  list = async (req: userRequest, res: Response) => {
+  list = async (req: IUserRequest, res: Response) => {
     const paginationQuery = parsePaginationQuery(req.query);
     const { docs, paginationData } =
       await this.userRegisteredWorkoutsService.list(
@@ -79,7 +76,7 @@ export class userRegisteredWorkoutsController extends BaseController {
   @SwaggerResponse(UserRegisteredWorkoutsPopulateSerialization)
   @SwaggerSummary("today's workout && my trainer --> my plan && weekly")
   @SwaggerDescription("Get a single workout from user registered workouts (workouts that the user had started)")
-  get = async (req: userRequest, res: Response) => {
+  get = async (req: IUserRequest, res: Response) => {
     const data = await this.userRegisteredWorkoutsService.findOneOrFail(
       { _id: req.params.id },
       {
@@ -107,7 +104,7 @@ export class userRegisteredWorkoutsController extends BaseController {
   @SwaggerRequest(createUserRegisteredWorkoutsSchema)
   @SwaggerSummary("Create workout")
   @SwaggerDescription("Create a new workout for the user")
-  create = async (req: userRequest, res: Response) => {
+  create = async (req: IUserRequest, res: Response) => {
     const data = await this.userRegisteredWorkoutsService.createForUser(req.body, req.jwtPayload.id);
     return JsonResponse.success(
       {
@@ -123,7 +120,7 @@ export class userRegisteredWorkoutsController extends BaseController {
   @SwaggerRequest(updateUserRegisteredWorkoutsSchema)
   @SwaggerSummary("Update Workout Progress")
   @SwaggerDescription("Update the progress of a workout")
-  updateProgress = async (req: userRequest, res: Response) => {
+  updateProgress = async (req: IUserRequest, res: Response) => {
     const urwId: string = req.params.id;
     const weekNumber: number = Number(req.params.week);
     const dayNumber: number = Number(req.params.day);

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

@@ -1,17 +1,33 @@
 import { UserRegisteredWorkout } from "@common/models/user-registered-workout.model";
 import { CrudService } from "@lib/services/crud.service";
 import { ICreateUserRegisteredWorkouts } from "../validations/create-user-registered-workouts.validation";
-import { WorkoutService } from "../../workouts/services/workouts.service";
 import { IUpdateUserRegisteredWorkouts } from "../validations/update-user-registered-workouts.validation";
 import { HttpError } from "@lib/error-handling/http-error";
+import { Workout } from "@common/models/workout.model";
 
-export class UserRegisteredWorkoutsService extends CrudService(UserRegisteredWorkout) {
-  private workoutsService: WorkoutService = new WorkoutService();
+export class UserRegisteredWorkoutsService extends CrudService(UserRegisteredWorkout, {
+  defaultFilter: {
+    is_active: true,
+  },
+}) {
+  private workoutsService = new (CrudService(Workout))()
+
+  async unregisterCurrentWorkout(userId: string) {
+    return await this.updateMany({
+      user: userId,
+      is_active: true,
+    }, {
+      is_active: false,
+    });
+  }
   
   async createForUser(data: ICreateUserRegisteredWorkouts, userId: string) {
     const workout = await this.workoutsService.findOneOrFail({
       _id: data.workout,
     });
+
+    await this.unregisterCurrentWorkout(userId); 
+
     return await this.create({
       ...data,
       user: userId,

src/modules/users/modules/workouts/controllers/workouts.controller.ts

@@ -15,6 +15,7 @@ import { SwaggerResponse } from "@lib/decorators/swagger-response.decorator";
 import { SwaggerSummary } from "@lib/decorators/swagger-summary.decorator";
 import { SwaggerDescription } from "@lib/decorators/swagger-description.decorator";
 import { SwaggerQuery } from "@lib/decorators/swagger-query.decorator";
+import { IUserRequest } from "@common/interfaces/user-request.interface";
 
 
 @Controller("/user/workouts")
@@ -37,7 +38,7 @@ export class UsersWorkoutController extends BaseController {
     filterName: "string",
     filterVal: "string",
   })
-  list = async (req: Request, res: Response): Promise<Response> => {
+  list = async (req: IUserRequest, res: Response): Promise<Response> => {
     const paginationQuery = parsePaginationQuery(req.query);
     
     let filterName = req.query.filterName, filterVal = req.query.filterVal;
@@ -48,7 +49,13 @@ export class UsersWorkoutController extends BaseController {
     }
 
     const { docs, paginationData } = await this.workoutsService.list(
-      filter,
+      {
+        ...filter,
+        $or: [
+          { aiGenerated: true, created_by: req.jwtPayload.id },
+          { aiGenerated: false },
+        ],
+      },
       paginationQuery
     );
 

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

@@ -1,4 +1,71 @@
+import { WorkoutPlace } from "@common/enums/workout-place.enum";
+import { UserDocument } from "@common/models/user.model";
 import { Workout } from "@common/models/workout.model";
+import { FitnessModel, IFWParams, IFitnessPredictionItem } from "@lib/models/fitness-model";
 import { CrudService } from "@lib/services/crud.service";
+import { calcAge } from "@lib/utils/age";
+import { ExerciseService } from "../../exercises/services/exercises.service";
+import { UserRegisteredWorkoutsService } from "../../user-registered-workouts/services/user-registered-workouts.service";
 
-export class WorkoutService extends CrudService(Workout) {}
+export class WorkoutService extends CrudService(Workout, {
+  defaultFilter: {
+    aiGenerated: false,
+  },
+}) {
+  private exerciseService = new ExerciseService();
+  private userRegisteredWorkoutsService = new UserRegisteredWorkoutsService();
+
+  public async createModelWorkout(user: UserDocument) {
+    const params: IFWParams = {
+      home_or_gym: user.preferences.workout_place === WorkoutPlace.GYM ? 1 : 0,
+      level: user.fitness_level,
+      goal: user.preferences.fitness_goal,
+      gender: user.gender,
+      age: calcAge(user.dob),
+      feedback: false,
+      old_weight: user.weight,
+      equipments: user.preferences.preferred_equipment,
+    };
+
+    const pworkout = await FitnessModel.predictWorkout(params);
+
+    // partition the workout days into weeks
+    // each week has 7 days
+    const weeks: IFitnessPredictionItem[][][] = [];
+    for (let i = 0; i < pworkout.length; i += 7) {
+      weeks.push(pworkout.slice(i, i + 7));
+    }
+
+    const exercisesNames = pworkout.flat().map((e) => e.name);
+    const exercises = await this.exerciseService.listAll({ name: { $in: exercisesNames } });
+
+    const workout = await this.create({
+      aiGenerated: true,
+      name: `AI Generated Workout for ${user.name} (${new Date().toLocaleDateString()})`,
+      description: `AI Generated Workout for ${user.name} (${new Date().toLocaleDateString()})`,
+      type: "AI Generated",
+      created_by: user._id,
+      image: "https://placehold.co/300x400",
+      fitness_level: user.fitness_level,
+      fitness_goal: user.preferences.fitness_goal,
+      place: [user.preferences.workout_place],
+      min_per_day: 30,
+      total_number_days: pworkout.flat().length,
+      template_weeks: weeks.map((week, i) => ({
+        week_number: i + 1,
+        week_name: `Week ${i + 1}`,
+        week_description: `Week ${i + 1}`,
+        days: week.map((day, j) => ({
+          day_number: j + 1,
+          total_number_exercises: day.length,
+          day_type: "full_body", // #TODO: Change this
+          exercises: day.map((e) => exercises.find((ex) => ex.name === e.name)?._id),
+        })),
+      })),
+    });
+
+    await this.userRegisteredWorkoutsService.createForUser({
+      workout: workout._id,
+    }, user._id);
+  }
+}