custom workout

src/common/models/template.model.ts

@@ -1,6 +1,12 @@
 import mongoose from "mongoose";
 const { Schema } = mongoose;
 
+export interface ITemplate {
+    name: string;
+    user: string;
+    exercises: string[];
+}
+
 const templateSchema = new Schema({
     name: { type: String, required: true, unique: true, dropDups: true },
     user: { type: mongoose.Types.ObjectId, ref: "users" },
@@ -8,5 +14,9 @@ const templateSchema = new Schema({
 });
 
 
+export type TemplateDocument = ITemplate & mongoose.Document;
 
-export const templateModel = mongoose.model("templates", templateSchema);
+export const Template = mongoose.model<TemplateDocument>(
+  "templates",
+  templateSchema
+);

src/common/serializers/template.serialization.ts

@@ -0,0 +1,15 @@
+import { Expose } from "class-transformer";
+
+export class TemplateSerialization {
+    @Expose({ name: "_id" })
+    id: string;
+
+    @Expose()
+    name: string;
+
+    @Expose()
+    user: string;
+
+    @Expose()
+    exercises: string[];
+}

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

@@ -0,0 +1,90 @@
+import { TemplateService } from "../services/templates.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 { Controller } from "@lib/decorators/prefix.decorator";
+import { serialize } from "@helpers/serialize";
+import { TemplateSerialization } from "@common/serializers/template.serialization";
+import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
+import {
+  SwaggerGet,
+  SwaggerPost,
+} from "@lib/decorators/swagger-routes.decorator";
+import { SwaggerResponse } from "@lib/decorators/swagger-response.decorator";
+import { SwaggerRequest } from "@lib/decorators/swagger-request.decorator";
+import { createTemplatesSchema } from "../validations/create-templates.validation";
+import { updateTemplatesSchema } from "../validations/update-templates.validation";
+
+
+interface userRequest extends Request {
+  jwtPayload?: any;
+}
+
+@Controller("/user/templates")
+@ControllerMiddleware(UsersGuardMiddleware())
+export class templateController extends BaseController {
+  private templatesService = new TemplateService();
+
+  setRoutes(): void {
+    this.router.get("/", asyncHandler(this.list));
+    this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
+    this.router.post(
+      "/",
+      bodyValidator(createTemplatesSchema),
+      asyncHandler(this.create)
+    );
+  }
+
+  @SwaggerGet()
+  @SwaggerResponse([TemplateSerialization])
+  list = async (req: userRequest, res: Response): Promise<Response> => {
+    const paginationQuery = parsePaginationQuery(req.query);
+    const { docs, paginationData } = await this.templatesService.list(
+      { user: req.jwtPayload.id },
+      paginationQuery
+    );
+
+    return JsonResponse.success(
+      {
+        data: serialize(docs, TemplateSerialization),
+        meta: paginationData,
+      },
+      res
+    );
+  };
+
+  @SwaggerGet("/:id")
+  @SwaggerResponse(TemplateSerialization)
+  get = async (req: userRequest, res: Response): Promise<Response> => {
+    const data = await this.templatesService.findOneOrFail({
+      _id: req.params.id,
+      user: req.jwtPayload.id
+    });
+
+    return JsonResponse.success(
+      {
+        data: serialize(data, TemplateSerialization),
+      },
+      res
+    );
+  };
+
+  @SwaggerPost()
+  @SwaggerResponse(TemplateSerialization)
+  @SwaggerRequest(createTemplatesSchema)
+  create = async (req: userRequest, res: Response) => {
+    const data = await this.templatesService.create(req.body);
+    return JsonResponse.success(
+      {
+        status: 201,
+        data: serialize(data, TemplateSerialization),
+      },
+      res
+    );
+  };
+
+}

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

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

src/modules/users/modules/templates/validations/create-templates.validation.ts

@@ -0,0 +1,32 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+
+export interface ICreateTemplates {
+    name: string;
+    user: string;
+    exercises: string[];
+}
+
+export const createTemplatesSchema = createSchema<ICreateTemplates>({
+    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",
+    }),
+    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",
+    }),
+    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",
+        }),
+});

src/modules/users/modules/templates/validations/update-templates.validation.ts

@@ -0,0 +1,30 @@
+import * as joi from "joi";
+import { createSchema } from "@helpers/create-schema";
+
+
+
+export interface IUpdateTemplates {
+    name?: string;
+    user?: string;
+    exercises?: string[];
+}
+
+
+export const updateTemplatesSchema = createSchema<IUpdateTemplates>({
+    name: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid name",
+        "string.empty": "name can not be empty",
+    }),
+    user: joi.string().empty().optional().messages({
+        "string.base": "please enter a valid user id",
+        "string.empty": "user id 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",
+        }),
+});