Merge pull request #49 from Modarb-Ai-Trainer/feat/exercises

src/common/models/equipment.model.ts

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+export interface IEquipment {
+  name: string;
+  image: string;
+}
+
+const equipmentSchema = new Schema({
+  name: { type: String, required: true, unique: true, dropDups: true },
+  image: { type: String, required: true },
+});
+
+export type EquipmentDocument = IEquipment & mongoose.Document;
+
+export const Equipment = mongoose.model<EquipmentDocument>(
+  "equipments",
+  equipmentSchema
+);

src/common/models/exercise.model.ts

@@ -1,4 +1,4 @@
-import mongoose from "mongoose";
+import mongoose, { ObjectId } from "mongoose";
 const { Schema } = mongoose;
 
 export interface IExercise {
@@ -13,8 +13,11 @@ export interface IExercise {
   sets: number;
   instructions: string;
   benefits: string;
-  targetMuscles: string[]; // refs
-  equipments: string[]; // refs
+  targetMuscles: {
+    primary: ObjectId;
+    secondary: ObjectId;
+  }
+  equipments: ObjectId[];
   media: {
     type: "image" | "video";
     url: string;
@@ -33,7 +36,10 @@ const exerciseSchema = new Schema({
   sets: { type: Number, required: true },
   instructions: { type: String, required: true },
   benefits: { type: String, required: true },
-  targetMuscles: [{ type: Schema.Types.ObjectId, ref: "muscles" }],
+  targetMuscles: {
+    primary: { type: Schema.Types.ObjectId, ref: "muscles" },
+    secondary: { type: Schema.Types.ObjectId, ref: "muscles" },
+  },
   equipments: [{ type: Schema.Types.ObjectId, ref: "equipments" }],
   media: {
     type: {

src/common/models/muscle.model.ts

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+export interface IMuscle {
+  name: string;
+  image: string;
+}
+
+const muscleSchema = new Schema({
+  name: { type: String, required: true, unique: true, dropDups: true },
+  image: { type: String, required: true },
+});
+
+export type MuscleDocument = IMuscle & mongoose.Document;
+
+export const Muscle = mongoose.model<MuscleDocument>(
+  "muscles",
+  muscleSchema
+);

src/common/serializers/equipment.serialization.ts

@@ -0,0 +1,12 @@
+import { Expose } from "class-transformer";
+
+export class MuscleSerialization {
+    @Expose({ name: "_id" })
+    id: string;
+
+    @Expose()
+    name: string;
+
+    @Expose()
+    image: string;
+}

src/common/serializers/exercise.serialization.ts

@@ -1,8 +1,6 @@
 import { Expose, Transform } from "class-transformer";
 import { serialize } from "@helpers/serialize";
 
-
-
 class ExpectedDurationRange {
   @Expose()
   min: number;

src/common/serializers/muscle.serialization.ts

@@ -0,0 +1,12 @@
+import { Expose } from "class-transformer";
+
+export class EquipmentSerialization {
+    @Expose({ name: "_id" })
+    id: string;
+
+    @Expose()
+    name: string;
+
+    @Expose()
+    image: string;
+}

src/modules/console/modules/equipments/controllers/equipments.controller.ts

@@ -0,0 +1,101 @@
+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 { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { AdminGuardMiddleware } from "modules/console/common/guards/admins.guard";
+import { EquipmentsService } from "../services/equipments.service";
+import { createEquipmentchema } from "../validations/create-equipment.validation";
+import { updateEquipmentSchema } from "../validations/update-equipment.validation";
+import { EquipmentSerialization } from "@common/serializers/muscle.serialization";
+
+@Prefix("/console/equipments")
+@ControllerMiddleware(AdminGuardMiddleware({}))
+export class EquipmentsController extends BaseController {
+    private equipmentsService = new EquipmentsService();
+
+    setRoutes() {
+        this.router.get("/", asyncHandler(this.list));
+        this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
+        this.router.post("/",
+            bodyValidator(createEquipmentchema),
+            asyncHandler(this.create));
+        this.router.patch(
+            "/:id",
+            paramsValidator("id"),
+            bodyValidator(updateEquipmentSchema),
+            asyncHandler(this.update)
+        );
+        this.router.delete(
+            "/:id",
+            paramsValidator("id"),
+            asyncHandler(this.delete)
+        );
+    }
+
+    list = async (req: Request, res: Response) => {
+        const paginationQuery = parsePaginationQuery(req.query);
+        const { docs, paginationData } = await this.equipmentsService.list(
+            {},
+            paginationQuery
+        );
+
+        return JsonResponse.success(
+            {
+                data: serialize(docs, EquipmentSerialization),
+                meta: paginationData,
+            },
+            res
+        );
+    };
+
+    get = async (req: Request, res: Response) => {
+        const data = await this.equipmentsService.findOneOrFail({
+            _id: req.params.id,
+        });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), EquipmentSerialization),
+            },
+            res
+        );
+    };
+
+    create = async (req: Request, res: Response) => {
+        const data = await this.equipmentsService.create(req.body);
+        return JsonResponse.success(
+            {
+                status: 201,
+                data: serialize(data.toJSON(), EquipmentSerialization),
+            },
+            res
+        );
+    };
+
+    update = async (req: Request, res: Response) => {
+        const data = await this.equipmentsService.updateOne(
+            { _id: req.params.id },
+            req.body
+        );
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), EquipmentSerialization),
+            },
+            res
+        );
+    };
+
+    delete = async (req: Request, res: Response) => {
+        const data = await this.equipmentsService.deleteOne({ _id: req.params.id });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), EquipmentSerialization),
+            },
+            res
+        );
+    };
+};

src/modules/console/modules/equipments/services/equipments.service.ts

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

src/modules/console/modules/equipments/validations/create-equipment.validation.ts

@@ -0,0 +1,19 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface ICreateEquipment{
+    name: string;
+    image: string;
+}
+
+export const createEquipmentchema = createSchema<ICreateEquipment>({
+    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",
+    }),
+    image: joi.string().empty().required().messages({
+        "string.base": "please enter a valid image url",
+        "string.empty": "image url can not be empty",
+    }),
+});

src/modules/console/modules/equipments/validations/update-equipment.validation.ts

@@ -0,0 +1,19 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface IUpdateEquipment {
+    name?: string;
+    image?: string;
+}
+
+
+export const updateEquipmentSchema = createSchema<IUpdateEquipment>({
+    name: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid name",
+        "string.empty": "name 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",
+    }),
+});

src/modules/console/modules/muscles/controllers/muscles.controller.ts

@@ -0,0 +1,101 @@
+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 { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { AdminGuardMiddleware } from "modules/console/common/guards/admins.guard";
+import { MusclesService } from "../services/muscles.service";
+import { createMusclechema } from "../validations/create-muscle.validation";
+import { updateMuscleSchema } from "../validations/update-muscle.validation";
+import { MuscleSerialization } from "@common/serializers/equipment.serialization";
+
+@Prefix("/console/muscles")
+@ControllerMiddleware(AdminGuardMiddleware({}))
+export class MusclesController extends BaseController {
+    private musclesService = new MusclesService();
+
+    setRoutes() {
+        this.router.get("/", asyncHandler(this.list));
+        this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
+        this.router.post("/",
+            bodyValidator(createMusclechema),
+            asyncHandler(this.create));
+        this.router.patch(
+            "/:id",
+            paramsValidator("id"),
+            bodyValidator(updateMuscleSchema),
+            asyncHandler(this.update)
+        );
+        this.router.delete(
+            "/:id",
+            paramsValidator("id"),
+            asyncHandler(this.delete)
+        );
+    }
+
+    list = async (req: Request, res: Response) => {
+        const paginationQuery = parsePaginationQuery(req.query);
+        const { docs, paginationData } = await this.musclesService.list(
+            {},
+            paginationQuery
+        );
+
+        return JsonResponse.success(
+            {
+                data: serialize(docs, MuscleSerialization),
+                meta: paginationData,
+            },
+            res
+        );
+    };
+
+    get = async (req: Request, res: Response) => {
+        const data = await this.musclesService.findOneOrFail({
+            _id: req.params.id,
+        });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), MuscleSerialization),
+            },
+            res
+        );
+    };
+
+    create = async (req: Request, res: Response) => {
+        const data = await this.musclesService.create(req.body);
+        return JsonResponse.success(
+            {
+                status: 201,
+                data: serialize(data.toJSON(), MuscleSerialization),
+            },
+            res
+        );
+    };
+
+    update = async (req: Request, res: Response) => {
+        const data = await this.musclesService.updateOne(
+            { _id: req.params.id },
+            req.body
+        );
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), MuscleSerialization),
+            },
+            res
+        );
+    };
+
+    delete = async (req: Request, res: Response) => {
+        const data = await this.musclesService.deleteOne({ _id: req.params.id });
+        return JsonResponse.success(
+            {
+                data: serialize(data.toJSON(), MuscleSerialization),
+            },
+            res
+        );
+    };
+};

src/modules/console/modules/muscles/services/muscles.service.ts

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

src/modules/console/modules/muscles/validations/create-muscle.validation.ts

@@ -0,0 +1,19 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface ICreateMuscle{
+    name: string;
+    image: string;
+}
+
+export const createMusclechema = createSchema<ICreateMuscle>({
+    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",
+    }),
+    image: joi.string().empty().required().messages({
+        "string.base": "please enter a valid image url",
+        "string.empty": "image url can not be empty",
+    }),
+});

src/modules/console/modules/muscles/validations/update-muscle.validation.ts

@@ -0,0 +1,19 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+export interface IUpdateMuscle {
+    name?: string;
+    image?: string;
+}
+
+
+export const updateMuscleSchema = createSchema<IUpdateMuscle>({
+    name: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid name",
+        "string.empty": "name 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",
+    }),
+});