Workout module

src/common/models/workout.model.ts

@@ -3,13 +3,45 @@ const { Schema } = mongoose;
 
 export interface IWorkout {
     name: string;
+    type: string;
+    created_by: mongoose.Types.ObjectId;
+    templateWeeks: [
+        {
+            days: [
+                {
+                    day: number,
+                    exercises: [
+                        {
+                            exercise: mongoose.Types.ObjectId,
+                        },
+                    ],
+                },
+            ],
+        },
+    ]
 }
 
 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: "users" },
+    templateWeeks: [
+        {
+            days: [
+                {
+                    day: Number,
+                    exercises: [
+                        {
+                            exercise: { type: mongoose.Types.ObjectId, ref: "exercises" },
+                        },
+                    ],
+                },
+            ],
+        },
+    ]
 });
 
 
 export type WorkoutDocument = IWorkout & mongoose.Document;
 
-export const Workout = mongoose.model<WorkoutDocument>("workouts", workoutSchema);
+export const Workout = mongoose.model<WorkoutDocument>("workouts", workoutSchema);

src/helpers/pagination.ts

@@ -1,8 +1,8 @@
 import { Request } from "express";
 
 export const parsePaginationQuery = (query: Request["query"]) => {
-  const limit = query.take && parseInt(query.limit as string);
-  const skip = query.skip && parseInt(query.skip as string);
+  const limit = query.limit && parseInt(query.limit as string) || 10;
+  const skip = query.skip && parseInt(query.skip as string) || 0;
 
   return {
     limit,

src/lib/guards/gen-guard.ts

@@ -17,33 +17,33 @@ export const genGuard =
       res: Response
     ) => boolean | Promise<boolean>
   ): OptionalIfUndefined<T> =>
-  (args: T) =>
-  async (req: Request, res: Response, next: NextFunction) => {
-    // get token from cookie
-    const token = req.headers.authorization?.split(" ")[1];
-    let payload: IJwtLoginPayload;
+    (args: T) =>
+      async (req: Request, res: Response, next: NextFunction) => {
+        // get token from cookie
+        const token = req.headers.authorization?.split(" ")[1];
+        let payload: IJwtLoginPayload;
 
-    // validate token
-    if (!token) {
-      throw new HttpError(401, "Unauthorized");
-    }
+        // validate token
+        if (!token) {
+          return next(new HttpError(401, "Unauthorized"));
+        }
 
-    try {
-      payload = verify(token, config.jwt.secret);
-    } catch (err) {
-      throw new HttpError(401, "Unauthorized");
-    }
+        try {
+          payload = verify(token, config.jwt.secret);
+        } catch (err) {
+          return next(new HttpError(401, "Unauthorized"));
+        }
 
-    if (
-      validationMethod &&
-      !(await validationMethod(args, payload, req, res))
-    ) {
-      throw new HttpError(401, "Unauthorized");
-    }
+        if (
+          validationMethod &&
+          !(await validationMethod(args, payload, req, res))
+        ) {
+          return next(new HttpError(401, "Unauthorized"));
+        }
 
-    // inject payload in request
-    (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
+        // inject payload in request
+        (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
 
-    // go on
-    next();
-  };
+        // go on
+        next();
+      };

src/modules/console/modules/admins/controllers/workouts.controller.ts

@@ -0,0 +1,91 @@
+import { WorkoutService } from "../services/workouts.service";
+import { Request, Response } from "express";
+import { JsonResponse } from "@lib/responses/json-response";
+import { parsePaginationQuery } from "@helpers/pagination";
+import { asyncHandler } from "@helpers/async-handler";
+import { paramsValidator, bodyValidator } 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 { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
+
+@Prefix("/admins/workouts")
+@ControllerMiddleware(UsersGuardMiddleware())
+
+export class WorkoutController extends BaseController {
+    private workoutsService = new WorkoutService();
+
+    setRoutes() {
+        this.router.get("/", asyncHandler(this.list));
+        this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
+    }
+
+    list = async (req: Request, res: Response) => {
+        const paginationQuery = parsePaginationQuery(req.query);
+        const { docs, paginationData } = await this.workoutsService.list(
+            {},
+            paginationQuery
+        );
+
+        // const response = new JsonResponse({
+        // data: serialize(docs, WorkoutSerialization),
+        // meta: paginationData,
+        // });
+        // return res.json(response);
+        return JsonResponse.success(
+            {
+                data: serialize(docs, WorkoutSerialization),
+                meta: paginationData,
+            },
+            res
+        );
+    };
+
+    get = async (req: Request, res: Response) => {
+        const data = await this.workoutsService.findOneOrFail({
+            _id: req.params.id,
+        });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), WorkoutSerialization),
+            },
+            res
+        );
+    };
+
+    create = async (req: Request, res: Response) => {
+        const data = await this.workoutsService.create(req.body);
+        return JsonResponse.success(
+            {
+                status: 201,
+                data: serialize(data.toJSON(), WorkoutSerialization),
+            },
+            res
+        );
+    };
+
+    update = async (req: Request, res: Response) => {
+        const data = await this.workoutsService.update(
+            { _id: req.params.id },
+            req.body
+        );
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), WorkoutSerialization),
+            },
+            res
+        );
+    };
+
+    delete = async (req: Request, res: Response) => {
+        const data = await this.workoutsService.delete({ _id: req.params.id });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), WorkoutSerialization),
+            },
+            res
+        );
+    };
+};

src/modules/console/modules/admins/services/workouts.service.ts

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

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

@@ -0,0 +1,33 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface ICreateWorkout {
+  name: string;
+  type: string;
+  created_by: string;
+  templateWeeks: string[];
+};
+
+
+export const createWorkoutSchema = createSchema<ICreateWorkout>({
+    name: 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",
+        "string.empty": "type can not be empty",
+    }),
+    created_by: joi.string().empty().required().messages({
+        "string.base": "please enter a valid created_by",
+        "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",
+        "any.required": "templateWeeks is required",
+        "string.empty": "templateWeeks can not be empty",
+    }),
+});

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

@@ -0,0 +1,30 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface IUpdateWorkout {
+    name?: string;
+    type?: string;
+    created_by?: string;
+    templateWeeks?: string[];
+};
+
+
+export const updateWorkoutSchema = createSchema<IUpdateWorkout>({
+    name: 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",
+    }),
+    created_by: joi.string().empty().optional().messages({
+        "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",
+    }),
+
+});