update

models-server/models/fitness_model.py

@@ -1,259 +0,0 @@
-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:
-            print(f)
-            fitness_model = pickle.load(f)
-
-        return fitness_model

models-server/models/nutrition_model.py

@@ -1,96 +0,0 @@
-import random
-import pandas as pd
-import numpy as np
-import pickle
-import os
-
-SERVER_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
-NUTRITION_MODEL_PATH = os.path.join(SERVER_FILE_DIR, "../resources/models/nutrition_model.pkl")
-MEALS_JSON_PATH = os.path.join(SERVER_FILE_DIR, "../../src/resources/meals.json")
-
-# Ensure the file exists
-if not os.path.exists(MEALS_JSON_PATH):
-    raise FileNotFoundError(f"File {MEALS_JSON_PATH} does not exist")
-
-df = pd.read_json(MEALS_JSON_PATH)
-
-class NutritionModel:
-    def __init__(self):
-        self.load()
-
-    def generate_plan(self, calories):
-        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(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)
-        }
-        
-        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])
-        
-        lunch = self.nutrition_model.transform(lunch_df)
-        breakfast = self.nutrition_model.transform(breakfast_df)
-        dinner = self.nutrition_model.transform(dinner_df)
-        snack = self.nutrition_model.transform(snack_df)
-
-        meals = np.concatenate((breakfast, lunch, dinner, snack), axis=0)
-        meals = np.transpose(meals)
-
-        days = []
-        for i in range(7):
-            day_meals = df.iloc[meals[i]].to_dict(orient="records")
-            days.append(day_meals)
-
-        return days
-
-    def load(self):
-        with open(NUTRITION_MODEL_PATH, "rb") as f:
-            self.nutrition_model = pickle.load(f)
-

models-server/resources/models/fitness_model.pkl

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

models-server/resources/models/nutrition_model.pkl

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

models-server/server.py

@@ -1,62 +0,0 @@
-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
-    return jsonify({"result": nutrition_model.generate_plan(**params)})
-
-
-if __name__ == "__main__":
-    app.run(host=HOST, port=PORT, debug=True)

package-lock.json

@@ -27,12 +27,14 @@
         "npm": "^10.2.5",
         "path": "^0.12.7",
         "swagger-ui-express": "^5.0.0",
-        "tsc-alias": "^1.8.8"
+        "tsc-alias": "^1.8.8",
+        "uuid": "^10.0.0"
       },
       "devDependencies": {
         "@faker-js/faker": "^8.4.1",
         "@types/express": "^4.17.21",
         "@types/swagger-ui-express": "^4.1.6",
+        "@types/uuid": "^9.0.8",
         "nodemon": "^3.0.2",
         "ts-node": "^10.9.2",
         "ts-node-dev": "^2.0.0",
@@ -457,6 +459,12 @@
         "@types/serve-static": "*"
       }
     },
+    "node_modules/@types/uuid": {
+      "version": "9.0.8",
+      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-9.0.8.tgz",
+      "integrity": "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA==",
+      "dev": true
+    },
     "node_modules/@types/webidl-conversions": {
       "version": "7.0.3",
       "resolved": "https://registry.npmjs.org/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz",
@@ -5779,6 +5787,18 @@
         "node": ">= 0.4.0"
       }
     },
+    "node_modules/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
     "node_modules/v8-compile-cache-lib": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",

package.json

@@ -17,6 +17,7 @@
     "@faker-js/faker": "^8.4.1",
     "@types/express": "^4.17.21",
     "@types/swagger-ui-express": "^4.1.6",
+    "@types/uuid": "^9.0.8",
     "nodemon": "^3.0.2",
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
@@ -42,6 +43,7 @@
     "npm": "^10.2.5",
     "path": "^0.12.7",
     "swagger-ui-express": "^5.0.0",
-    "tsc-alias": "^1.8.8"
+    "tsc-alias": "^1.8.8",
+    "uuid": "^10.0.0"
   }
 }

src/common/models/template.model.ts

@@ -9,7 +9,7 @@ export interface ITemplate {
 }
 
 const templateSchema = new Schema({
-  name: { type: String, required: true, unique: true, dropDups: true },
+  name: { type: String, required: true },
   user: { type: mongoose.Types.ObjectId, ref: "users" },
   creationDate: { type: Date, default: Date.now() },
   exercises: [{ type: mongoose.Types.ObjectId, ref: "exercises" }],

src/modules/users/modules/meal-plans/services/meal-plans.service.ts

@@ -30,16 +30,26 @@ export class MealPlansService extends CrudService(MealPlan) {
 
         const mealsNames = pMealPlan.flat().map((meal) => meal.Name);
         const meals = await this.mealsService.listAll({ name: { $in: mealsNames } });
-        const todayDate = new Date().toLocaleDateString('en-US', {
-            year: 'numeric',
-            month: 'long',
-            day: 'numeric'
-          });
+        const today = new Date();
+        const todayDate = today.toLocaleDateString('en-US', {
+          year: 'numeric',
+          month: 'long',
+          day: 'numeric'
+        });
+        const currentTime = today.toLocaleTimeString('en-US', {
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+          hour12: false
+        });
+        const milliseconds = today.getMilliseconds();
+        
+
         const mealPlan = await this.create({
             aiGenerated: true,
             image: "https://placehold.co/300x400",
             description: `This AI-generated meal plan is designed specifically for you, considering your personal fitness goal of ${user.preferences.fitness_goal}. 
-            Created on ${todayDate}, this plan is tailored to provide a balanced and nutritious diet that supports your workout frequency of ${user.preferences.workout_frequency} times per week.
+            Created on ${todayDate} at ${currentTime}.${milliseconds}, this plan is tailored to provide a balanced and nutritious diet that supports your workout frequency of ${user.preferences.workout_frequency} times per week.
             Whether you prefer working out on ${user.preferences.preferred_days.join(", ")}, at ${user.preferences.workout_place}, or using ${user.preferences.preferred_equipment.join(", ")}, this meal plan will help you achieve your health and fitness goals. Enjoy a variety of delicious and nutritious meals selected just for you.`,
             duration: 28,
             level: user.fitness_level,
@@ -50,6 +60,7 @@ export class MealPlansService extends CrudService(MealPlan) {
         });
         
         
+        
 
         await this.userRegisteredMealPlansService.createForUser(
             {

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

@@ -101,7 +101,7 @@ export class templateController extends BaseController {
   @SwaggerSummary("Create custom plan")
   @SwaggerDescription("Create a new custom plan")
   create = async (req: userRequest, res: Response) => {
-    const data = await this.templatesService.create(req.body);
+    const data = await this.templatesService.create(req.body);    
     return JsonResponse.success(
       {
         status: 201,

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

@@ -1,4 +1,6 @@
 import { Template } from "@common/models/template.model";
 import { CrudService } from "@lib/services/crud.service";
 
-export class TemplateService extends CrudService(Template) {}
+export class TemplateService extends CrudService(Template) {
+    
+}

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

@@ -6,6 +6,7 @@ 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";
+import { v4 as uuidv4 } from 'uuid';
 
 export class WorkoutService extends CrudService(Workout) {
   private exerciseService = new ExerciseService();
@@ -34,15 +35,25 @@ export class WorkoutService extends CrudService(Workout) {
 
     const exercisesNames = pworkout.flat().map((e) => e.name);
     const exercises = await this.exerciseService.listAll({ name: { $in: exercisesNames } });
-    const todayDate = new Date().toLocaleDateString('en-US', {
+    const today = new Date();
+    const todayDate = today.toLocaleDateString('en-US', {
       year: 'numeric',
       month: 'long',
       day: 'numeric'
     });
+    const currentTime = today.toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false
+    });
+    const milliseconds = today.getMilliseconds();
+    const uuid = uuidv4();
+    
     const workout = await this.create({
       aiGenerated: true,
-      name: `AI Generated Workout (${user.preferences.fitness_goal} - ${user.fitness_level}) - ${todayDate}`,
-      description:  `This AI-generated workout plan, created on ${todayDate}, is tailored for your ${user.fitness_level.toLowerCase()} fitness level and ${user.preferences.fitness_goal.toLowerCase()} goal. It is designed to be performed ${user.preferences.workout_place === WorkoutPlace.GYM ? "at the gym" : "at home"} using your preferred equipment.`,
+      name: `AI Generated Workout (${user.preferences.fitness_goal} - ${user.fitness_level}) - ${todayDate} ${currentTime}.${milliseconds} - ${uuid}`,
+      description: `This AI-generated workout plan, created on ${todayDate} at ${currentTime}.${milliseconds}, is tailored for your ${user.fitness_level.toLowerCase()} fitness level and ${user.preferences.fitness_goal.toLowerCase()} goal. It is designed to be performed ${user.preferences.workout_place === WorkoutPlace.GYM ? "at the gym" : "at home"} using your preferred equipment.`,
       type: "AI Generated",
       created_by: user._id,
       image: "https://placehold.co/300x400",