create myWorkout module

src/common/models/workout.model.ts

@@ -3,18 +3,19 @@ const { Schema } = mongoose;
 
 export interface IWorkout {
     name: string;
+    description: string;
     type: string;
     created_by: mongoose.Types.ObjectId;
+    image: object;
     templateWeeks: [
         {
+            weekNumber: number;
+            name: string,
+            description: string,
             days: [
                 {
-                    day: number,
-                    exercises: [
-                        {
-                            exercise: mongoose.Types.ObjectId,
-                        },
-                    ],
+                    dayNumber: number,
+                    exercises: [mongoose.Types.ObjectId],
                 },
             ],
         },
@@ -25,6 +26,7 @@ const workoutSchema = new Schema({
     name: { type: String, required: true, unique: true, dropDups: true },
     type: { type: String, required: true },
     created_by: { type: mongoose.Types.ObjectId, ref: "admins" },
+    image: { type: Object },
     templateWeeks: [
         {
             days: [

src/common/serializers/{workout.serializtion.ts → workout.serialization.ts}

@@ -30,6 +30,9 @@ export class WorkoutSerialization {
   @Expose()
   type: string;
 
+  @Expose()
+  image: object;
+
   @Expose()
   created_by: string;
 

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/controllers/workouts.controller.ts

@@ -9,7 +9,7 @@ import { updateWorkoutSchema } from "../validations/update-workout.validation";
 import { BaseController } from "@lib/controllers/controller.base";
 import { Prefix } from "@lib/decorators/prefix.decorator";
 import { serialize } from "@helpers/serialize";
-import { WorkoutSerialization } from "@common/serializers/workout.serializtion";
+import { WorkoutSerialization } from "@common/serializers/workout.serialization";
 import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
 import { AdminGuardMiddleware } from "modules/console/common/guards/admins.guard";
 

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

@@ -5,7 +5,7 @@ export interface ICreateWorkout {
   name: string;
   type: string;
   created_by: string;
-  templateWeeks: string[];
+  templateWeeks: object[];
 };
 
 
@@ -26,8 +26,8 @@ export const createWorkoutSchema = createSchema<ICreateWorkout>({
         "string.empty": "created_by can not be empty",
     }),
     templateWeeks: joi.array().empty().required().messages({
-        "string.base": "please enter a valid templateWeeks",
+        "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

@@ -5,7 +5,7 @@ export interface IUpdateWorkout {
     name?: string;
     type?: string;
     created_by?: string;
-    templateWeeks?: string[];
+    templateWeeks?: object[];
 };
 
 
@@ -23,8 +23,8 @@ export const updateWorkoutSchema = createSchema<IUpdateWorkout>({
         "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",
+        "array.base": "please enter a valid templateWeeks",
+        "array.empty": "templateWeeks can not be empty",
     }),
 
 });

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

@@ -0,0 +1,46 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+export interface IUserRegisteredWorkout {
+    user: mongoose.Types.ObjectId,
+    workout: mongoose.Types.ObjectId,
+    isActive: Boolean,
+    weeks: [
+        {
+            weekNumber: number,
+            name: string,
+            description: string,
+            days: [
+                {
+                    dayNumber: number,
+                    exercises: [mongoose.Types.ObjectId],
+                    isDone: Boolean
+                },
+            ],
+        },
+    ]
+}
+
+const userRegisteredWorkoutSchema = new Schema({
+    user: { type: mongoose.Types.ObjectId, ref: "users" },
+    workout: { type: mongoose.Types.ObjectId, ref: "workouts" },
+    isActive: { type: Boolean, default: false },
+    weeks: [
+        {
+            days: [
+                {
+                    day: Number,
+                    exercises: [
+                        { type: mongoose.Types.ObjectId, ref: "exercises" },
+                    ],
+                    isDone: { type: Boolean, default: false }
+                },
+            ],
+        },
+    ]
+});
+
+
+export type UserRegisteredWorkoutDocument = IUserRegisteredWorkout & mongoose.Document;
+
+export const UserRegisteredWorkout = mongoose.model<UserRegisteredWorkoutDocument>("UserRegisteredWorkouts", userRegisteredWorkoutSchema);

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

@@ -0,0 +1,45 @@
+import { Expose, Transform } from "class-transformer";
+import { serialize } from "@helpers/serialize";
+
+
+
+class Days {
+  @Expose()
+  day: number;
+
+  @Expose({ name: "exercises" })
+  exercises: any;
+
+  @Expose()
+  isDone: Boolean
+}
+
+
+class Weeks {
+  @Expose({ name: "days" })
+  @Transform(
+    ({ value }) => serialize(value, Days)
+  )
+  days: any;
+}
+
+export class UserRegisteredWorkoutsSerialization {
+  @Expose({ name: "_id" })
+  id: string;
+
+  @Expose()
+  user: string;
+
+  @Expose()
+  workout: string;
+
+  @Expose()
+  isActive: Boolean;
+
+  @Expose({ name: "weeks" })
+  @Transform(
+    ({ value }) => serialize(value, Weeks)
+  )
+  weeks: any;
+
+}

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,102 @@
+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("/get/:id", paramsValidator("id"), asyncHandler(this.get));
+    this.router.get("/list/:userId", paramsValidator("userId"), asyncHandler(this.list));
+    this.router.post("/",
+      bodyValidator(createUserRegisteredWorkoutsSchema),
+      asyncHandler(this.create));
+
+    this.router.patch("/",
+      bodyValidator(updateUserRegisteredWorkoutsSchema),
+      asyncHandler(this.update));
+  }
+
+  list = async (req: userRequest, res: Response) => {
+    const paginationQuery = parsePaginationQuery(req.query);
+    // if (req.jwtPayload.id != req.params.userId) console.log(req.jwtPayload);
+
+    const { docs, paginationData } = await this.userRegisteredWorkoutsService.list(
+      { user: req.params.userId },
+      paginationQuery,
+      {
+        populateArray: [
+          { path: "workout", select: "-templateWeeks -created_by" },
+          { path: "weeks.days.exercises" },
+        ]
+      }
+    );
+
+    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: "-templateWeeks -created_by" },
+          { path: "weeks.days.exercises" },
+        ]
+      }
+    );
+    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
+    );
+  };
+
+  update = async (req: userRequest, res: Response) => {
+    const data = await this.userRegisteredWorkoutsService.updateOne(
+      { _id: req.params.id },
+      req.body
+    );
+    return JsonResponse.success(
+      {
+        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,79 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface IDays {
+    day: string;
+    exercises: string[];
+    isDone?: Boolean;
+};
+
+
+export interface IWeeks {
+    days: IDays[];
+};
+
+
+export interface ICreateUserRegisteredWorkouts {
+    user: string;
+    workout: string;
+    isActive: Boolean;
+    weeks: IWeeks[];
+};
+
+
+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",
+    }),
+    isActive: 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({
+            days: joi.array().required().items(
+                joi.object({
+                    day: joi.number().empty().required().messages({
+                        "number.base": "please enter a valid day number",
+                        "any.required": "day number is required",
+                        "number.empty": "day number 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",
+                        }),
+                    isDone: 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,71 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+
+export interface IDays {
+    day?: string;
+    exercises?: string[];
+    isDone?: Boolean;
+};
+
+
+export interface IWeeks {
+    days?: IDays[];
+};
+
+export interface IUpdateUserRegisteredWorkouts {
+    user?: string;
+    workout?: string;
+    isActive?: Boolean;
+    weeks?: IWeeks[];
+};
+
+
+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",
+    }),
+    isActive: 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({
+            days: joi.array().optional().items(
+                joi.object({
+                    day: joi.number().empty().optional().messages({
+                        "number.base": "please enter a valid day number",
+                        "number.empty": "day number 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",
+                        }),
+                    isDone: 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

@@ -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 { WorkoutSerialization } from "@common/serializers/workout.serializtion";
+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();