Merge pull request #48 from Modarb-Ai-Trainer:myWorkout

add user-registered-workout.model and update workout.model

src/common/enums/place.enum.ts

@@ -0,0 +1,4 @@
+export enum Place {
+  GYM = "gym",
+  HOME = "home",
+}

src/common/models/user-registered-workout.model.ts

@@ -0,0 +1,55 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+export interface IUserRegisteredWorkout {
+    user: mongoose.Types.ObjectId,
+    workout: mongoose.Types.ObjectId,
+    is_active: Boolean,
+    weeks: [
+        {
+            week_number: number,
+            week_name: string,
+            week_description: string,
+            is_done: boolean,
+            days: [
+                {
+                    day_number: number,
+                    total_number_exercises: number,
+                    day_type: string,
+                    exercises: [mongoose.Types.ObjectId],
+                    is_done: boolean
+                },
+            ],
+        },
+    ]
+}
+
+const userRegisteredWorkoutSchema = new Schema({
+    user: { type: mongoose.Types.ObjectId, ref: "users" },
+    workout: { type: mongoose.Types.ObjectId, ref: "workouts" },
+    is_active: { type: Boolean, default: false },
+    weeks: [
+        {
+            week_number: { type: Number },
+            week_name: { type: String, required: true, },
+            week_description: { type: String, required: true, },
+            is_done: { type: Boolean, default: false },
+            days: [
+                {
+                    day_number: { type: Number, required: true, },
+                    total_number_exercises: { type: Number, required: true, },
+                    day_type: { type: String, required: true, },
+                    exercises: [
+                        { type: mongoose.Types.ObjectId, ref: "exercises" },
+                    ],
+                    is_done: { type: Boolean, default: false }
+                },
+            ],
+        },
+    ]
+});
+
+
+export type UserRegisteredWorkoutDocument = IUserRegisteredWorkout & mongoose.Document;
+
+export const UserRegisteredWorkout = mongoose.model<UserRegisteredWorkoutDocument>("UserRegisteredWorkouts", userRegisteredWorkoutSchema);

src/common/models/user.model.ts

@@ -15,13 +15,13 @@ export interface IUser {
   name: string;
   email: string;
   password: string;
-  image: object;
+  image: string;
   role: AuthenticatableType;
   gender: string;
   dob: Date;
   height: number;
   weight: number;
-  fitness_level: string;
+  fitness_level: FitnessLevel;
   preferences: {
     fitness_goal: FitnessGoal;
     target_weight: number;
@@ -37,7 +37,7 @@ const userSchema = new Schema({
   name: { type: String, required: true },
   email: { type: String, required: true },
   password: { type: String, required: true },
-  image: { type: Object },
+  image: { type: String },
   gender: {
     type: String,
     enum: Gender,

src/common/models/workout.model.ts

@@ -1,20 +1,32 @@
 import mongoose from "mongoose";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Place } from "@common/enums/place.enum";
+
 const { Schema } = mongoose;
 
 export interface IWorkout {
     name: string;
+    description: string;
     type: string;
     created_by: mongoose.Types.ObjectId;
-    templateWeeks: [
+    image: string;
+    fitness_level: FitnessLevel;
+    fitness_goal: FitnessGoal;
+    place: [Place];
+    min_per_day: number;
+    total_number_days: number;
+    template_weeks: [
         {
+            week_number: number;
+            week_name: string,
+            week_description: string,
             days: [
                 {
-                    day: number,
-                    exercises: [
-                        {
-                            exercise: mongoose.Types.ObjectId,
-                        },
-                    ],
+                    day_number: number,
+                    total_number_exercises: number,
+                    day_type: string,
+                    exercises: [mongoose.Types.ObjectId],
                 },
             ],
         },
@@ -23,13 +35,25 @@ export interface IWorkout {
 
 const workoutSchema = new Schema({
     name: { type: String, required: true, unique: true, dropDups: true },
+    description: { type: String, required: true },
     type: { type: String, required: true },
     created_by: { type: mongoose.Types.ObjectId, ref: "admins" },
-    templateWeeks: [
+    image: { type: String },
+    fitness_level: { type: String, enum: FitnessLevel, required: true, },
+    fitness_goal: { type: String, enum: FitnessGoal, required: true, },
+    place: [{ type: String, enum: Place, required: true, }],
+    min_per_day: { type: Number, required: true, },
+    total_number_days: { type: Number, required: true, },
+    template_weeks: [
         {
+            week_number: { type: Number, required: true, },
+            week_name: { type: String, required: true, },
+            week_description: { type: String, required: true, },
             days: [
                 {
-                    day: Number,
+                    day_number: { type: Number, required: true, enum: [1, 2, 3, 4, 5, 6, 7] },
+                    total_number_exercises: { type: Number, required: true, },
+                    day_type: { type: String, required: true, },
                     exercises: [
                         { type: mongoose.Types.ObjectId, ref: "exercises" },
                     ],

src/common/serializers/exercise.serialization.ts

@@ -1,4 +1,23 @@
 import { Expose, Transform } from "class-transformer";
+import { serialize } from "@helpers/serialize";
+
+
+
+class ExpectedDurationRange {
+  @Expose()
+  min: number;
+
+  @Expose()
+  max: number;
+}
+
+class Media {
+  @Expose()
+  type: string;
+
+  @Expose()
+  url: string;
+}
 
 export class ExerciseSerialization {
   @Expose({ name: "_id" })
@@ -6,4 +25,40 @@ export class ExerciseSerialization {
 
   @Expose()
   name: string;
+
+  @Expose()
+  category: string;
+
+  @Expose()
+  duration: number | null;
+
+  @Expose({ name: "expectedDurationRange" })
+  @Transform(
+    ({ value }) => serialize(value, ExpectedDurationRange)
+  )
+  expectedDurationRange: object;
+
+  @Expose()
+  reps: number;
+
+  @Expose()
+  sets: number;
+
+  @Expose()
+  instructions: string;
+
+  @Expose()
+  benefits: string;
+
+  @Expose()
+  targetMuscles: any;
+
+  @Expose()
+  equipments: any;
+
+  @Expose({ name: "media" })
+  @Transform(
+    ({ value }) => serialize(value, Media)
+  )
+  media: object;
 }

src/common/serializers/user-registered-workout.serialization.ts

@@ -0,0 +1,61 @@
+import { Expose, Transform } from "class-transformer";
+import { serialize } from "@helpers/serialize";
+
+
+class Days {
+  @Expose()
+  day_number: number;
+
+  @Expose()
+  total_number_exercises: number;
+
+  @Expose()
+  day_type: string;
+
+  @Expose({ name: "exercises" })
+  exercises: any;
+
+  @Expose()
+  is_done: Boolean
+}
+
+class Weeks {
+  @Expose()
+  week_number: number;
+
+  @Expose()
+  week_name: string;
+
+  @Expose()
+  week_description: string;
+
+  @Expose({ name: "days" })
+  @Transform(
+    ({ value }) => serialize(value, Days)
+  )
+  days: any;
+
+  @Expose()
+  is_done: Boolean
+}
+
+export class UserRegisteredWorkoutsSerialization {
+  @Expose({ name: "_id" })
+  id: string;
+
+  @Expose()
+  user: string;
+
+  @Expose()
+  workout: string;
+
+  @Expose()
+  is_active: Boolean;
+
+  @Expose({ name: "weeks" })
+  @Transform(
+    ({ value }) => serialize(value, Weeks)
+  )
+  weeks: any;
+
+}

src/common/serializers/user.serialization.ts

@@ -33,7 +33,7 @@ export class UserSerialization {
   email: string;
 
   @Expose()
-  image: object;
+  image: string;
 
   @Expose()
   role: string;

src/common/serializers/workout.serialization.ts

@@ -5,14 +5,28 @@ import { serialize } from "@helpers/serialize";
 
 class Days {
   @Expose()
-  day: number;
+  day_number: number;
+
+  @Expose()
+  total_number_exercises: number;
+
+  @Expose()
+  day_type: string;
 
   @Expose({ name: "exercises" })
   exercises: any;
 }
 
-
 class TemplateWeeks {
+  @Expose()
+  week_number: number;
+
+  @Expose()
+  week_name: string;
+
+  @Expose()
+  week_description: string;
+
   @Expose({ name: "days" })
   @Transform(
     ({ value }) => serialize(value, Days)
@@ -27,16 +41,37 @@ export class WorkoutSerialization {
   @Expose()
   name: string;
 
+  @Expose()
+  description: string;
+
   @Expose()
   type: string;
 
+  @Expose()
+  image: string;
+
   @Expose()
   created_by: string;
 
-  @Expose({ name: "templateWeeks" })
+  @Expose()
+  fitness_level: string;
+
+  @Expose()
+  fitness_goal: string;
+
+  @Expose()
+  place: any;
+
+  @Expose()
+  min_per_day: number;
+
+  @Expose()
+  total_number_days: number;
+
+  @Expose({ name: "template_weeks" })
   @Transform(
     ({ value }) => serialize(value, TemplateWeeks)
   )
-  templateWeeks: any;
+  template_weeks: any;
 
 }

src/lib/services/crud.service.ts

@@ -45,7 +45,7 @@ export const CrudService = <ModelDoc extends Document>(
           skip: 0,
         },
       options?: {
-        populateObject: any
+        populateArray: any
       }
     ): Promise<{
       docs: ModelDoc[];
@@ -59,7 +59,7 @@ export const CrudService = <ModelDoc extends Document>(
         .find(filter)
         .limit(paginationOptions.limit)
         .skip(paginationOptions.skip)
-      if (options?.populateObject) queryInstruction.populate(options.populateObject);
+      if (options?.populateArray) queryInstruction.populate(options.populateArray);
 
       const docs = await queryInstruction
       const total = await this.model.countDocuments(filter);
@@ -72,14 +72,26 @@ export const CrudService = <ModelDoc extends Document>(
       return { docs, paginationData };
     }
 
-    async findOne(filter: FilterQuery<ModelDoc>): Promise<ModelDoc | null> {
-      return this.model.findOne(filter);
+    async findOne(
+      filter: FilterQuery<ModelDoc>,
+      options?: {
+        populateArray: any
+      }): Promise<ModelDoc | null> {
+      const queryInstruction = this.model.findOne(filter);
+      if (options?.populateArray) queryInstruction.populate(options.populateArray);
+      const document = await queryInstruction
+      return document;
     }
 
-    async findOneOrFail(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+    async findOneOrFail(
+      filter: FilterQuery<ModelDoc>,
+      options?: {
+        populateArray: any
+      }
+    ): Promise<ModelDoc> {
       await this.existsOrThrow(filter);
-      const document = await this.findOne(filter);
-
+      let optionsObject = options ? options : { populateArray: [{}] }
+      const document = await this.findOne(filter, optionsObject);
       return document;
     }
 

src/modules/console/modules/workouts/validations/create-workout.validation.ts

@@ -1,13 +1,37 @@
 import * as joi from "joi";
 import { createSchema } from "@helpers/create-schema";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Place } from "@common/enums/place.enum";
 
-export interface ICreateWorkout {
-  name: string;
-  type: string;
-  created_by: string;
-  templateWeeks: string[];
-};
 
+export interface ICreateWorkout {
+    name: string;
+    description: string;
+    type: string;
+    created_by: string;
+    image?: string;
+    fitness_level: string;
+    fitness_goal: string;
+    place: [string];
+    min_per_day: number;
+    total_number_days: number;
+    template_weeks: [
+        {
+            week_number: number;
+            week_name: string,
+            week_description: string,
+            days: [
+                {
+                    day_number: number,
+                    total_number_exercises: number,
+                    day_type: string,
+                    exercises: [string],
+                },
+            ],
+        },
+    ]
+}
 
 export const createWorkoutSchema = createSchema<ICreateWorkout>({
     name: joi.string().empty().required().messages({
@@ -15,6 +39,11 @@ export const createWorkoutSchema = createSchema<ICreateWorkout>({
         "any.required": "name is required",
         "string.empty": "name can not be empty",
     }),
+    description: joi.string().empty().required().messages({
+        "string.base": "please enter a valid name",
+        "any.required": "name is required",
+        "string.empty": "name can not be empty",
+    }),
     type: joi.string().empty().required().messages({
         "string.base": "please enter a valid type",
         "any.required": "type is required",
@@ -25,9 +54,110 @@ export const createWorkoutSchema = createSchema<ICreateWorkout>({
         "any.required": "created_by is required",
         "string.empty": "created_by can not be empty",
     }),
-    templateWeeks: joi.array().empty().required().messages({
-        "string.base": "please enter a valid templateWeeks",
+    image: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid image url",
+        "string.empty": "image url can not be empty",
+    }),
+    fitness_level: joi.string().valid(...Object.values(FitnessLevel)).empty().required().messages({
+        "string.base": "please enter a valid fitness level",
+        "any.required": "fitness level is required",
+        "string.empty": "fitness level can not be empty",
+        "any.only": `Fitness level must be one of the following values: ${FitnessLevel.ADVANCED}, ${FitnessLevel.BEGINNER} or ${FitnessLevel.INTERMEDIATE}`
+    }),
+    fitness_goal: joi.string().valid(...Object.values(FitnessGoal)).empty().required().messages({
+        "string.base": "please enter a valid fitness goal",
+        "any.required": "fitness goal is required",
+        "string.empty": "fitness goal can not be empty",
+        "any.only": `Fitness goal must be one of the following values: ${FitnessGoal.GAIN_MUSCLE}, ${FitnessGoal.GET_FITTER} or ${FitnessGoal.LOSE_WEIGHT}`
+    }),
+    place: joi.array().empty().required().items(
+        joi.string().empty().required().valid(...Object.values(Place)).messages({
+            "string.base": "please enter a valid place",
+            "any.required": "place is required",
+            "string.empty": "place can not be empty",
+            "any.only": `place must be one of the following values: ${Place.GYM} or ${Place.HOME}`
+        })
+    ).messages({
+        "array.base": "please enter a valid place array",
+        "any.required": "place array is required",
+        "array.empty": "place array can not be empty",
+    }),
+    min_per_day: joi.number().integer().empty().required().messages({
+        "number.base": "please enter a valid min per day",
+        "any.required": "min per day is required",
+        "number.empty": "min per day can not be empty",
+        "number.integer": "day number must be an integer",
+    }),
+    total_number_days: joi.number().integer().empty().required().messages({
+        "number.base": "please enter a valid total number days",
+        "any.required": "total number days is required",
+        "number.empty": "total number days can not be empty",
+        "number.integer": "day number must be an integer",
+    }),
+    template_weeks: joi.array().empty().required().items(
+        joi.object({
+            week_number: joi.number().integer().empty().required().messages({
+                "number.base": "please enter a valid week number",
+                "any.required": "week number is required",
+                "number.empty": "week number can not be empty",
+                "number.integer": "week number must be an integer",
+            }),
+            week_name: joi.string().empty().required().messages({
+                "string.base": "please enter a valid week name",
+                "any.required": "week name is required",
+                "string.empty": "week name can not be empty",
+            }),
+            week_description: joi.string().empty().required().messages({
+                "string.base": "please enter a valid week description",
+                "any.required": "week description is required",
+                "string.empty": "week description can not be empty",
+            }),
+            days: joi.array().required().items(
+                joi.object({
+                    day_number: joi.number().empty().integer().min(1).max(7).required().messages({
+                        "number.base": "Please enter a valid day number",
+                        "any.required": "day number is required",
+                        "number.empty": "day number cannot be empty",
+                        "number.integer": "day number must be an integer",
+                        "number.min": "day number must be between 1 and 7",
+                        "number.max": "day number must be between 1 and 7"
+                    }),
+                    total_number_exercises: joi.number().empty().integer().required().messages({
+                        "number.base": "Please enter a valid total number exercises",
+                        "any.required": "total number exercises is required",
+                        "number.empty": "total number exercises cannot be empty",
+                        "number.integer": "total number exercises must be an integer",
+                    }),
+                    day_type: joi.string().empty().required().messages({
+                        "string.base": "please enter a valid day type",
+                        "any.required": "day type is required",
+                        "string.empty": "day type can not be empty",
+                    }),
+                    exercises: joi.array().empty().required().items(
+                        joi.string().empty().required().messages({
+                            "string.base": "please enter a valid exercise id",
+                            "any.required": "exercise id is required",
+                            "string.empty": "exercise id can not be empty",
+                        }),).messages({
+                            "array.base": "please enter a valid exercises array",
+                            "any.required": "exercises array is required",
+                            "array.empty": "exercises array can not be empty",
+                        }),
+                }).empty().messages({
+                    "object.base": "please enter a valid day object",
+                    "any.required": "day object is required",
+                    "object.empty": "day object can not be empty",
+                })
+            ),
+        }).empty().messages({
+            "array.base": "please enter a valid days array",
+            "any.required": "days array is required",
+            "array.empty": "days array can not be empty",
+
+        })
+    ).messages({
+        "array.base": "please enter a valid templateWeeks",
         "any.required": "templateWeeks is required",
-        "string.empty": "templateWeeks can not be empty",
+        "array.empty": "templateWeeks can not be empty",
     }),
 });

src/modules/console/modules/workouts/validations/update-workout.validation.ts

@@ -1,12 +1,38 @@
 import * as joi from "joi";
 import { createSchema } from "@helpers/create-schema";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Place } from "@common/enums/place.enum";
+
+
 
 export interface IUpdateWorkout {
     name?: string;
+    description?: string;
     type?: string;
     created_by?: string;
-    templateWeeks?: string[];
-};
+    image?: string;
+    fitness_level?: string;
+    fitness_goal?: string;
+    place?: [string];
+    min_per_day?: number;
+    total_number_days?: number;
+    template_weeks?: [
+        {
+            week_number?: number;
+            week_name?: string,
+            week_description?: string,
+            days?: [
+                {
+                    day_number?: number,
+                    total_number_exercises?: number,
+                    day_type?: string,
+                    exercises?: [string],
+                },
+            ],
+        },
+    ]
+}
 
 
 export const updateWorkoutSchema = createSchema<IUpdateWorkout>({
@@ -14,6 +40,10 @@ export const updateWorkoutSchema = createSchema<IUpdateWorkout>({
         "string.base": "please enter a valid name",
         "string.empty": "name can not be empty",
     }),
+    description: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid name",
+        "string.empty": "name can not be empty",
+    }),
     type: joi.string().empty().optional().messages({
         "string.base": "please enter a valid type",
         "string.empty": "type can not be empty",
@@ -22,9 +52,94 @@ export const updateWorkoutSchema = createSchema<IUpdateWorkout>({
         "string.base": "please enter a valid created_by",
         "string.empty": "created_by can not be empty",
     }),
-    templateWeeks: joi.array().empty().optional().messages({
-        "string.base": "please enter a valid templateWeeks",
-        "string.empty": "templateWeeks can not be empty",
+    image: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid image url",
+        "string.empty": "image url can not be empty",
+    }),
+    fitness_level: joi.string().valid(...Object.values(FitnessLevel)).empty().optional().messages({
+        "string.base": "please enter a valid fitness level",
+        "string.empty": "fitness level can not be empty",
+        "any.only": `Fitness level must be one of the following values: ${FitnessLevel.ADVANCED}, ${FitnessLevel.BEGINNER} or ${FitnessLevel.INTERMEDIATE}`
+    }),
+    fitness_goal: joi.string().valid(...Object.values(FitnessGoal)).empty().optional().messages({
+        "string.base": "please enter a valid fitness goal",
+        "string.empty": "fitness goal can not be empty",
+        "any.only": `Fitness goal must be one of the following values: ${FitnessGoal.GAIN_MUSCLE}, ${FitnessGoal.GET_FITTER} or ${FitnessGoal.LOSE_WEIGHT}`
+    }),
+    place: joi.array().empty().optional().items(
+        joi.string().empty().optional().valid(...Object.values(Place)).messages({
+            "string.base": "please enter a valid place",
+            "string.empty": "place can not be empty",
+            "any.only": `place must be one of the following values: ${Place.GYM} or ${Place.HOME}`
+        })
+    ).messages({
+        "array.base": "please enter a valid place array",
+        "array.empty": "place array can not be empty",
+    }),
+    min_per_day: joi.number().integer().empty().optional().messages({
+        "number.base": "please enter a valid min per day",
+        "number.empty": "min per day can not be empty",
+        "number.integer": "day number must be an integer",
+    }),
+    total_number_days: joi.number().integer().empty().optional().messages({
+        "number.base": "please enter a valid total number days",
+        "number.empty": "total number days can not be empty",
+        "number.integer": "day number must be an integer",
+    }),
+    template_weeks: joi.array().empty().optional().items(
+        joi.object({
+            week_number: joi.number().integer().empty().optional().messages({
+                "number.base": "please enter a valid week number",
+                "number.empty": "week number can not be empty",
+                "number.integer": "week number must be an integer",
+            }),
+            week_name: joi.string().empty().optional().messages({
+                "string.base": "please enter a valid week name",
+                "string.empty": "week name can not be empty",
+            }),
+            week_description: joi.string().empty().optional().messages({
+                "string.base": "please enter a valid week description",
+                "string.empty": "week description can not be empty",
+            }),
+            days: joi.array().optional().items(
+                joi.object({
+                    day_number: joi.number().empty().integer().min(1).max(7).optional().messages({
+                        "number.base": "Please enter a valid day number",
+                        "number.empty": "day number cannot be empty",
+                        "number.integer": "day number must be an integer",
+                        "number.min": "day number must be between 1 and 7",
+                        "number.max": "day number must be between 1 and 7"
+                    }),
+                    total_number_exercises: joi.number().empty().integer().optional().messages({
+                        "number.base": "Please enter a valid total number exercises",
+                        "number.empty": "total number exercises cannot be empty",
+                        "number.integer": "total number exercises must be an integer",
+                    }),
+                    day_type: joi.string().empty().optional().messages({
+                        "string.base": "please enter a valid day type",
+                        "string.empty": "day type can not be empty",
+                    }),
+                    exercises: joi.array().empty().optional().items(
+                        joi.string().empty().required().messages({
+                            "string.base": "please enter a valid exercise id",
+                            "string.empty": "exercise id can not be empty",
+                        }),).messages({
+                            "array.base": "please enter a valid exercises array",
+                            "array.empty": "exercises array can not be empty",
+                        }),
+                }).empty().messages({
+                    "object.base": "please enter a valid day object",
+                    "object.empty": "day object can not be empty",
+                })
+            ),
+        }).empty().messages({
+            "array.base": "please enter a valid days array",
+            "array.empty": "days array can not be empty",
+
+        })
+    ).messages({
+        "array.base": "please enter a valid templateWeeks",
+        "array.empty": "templateWeeks can not be empty",
     }),
 
 });

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

@@ -13,7 +13,7 @@ import { serialize } from "@helpers/serialize";
 import { UserSerialization } from "@common/serializers/user.serialization";
 import { UsersAuthService } from "../services/users-auth.service";
 
-@Prefix("/users/auth")
+@Prefix("/user/auth")
 export class UsersAuthController extends BaseController {
   private authService = new UsersAuthService();
 

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

@@ -7,11 +7,11 @@ import { paramsValidator } from "@helpers/validation.helper";
 import { BaseController } from "@lib/controllers/controller.base";
 import { Prefix } from "@lib/decorators/prefix.decorator";
 import { serialize } from "@helpers/serialize";
-import { ExerciseSerialization } from "@common/serializers/exercise.serializtion";
+import { ExerciseSerialization } from "@common/serializers/exercise.serialization";
 import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
 import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
 
-@Prefix("/users/exercises")
+@Prefix("/user/exercises")
 @ControllerMiddleware(UsersGuardMiddleware())
 export class ExerciseController extends BaseController {
   private exercisesService = new ExerciseService();

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

@@ -0,0 +1,84 @@
+import { UserRegisteredWorkoutsService } from "../services/user-registered-workouts.service";
+import { Request, Response } from "express";
+import { JsonResponse } from "@lib/responses/json-response";
+import { parsePaginationQuery } from "@helpers/pagination";
+import { paramsValidator, bodyValidator } from "@helpers/validation.helper";
+import { asyncHandler } from "@helpers/async-handler";
+import { BaseController } from "@lib/controllers/controller.base";
+import { Prefix } from "@lib/decorators/prefix.decorator";
+import { serialize } from "@helpers/serialize";
+import { UserRegisteredWorkoutsSerialization } from "@common/serializers/user-registered-workout.serialization";
+import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
+import { createUserRegisteredWorkoutsSchema } from "../validations/create-user-registered-workouts.validation";
+import { updateUserRegisteredWorkoutsSchema } from "../validations/update-user-registered-workouts.validation";
+
+interface userRequest extends Request {
+  jwtPayload?: any;
+}
+
+@Prefix("/user/myWorkouts")
+@ControllerMiddleware(UsersGuardMiddleware())
+export class userRegisteredWorkoutsController extends BaseController {
+  private userRegisteredWorkoutsService = new UserRegisteredWorkoutsService();
+
+  setRoutes(): void {
+    this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
+    this.router.get("/", asyncHandler(this.list));
+    this.router.post("/",
+      bodyValidator(createUserRegisteredWorkoutsSchema),
+      asyncHandler(this.create));
+  }
+
+  list = async (req: userRequest, res: Response) => {
+    const paginationQuery = parsePaginationQuery(req.query);
+    const { docs, paginationData } = await this.userRegisteredWorkoutsService.list(
+      { user: req.jwtPayload.id },
+      paginationQuery,
+      {
+        populateArray: [
+          { path: "workout", select: "-templateWeeks -created_by" },
+          { path: "weeks.days.exercises", select: "name media reps sets" },
+        ]
+      }
+    );
+
+    return JsonResponse.success(
+      {
+        data: serialize(docs, UserRegisteredWorkoutsSerialization),
+        meta: paginationData,
+      },
+      res
+    );
+  };
+
+  get = async (req: userRequest, res: Response) => {
+    const data = await this.userRegisteredWorkoutsService.findOneOrFail(
+      { _id: req.params.id },
+      {
+        populateArray: [
+          { path: "workout", select: "-template_weeks -created_by" },
+          { path: "weeks.days.exercises", select: "name media reps sets" },
+        ]
+      }
+    );
+    return JsonResponse.success(
+      {
+        data: serialize(data.toJSON(), UserRegisteredWorkoutsSerialization),
+      },
+      res
+    );
+  };
+
+  create = async (req: userRequest, res: Response) => {
+    const data = await this.userRegisteredWorkoutsService.create(req.body);
+    return JsonResponse.success(
+      {
+        status: 201,
+        data: serialize(data.toJSON(), UserRegisteredWorkoutsSerialization),
+      },
+      res
+    );
+  };
+
+}

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

@@ -0,0 +1,4 @@
+import { UserRegisteredWorkout } from "@common/models/user-registered-workout.model";
+import { CrudService } from "@lib/services/crud.service";
+
+export class UserRegisteredWorkoutsService extends CrudService(UserRegisteredWorkout) {}

src/modules/users/modules/user-registered-workouts/validations/create-user-registered-workouts.validation.ts

@@ -0,0 +1,117 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+
+export interface ICreateUserRegisteredWorkouts {
+    user: string;
+    workout: string;
+    is_active?: Boolean;
+    weeks: [
+        {
+            week_number: number;
+            week_name: string,
+            week_description: string,
+            is_done?: boolean,
+            days: [
+                {
+                    day_number: number,
+                    total_number_exercises: number,
+                    day_type: string,
+                    exercises: [string],
+                    is_done?: boolean,
+                },
+            ],
+        },
+    ]
+}
+
+export const createUserRegisteredWorkoutsSchema = createSchema<ICreateUserRegisteredWorkouts>({
+    user: joi.string().empty().required().messages({
+        "string.base": "please enter a valid user id",
+        "any.required": "user id is required",
+        "string.empty": "user id can not be empty",
+    }),
+    is_active: joi.boolean().empty().optional().messages({
+        "boolean.base": "please enter a valid isActive",
+        "boolean.empty": "isActive can not be empty",
+    }),
+    workout: joi.string().empty().required().messages({
+        "string.base": "please enter a valid workout id",
+        "any.required": "workout id is required",
+        "string.empty": "workout id can not be empty",
+    }),
+    weeks: joi.array().empty().required().items(
+        joi.object({
+            week_number: joi.number().integer().empty().required().messages({
+                "number.base": "please enter a valid week number",
+                "any.required": "week number is required",
+                "number.empty": "week number can not be empty",
+                "number.integer": "week number must be an integer",
+            }),
+            week_name: joi.string().empty().required().messages({
+                "string.base": "please enter a valid week name",
+                "any.required": "week name is required",
+                "string.empty": "week name can not be empty",
+            }),
+            week_description: joi.string().empty().required().messages({
+                "string.base": "please enter a valid week description",
+                "any.required": "week description is required",
+                "string.empty": "week description can not be empty",
+            }),
+            is_done: joi.boolean().empty().optional().messages({
+                "boolean.base": "please enter a valid isDone",
+                "boolean.empty": "isDone can not be empty",
+            }),
+            days: joi.array().required().items(
+                joi.object({
+                    day_number: joi.number().empty().integer().min(1).max(7).required().messages({
+                        "number.base": "Please enter a valid day number",
+                        "any.required": "day number is required",
+                        "number.empty": "day number cannot be empty",
+                        "number.integer": "day number must be an integer",
+                        "number.min": "day number must be between 1 and 7",
+                        "number.max": "day number must be between 1 and 7"
+                    }),
+                    total_number_exercises: joi.number().empty().integer().required().messages({
+                        "number.base": "Please enter a valid total number exercises",
+                        "any.required": "total number exercises is required",
+                        "number.empty": "total number exercises cannot be empty",
+                        "number.integer": "total number exercises must be an integer",
+                    }),
+                    day_type: joi.string().empty().required().messages({
+                        "string.base": "please enter a valid day type",
+                        "any.required": "day type is required",
+                        "string.empty": "day type can not be empty",
+                    }),
+                    exercises: joi.array().empty().required().items(
+                        joi.string().empty().required().messages({
+                            "string.base": "please enter a valid exercise id",
+                            "any.required": "exercise id is required",
+                            "string.empty": "exercise id can not be empty",
+                        }),).messages({
+                            "array.base": "please enter a valid exercises array",
+                            "any.required": "exercises array is required",
+                            "array.empty": "exercises array can not be empty",
+                        }),
+                    is_done: joi.boolean().empty().optional().messages({
+                        "boolean.base": "please enter a valid isDone",
+                        "boolean.empty": "isDone can not be empty",
+                    }),
+                }).empty().messages({
+                    "object.base": "please enter a valid day object",
+                    "any.required": "day object is required",
+                    "object.empty": "day object can not be empty",
+                })
+            ),
+        }).empty().messages({
+            "array.base": "please enter a valid days array",
+            "any.required": "days array is required",
+            "array.empty": "days array can not be empty",
+
+        })
+    ).messages({
+        "array.base": "please enter a valid weeks array",
+        "any.required": "weeks array is required",
+        "array.empty": "weeks array can not be empty",
+    }),
+});

src/modules/users/modules/user-registered-workouts/validations/update-user-registered-workouts.validation.ts

@@ -0,0 +1,106 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+
+
+export interface IUpdateUserRegisteredWorkouts {
+    user?: string;
+    workout?: string;
+    is_active?: Boolean;
+    weeks?: [
+        {
+            week_number?: number;
+            week_name?: string,
+            week_description?: string,
+            is_done?: boolean,
+            days?: [
+                {
+                    day_number?: number,
+                    total_number_exercises?: number,
+                    day_type?: string,
+                    exercises?: [string],
+                    is_done?: boolean,
+                },
+            ],
+        },
+    ]
+}
+
+
+export const updateUserRegisteredWorkoutsSchema = createSchema<IUpdateUserRegisteredWorkouts>({
+    user: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid user id",
+        "string.empty": "user id can not be empty",
+    }),
+    is_active: joi.boolean().empty().optional().messages({
+        "boolean.base": "please enter a valid isActive",
+        "boolean.empty": "isActive can not be empty",
+    }),
+    workout: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid workout id",
+        "string.empty": "workout id can not be empty",
+    }),
+    weeks: joi.array().empty().optional().items(
+        joi.object({
+            week_number: joi.number().integer().empty().optional().messages({
+                "number.base": "please enter a valid week number",
+                "number.empty": "week number can not be empty",
+                "number.integer": "week number must be an integer",
+            }),
+            week_name: joi.string().empty().optional().messages({
+                "string.base": "please enter a valid week name",
+                "string.empty": "week name can not be empty",
+            }),
+            week_description: joi.string().empty().optional().messages({
+                "string.base": "please enter a valid week description",
+                "string.empty": "week description can not be empty",
+            }),
+            is_done: joi.boolean().empty().optional().messages({
+                "boolean.base": "please enter a valid isDone",
+                "boolean.empty": "isDone can not be empty",
+            }),
+            days: joi.array().optional().items(
+                joi.object({
+                    day_number: joi.number().empty().integer().min(1).max(7).optional().messages({
+                        "number.base": "Please enter a valid day number",
+                        "number.empty": "day number cannot be empty",
+                        "number.integer": "day number must be an integer",
+                        "number.min": "day number must be between 1 and 7",
+                        "number.max": "day number must be between 1 and 7"
+                    }),
+                    total_number_exercises: joi.number().empty().integer().optional().messages({
+                        "number.base": "Please enter a valid total number exercises",
+                        "number.empty": "total number exercises cannot be empty",
+                        "number.integer": "total number exercises must be an integer",
+                    }),
+                    day_type: joi.string().empty().optional().messages({
+                        "string.base": "please enter a valid day type",
+                        "string.empty": "day type can not be empty",
+                    }),
+                    exercises: joi.array().empty().optional().items(
+                        joi.string().empty().optional().messages({
+                            "string.base": "please enter a valid exercise id",
+                            "string.empty": "exercise id can not be empty",
+                        }),).messages({
+                            "array.base": "please enter a valid exercises array",
+                            "array.empty": "exercises array can not be empty",
+                        }),
+                    is_done: joi.boolean().empty().optional().messages({
+                        "boolean.base": "please enter a valid isDone",
+                        "boolean.empty": "isDone can not be empty",
+                    }),
+                }).empty().messages({
+                    "object.base": "please enter a valid day object",
+                    "object.empty": "day object can not be empty",
+                })
+            ),
+        }).empty().messages({
+            "array.base": "please enter a valid days array",
+            "array.empty": "days array can not be empty",
+
+        })
+    ).messages({
+        "array.base": "please enter a valid weeks array",
+        "array.empty": "weeks array can not be empty",
+    }),
+});

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

@@ -11,7 +11,7 @@ import { WorkoutSerialization } from "@common/serializers/workout.serialization"
 import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
 import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
 
-@Prefix("/users/workouts")
+@Prefix("/user/workouts")
 @ControllerMiddleware(UsersGuardMiddleware())
 export class WorkoutController extends BaseController {
   private workoutsService = new WorkoutService();