Merge pull request #22 from Modarb-Ai-Trainer:refactors

package-lock.json

@@ -9,6 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
+        "@hapi/joi": "^17.1.1",
         "@types/glob": "^8.1.0",
         "bcrypt": "^5.1.1",
         "cors": "^2.8.5",
@@ -18,7 +19,7 @@
         "glob": "^10.3.10",
         "http": "^0.0.1-security",
         "i": "^0.3.7",
-        "joi": "^17.11.0",
+        "joi": "^17.12.1",
         "jsonwebtoken": "^9.0.2",
         "mongoose": "^8.0.3",
         "npm": "^10.2.5",
@@ -45,11 +46,44 @@
         "node": ">=12"
       }
     },
+    "node_modules/@hapi/address": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@hapi/address/-/address-4.1.0.tgz",
+      "integrity": "sha512-SkszZf13HVgGmChdHo/PxchnSaCJ6cetVqLzyciudzZRT0jcOouIF/Q93mgjw8cce+D+4F4C1Z/WrfFN+O3VHQ==",
+      "deprecated": "Moved to 'npm install @sideway/address'",
+      "dependencies": {
+        "@hapi/hoek": "^9.0.0"
+      }
+    },
+    "node_modules/@hapi/formula": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@hapi/formula/-/formula-2.0.0.tgz",
+      "integrity": "sha512-V87P8fv7PI0LH7LiVi8Lkf3x+KCO7pQozXRssAHNXXL9L1K+uyu4XypLXwxqVDKgyQai6qj3/KteNlrqDx4W5A==",
+      "deprecated": "Moved to 'npm install @sideway/formula'"
+    },
     "node_modules/@hapi/hoek": {
       "version": "9.3.0",
       "resolved": "https://registry.npmjs.org/@hapi/hoek/-/hoek-9.3.0.tgz",
       "integrity": "sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ=="
     },
+    "node_modules/@hapi/joi": {
+      "version": "17.1.1",
+      "resolved": "https://registry.npmjs.org/@hapi/joi/-/joi-17.1.1.tgz",
+      "integrity": "sha512-p4DKeZAoeZW4g3u7ZeRo+vCDuSDgSvtsB/NpfjXEHTUjSeINAi/RrVOWiVQ1isaoLzMvFEhe8n5065mQq1AdQg==",
+      "deprecated": "Switch to 'npm install joi'",
+      "dependencies": {
+        "@hapi/address": "^4.0.1",
+        "@hapi/formula": "^2.0.0",
+        "@hapi/hoek": "^9.0.0",
+        "@hapi/pinpoint": "^2.0.0",
+        "@hapi/topo": "^5.0.0"
+      }
+    },
+    "node_modules/@hapi/pinpoint": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@hapi/pinpoint/-/pinpoint-2.0.1.tgz",
+      "integrity": "sha512-EKQmr16tM8s16vTT3cA5L0kZZcTMU5DUOZTuvpnY738m+jyP3JIUj+Mm1xc1rsLkGBQ/gVnfKYPwOmPg1tUR4Q=="
+    },
     "node_modules/@hapi/topo": {
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/@hapi/topo/-/topo-5.1.0.tgz",
@@ -228,9 +262,9 @@
       }
     },
     "node_modules/@sideway/address": {
-      "version": "4.1.4",
-      "resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.4.tgz",
-      "integrity": "sha512-7vwq+rOHVWjyXxVlR76Agnvhy8I9rpzjosTESvmhNeXOXdZZB15Fl+TI9x1SiHZH5Jv2wTGduSxFDIaq0m3DUw==",
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz",
+      "integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==",
       "dependencies": {
         "@hapi/hoek": "^9.0.0"
       }
@@ -1449,13 +1483,13 @@
       }
     },
     "node_modules/joi": {
-      "version": "17.11.0",
-      "resolved": "https://registry.npmjs.org/joi/-/joi-17.11.0.tgz",
-      "integrity": "sha512-NgB+lZLNoqISVy1rZocE9PZI36bL/77ie924Ri43yEvi9GUUMPeyVIr8KdFTMUlby1p0PBYMk9spIxEUQYqrJQ==",
+      "version": "17.12.1",
+      "resolved": "https://registry.npmjs.org/joi/-/joi-17.12.1.tgz",
+      "integrity": "sha512-vtxmq+Lsc5SlfqotnfVjlViWfOL9nt/avKNbKYizwf6gsCfq9NYY/ceYRMFD8XDdrjJ9abJyScWmhmIiy+XRtQ==",
       "dependencies": {
-        "@hapi/hoek": "^9.0.0",
-        "@hapi/topo": "^5.0.0",
-        "@sideway/address": "^4.1.3",
+        "@hapi/hoek": "^9.3.0",
+        "@hapi/topo": "^5.1.0",
+        "@sideway/address": "^4.1.5",
         "@sideway/formula": "^3.0.1",
         "@sideway/pinpoint": "^2.0.0"
       }

package.json

@@ -19,6 +19,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@hapi/joi": "^17.1.1",
     "@types/glob": "^8.1.0",
     "bcrypt": "^5.1.1",
     "cors": "^2.8.5",
@@ -28,7 +29,7 @@
     "glob": "^10.3.10",
     "http": "^0.0.1-security",
     "i": "^0.3.7",
-    "joi": "^17.11.0",
+    "joi": "^17.12.1",
     "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.0.3",
     "npm": "^10.2.5",

src/common/enums/authenticatable-type.enum.ts

@@ -0,0 +1,4 @@
+export enum AuthenticatableType {
+  USER = "user",
+  ADMIN = "admin",
+}

src/common/enums/fitness-goal.enum.ts

@@ -0,0 +1,5 @@
+export enum FitnessGoal {
+  LOSE_WEIGHT = "lose weight",
+  GAIN_MUSCLE = "gain muscle",
+  GET_FITTER = "get fitter",
+}

src/common/enums/fitness-level.enum.ts

@@ -0,0 +1,5 @@
+export enum FitnessLevel {
+  BEGINNER = "beginner",
+  INTERMEDIATE = "intermediate",
+  ADVANCED = "advanced",
+}

src/common/enums/gender.enum.ts

@@ -0,0 +1,4 @@
+export enum Gender {
+  MALE = "male",
+  FEMALE = "female",
+}

src/common/enums/injury.enum.ts

@@ -0,0 +1,7 @@
+export enum Injury {
+  NECK = "neck",
+  SHOULDERS = "shoulders",
+  BACK = "back",
+  ARMS = "arms",
+  KNEES = "knees",
+}

src/common/enums/preferred-day.enum.ts

@@ -0,0 +1,9 @@
+export enum PreferredDay {
+  SATURDAY = "saturday",
+  SUNDAY = "sunday",
+  MONDAY = "monday",
+  TUESDAY = "tuesday",
+  WEDNESDAY = "wednesday",
+  THURSDAY = "thursday",
+  FRIDAY = "friday",
+}

src/common/enums/preferred-equipment.enum.ts

@@ -0,0 +1,7 @@
+export enum PreferredEquipment {
+  BARBELLS = "barbells",
+  DUMBBELLS = "dumbbells",
+  GYM_MACHINES = "gym machines",
+  RESISTANCE_BAND = "resistance band",
+  BODYWEIGHT = "bodyweight",
+}

src/common/enums/workout-place.enum.ts

@@ -0,0 +1,5 @@
+export enum WorkoutPlace {
+  GYM = "gym",
+  HOME = "home",
+  BOTH = "both",
+}

src/common/interfaces/jwt-payload.interface.ts

@@ -0,0 +1,15 @@
+import { Role } from "@common/enums/role.enum";
+
+export type IJwtLoginPayload = {
+  id: string;
+  email: string;
+  name: string;
+} & (
+  | {
+      role: Role;
+      type: "admin";
+    }
+  | {
+      type: "user";
+    }
+);

src/common/models/user.model.ts

@@ -0,0 +1,103 @@
+import mongoose from "mongoose";
+import bcrypt from "bcrypt";
+import { AuthenticatableType } from "@common/enums/authenticatable-type.enum";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Gender } from "@common/enums/gender.enum";
+import { Injury } from "@common/enums/injury.enum";
+import { PreferredDay } from "@common/enums/preferred-day.enum";
+import { PreferredEquipment } from "@common/enums/preferred-equipment.enum";
+import { WorkoutPlace } from "@common/enums/workout-place.enum";
+export const saltrounds = 5;
+const { Schema } = mongoose;
+
+export interface IUser {
+  name: string;
+  email: string;
+  password: string;
+  image: object;
+  role: AuthenticatableType;
+  gender: string;
+  dob: Date;
+  height: number;
+  weight: number;
+  fitness_level: string;
+  preferences: {
+    fitness_goal: FitnessGoal;
+    target_weight: number;
+    workout_frequency: number;
+    preferred_days: [PreferredDay];
+    workout_place: WorkoutPlace;
+    preferred_equipment: [PreferredEquipment];
+  };
+  injuries: [Injury];
+}
+
+const userSchema = new Schema({
+  name: { type: String, required: true },
+  email: { type: String, required: true, unique: true, dropDups: true },
+  password: { type: String, required: true },
+  image: { type: Object },
+  gender: {
+    type: String,
+    enum: Gender,
+    required: true,
+  },
+  height: { type: Number, required: true },
+  weight: { type: Number, required: true },
+  fitness_level: {
+    type: String,
+    enum: FitnessLevel,
+    required: true,
+  },
+  preferences: {
+    fitness_goal: {
+      type: String,
+      enum: FitnessGoal,
+      required: true,
+    },
+    target_weight: { type: Number, required: true },
+    workout_frequency: { type: Number, required: true },
+    preferred_days: [
+      {
+        type: String,
+        enum: PreferredDay,
+        required: true,
+      },
+    ],
+    workout_place: {
+      type: String,
+      enum: WorkoutPlace,
+      required: true,
+    },
+    preferred_equipment: [
+      {
+        type: String,
+        enum: PreferredEquipment,
+        required: true,
+      },
+    ],
+  },
+  injuries: [
+    {
+      type: String,
+      enum: Injury,
+      required: true,
+    },
+  ],
+  dob: { type: Date },
+  role: {
+    type: String,
+    enum: AuthenticatableType,
+    default: AuthenticatableType.USER,
+  },
+});
+
+userSchema.pre("save", async function (next) {
+  this.password = await bcrypt.hash(this.password, saltrounds);
+  next();
+});
+
+export type UserDocument = IUser & mongoose.Document;
+
+export const userModel = mongoose.model<UserDocument>("users", userSchema);

src/common/validations/user-register.validation.ts

@@ -0,0 +1,193 @@
+import { AuthenticatableType } from "@common/enums/authenticatable-type.enum";
+import { FitnessGoal } from "@common/enums/fitness-goal.enum";
+import { FitnessLevel } from "@common/enums/fitness-level.enum";
+import { Gender } from "@common/enums/gender.enum";
+import { Injury } from "@common/enums/injury.enum";
+import { PreferredDay } from "@common/enums/preferred-day.enum";
+import { PreferredEquipment } from "@common/enums/preferred-equipment.enum";
+import { WorkoutPlace } from "@common/enums/workout-place.enum";
+import * as joi from "joi";
+import { createSchema } from "src/helpers/create-schema";
+
+export interface IUserRegister {
+  name: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  image?: {
+    url: string;
+    public_id: string;
+  };
+  gender: string;
+  height: number;
+  weight: number;
+  fitness_level: string;
+  preferences?: {
+    fitness_goal: string;
+    target_weight: number;
+    workout_frequency: number;
+    preferred_days: string[];
+    workout_place: string;
+    preferred_equipment: string[];
+  };
+  injuries: string[];
+  dob?: Date;
+}
+
+export const userRegisterKeys = {
+  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",
+  }),
+  email: joi
+    .string()
+    .required()
+    .email({
+      minDomainSegments: 2,
+      tlds: { allow: ["com", "net", "org", "eg", "io"] },
+    })
+    .empty()
+    .messages({
+      "string.email": "please enter a valid email",
+      "any.required": "email must be entered",
+      "string.empty": "email can not be empty",
+    }),
+  password: joi.string().empty().min(8).required().messages({
+    "string.base": "please enter a valid password",
+    "any.required": "password must be entered",
+    "string.empty": "password cannot be empty",
+    "string.min": "password must be at least 8 characters",
+  }),
+  confirmPassword: joi.string().empty().min(8).required().messages({
+    "string.base": "please enter a valid password",
+    "any.required": "password must be entered",
+    "string.empty": "password cannot be empty",
+    "string.min": "password must be at least 8 characters",
+  }),
+  image: joi
+    .object()
+    .optional()
+    .keys({
+      url: joi.string().optional().messages({
+        "string.base": "please enter a valid url",
+      }),
+      public_id: joi.string().optional().messages({
+        "string.base": "please enter a valid public_id",
+      }),
+    }),
+  gender: joi
+    .string()
+    .valid(...Object.values(Gender))
+    .empty()
+    .required()
+    .messages({
+      "string.base": "please enter a valid gender",
+      "any.required": "gender must be entered",
+      "string.empty": "gender cannot be empty",
+    }),
+  height: joi.number().empty().required().messages({
+    "number.base": "please enter a valid height number",
+    "any.required": "height must be entered",
+    "number.empty": "height cannot be empty",
+  }),
+  weight: joi.number().empty().required().messages({
+    "number.base": "please enter a valid weight number",
+    "any.required": "weight must be entered",
+    "number.empty": "weight cannot 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 must be entered",
+      "string.empty": "fitness_level cannot be empty",
+    }),
+  preferences: joi
+    .object()
+    .optional()
+    .keys({
+      fitness_goal: joi
+        .string()
+        .valid(...Object.values(FitnessGoal))
+        .empty()
+        .required()
+        .messages({
+          "string.base": "please enter a valid fitness_goal",
+          "any.required": "fitness_goal must be entered",
+          "string.empty": "fitness_goal cannot be empty",
+        }),
+      target_weight: joi.number().empty().required().messages({
+        "number.base": "please enter a valid target_weight number",
+        "any.required": "target_weight must be entered",
+        "number.empty": "target_weight cannot be empty",
+      }),
+      workout_frequency: joi.number().empty().required().messages({
+        "number.base": "please enter a valid workout_frequency number",
+        "any.required": "workout_frequency must be entered",
+        "number.empty": "workout_frequency cannot be empty",
+      }),
+      preferred_days: joi
+        .array()
+        .valid(...Object.values(PreferredDay))
+        .empty()
+        .required()
+        .items(
+          joi.string().empty().required().messages({
+            "string.base": "please enter a valid preferred_days",
+            "any.required": "preferred_days must be entered",
+            "string.empty": "preferred_days cannot be empty",
+          })
+        ),
+      workout_place: joi
+        .string()
+        .valid(...Object.values(WorkoutPlace))
+        .empty()
+        .required()
+        .messages({
+          "string.base": "please enter a valid workout_place",
+          "any.required": "workout_place must be entered",
+          "string.empty": "workout_place cannot be empty",
+        }),
+      preferred_equipment: joi
+        .array()
+        .valid(...Object.values(PreferredEquipment))
+        .empty()
+        .required()
+        .items(
+          joi.string().empty().required().messages({
+            "string.base": "please enter a valid preferred_equipment",
+            "any.required": "preferred_equipment must be entered",
+            "string.empty": "preferred_equipment cannot be empty",
+          })
+        ),
+    }),
+  injuries: joi
+    .array()
+    .valid(...Object.values(Injury))
+    .empty()
+    .required()
+    .items(
+      joi.string().empty().required().messages({
+        "string.base": "please enter a valid injuries",
+        "any.required": "injuries must be entered",
+        "string.empty": "injuries cannot be empty",
+      })
+    ),
+  dob: joi.date().empty().optional().messages({
+    "date.base": "please enter a valid date",
+  }),
+  role: joi
+    .string()
+    .valid(...Object.values(AuthenticatableType))
+    .optional()
+    .messages({
+      "string.base": "please enter a valid role",
+      "string.empty": "role cannot be empty",
+    }),
+};
+
+export const userRegisterSchema = createSchema<IUserRegister>(userRegisterKeys);

src/configs/config.ts

@@ -1,5 +1,5 @@
-import { Env } from "./env";
 import dotenv from "dotenv";
+import { Env } from "src/lib/env/env";
 dotenv.config();
 
 export interface Config {

src/configs/env.ts

@@ -1,25 +0,0 @@
-export class EnvValue {
-  constructor(public value: string | number | boolean) {}
-
-  toString(): string {
-    return String(this.value);
-  }
-  toNumber(): number {
-    return Number(this.value);
-  }
-  toBoolean(): boolean {
-    return this.value === "true";
-  }
-}
-
-export class Env {
-  static get(key: string, defaultValue?: string | number | boolean): EnvValue {
-    const value = process.env[key] || defaultValue;
-
-    if (!value) {
-      throw new Error(`Environment variable ${key} not found`);
-    }
-
-    return new EnvValue(value);
-  }
-}

src/helpers/create-schema.ts

@@ -0,0 +1,7 @@
+import * as joi from "joi";
+
+export const createSchema = <T>(
+  schema: joi.SchemaMap<T>
+): joi.ObjectSchema<T> => {
+  return joi.object().required().keys(schema);
+};

src/helpers/jwt.helper.ts

@@ -1,7 +1,7 @@
 import jwt from "jsonwebtoken";
 import { config } from "../configs/config";
 
-export class jwtHelper {
+export class JwtHelper {
   static generateToken(payload: any) {
     return jwt.sign(payload, config.jwt.secret, {
       expiresIn: config.jwt.expiresIn,
@@ -12,23 +12,23 @@ export class jwtHelper {
     return (req: any, res: any, next: any) => {
       let authHeader = req.headers["authorization"];
       const token = authHeader && authHeader.split(" ")[1];
-      if (token) {
-        jwt.verify(token, config.jwt.secret, (err: any, tokenData: any) => {
-          if (err)
-            return res
-              .status(403)
-              .json({ success: false, code: 403, message: "Invalid Token!" });
-          if (!role.includes(tokenData.role))
-            return res
-              .status(401)
-              .json({ success: false, code: 401, message: "Unauthorized" });
-          req.tokenData = tokenData;
-          next();
-        });
-      } else
+      if (!token) {
         return res
           .status(401)
           .json({ success: false, code: 401, message: "Unauthorized" });
+      }
+      jwt.verify(token, config.jwt.secret, (err: any, tokenData: any) => {
+        if (err)
+          return res
+            .status(403)
+            .json({ success: false, code: 403, message: "Invalid Token!" });
+        if (!role.includes(tokenData.role))
+          return res
+            .status(401)
+            .json({ success: false, code: 401, message: "Unauthorized" });
+        req.tokenData = tokenData;
+        next();
+      });
     };
   }
 }

src/helpers/pagination.ts

@@ -0,0 +1,11 @@
+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);
+
+  return {
+    limit,
+    skip,
+  };
+};

src/helpers/validation.helper.ts

@@ -1,22 +1,3 @@
-// export const validator = (schema: any) => {
-//     return (req: any, res: any, next: any) => {
-//         try {
-//             let validationResult = schema.body.validate(req.body);
-//             var validation = [];
-//             if (validationResult.error) {
-//                 validation.push(validationResult.error.details[0].message);
-//             }
-//             if (validation.length) {
-//                 return res.status(400).json({ success: false, error: validation.join(), code: 400 });
-//             }
-//             next();
-//         } catch (err) {
-//             console.log(`err`, err);
-//             return res.status(400).json({ success: false, error: "Bad Request!", code: 400 });
-//         }
-//     };
-// };
-
 import { NextFunction, Request, Response } from "express";
 import { createValidator } from "express-joi-validation";
 import Joi from "joi";
@@ -32,7 +13,7 @@ export const paramsValidator = (schemaOrParam: Joi.Schema | string) =>
 
 export const validationErrorHandler = (
   err,
-  req: Request,
+  _req: Request,
   res: Response,
   next: NextFunction
 ) => {

src/lib/error-handling/http-error.ts

@@ -0,0 +1,13 @@
+import http from "http";
+
+export class HttpError extends Error {
+  status: number;
+  constructor(status: number, message?: string | object) {
+    if (typeof message === "object") {
+      message = JSON.stringify(message);
+    }
+
+    super(message || http.STATUS_CODES[status] || "Error");
+    this.status = status;
+  }
+}

src/lib/responses/json-response.ts

@@ -1,23 +1,21 @@
-export class JsonResponse {
-  public status: number;
-  public message: string;
-  public data: Record<string, any> | Record<string, any>[];
-  public meta?: {
+interface JsonResponseProps {
+  status?: number;
+  message?: string;
+  data?: Record<string, any> | Record<string, any>[];
+  meta?: {
     total: number;
     page: number;
     perPage: number;
   };
+}
+
+export class JsonResponse {
+  public status: JsonResponseProps["status"];
+  public message: JsonResponseProps["message"];
+  public data: JsonResponseProps["data"];
+  public meta?: JsonResponseProps["meta"];
 
-  constructor(props: {
-    status?: number;
-    message?: string;
-    data?: Record<string, any> | Record<string, any>[];
-    meta?: {
-      total: number;
-      page: number;
-      perPage: number;
-    };
-  }) {
+  constructor(props: JsonResponseProps) {
     this.status = props.status || 200;
     this.message = props.message || "Success";
     this.data = props.data || {};

src/lib/services/crud.service.ts

@@ -0,0 +1,68 @@
+import { HttpError } from "@lib/error-handling/http-error";
+import { AnyKeys, Document, FilterQuery, Model } from "mongoose";
+
+export const CrudService = <ModelDoc extends Document>(
+  model: Model<ModelDoc>
+) => {
+  return class CrudServiceClass {
+    protected model: Model<ModelDoc> = model;
+
+    async create(data: AnyKeys<ModelDoc>): Promise<ModelDoc> {
+      return this.model.create(data);
+    }
+
+    async update(
+      filter: FilterQuery<ModelDoc>,
+      data: AnyKeys<ModelDoc>
+    ): Promise<ModelDoc> {
+      return this.model.findOneAndUpdate(filter, data, { new: true });
+    }
+
+    async delete(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+      return this.model.findOneAndDelete(filter);
+    }
+
+    async list(
+      filter: FilterQuery<ModelDoc>,
+      paginationOptions: {
+        limit?: number;
+        skip?: number;
+      } = {
+        limit: 10,
+        skip: 0,
+      }
+    ): Promise<{
+      docs: ModelDoc[];
+      paginationData: {
+        total: number;
+        page: number;
+        perPage: number;
+      };
+    }> {
+      const docs = await this.model
+        .find(filter)
+        .limit(paginationOptions.limit)
+        .skip(paginationOptions.skip);
+
+      const total = await this.model.countDocuments(filter);
+      const paginationData = {
+        total: total,
+        page: paginationOptions.skip,
+        perPage: paginationOptions.limit,
+      };
+
+      return { docs, paginationData };
+    }
+
+    async findOne(filter: FilterQuery<ModelDoc>): Promise<ModelDoc | null> {
+      return this.model.findOne(filter);
+    }
+
+    async findOneOrFail(filter: FilterQuery<ModelDoc>): Promise<ModelDoc> {
+      const document = await this.findOne(filter);
+      if (!document) throw new HttpError(404, "No Matching Result Found.");
+
+      return document;
+    }
+  };
+};

src/modules/common/users/enums/roles.enum.ts

@@ -1,45 +0,0 @@
-export enum Role {
-  USER = "user"
-}
-export enum Gender {
-  MALE = "male",
-  FEMALE = "female"
-}
-export enum FitnessLevel {
-  BEGINNER = "beginner",
-  INTERMEDIATE = "intermediate",
-  ADVANCED = "advanced"
-}
-export enum FitnessGoal {
-  LOSE_WEIGHT = "lose weight",
-  GAIN_MUSCLE = "gain muscle",
-  GET_FITTER = "get fitter"
-}
-export enum WorkoutPlace {
-  GYM = "gym",
-  HOME = "home",
-  BOTH = "both"
-}
-export enum PreferredDay {
-  SATURDAY = "saturday",
-  SUNDAY = "sunday",
-  MONDAY = "monday",
-  TUESDAY = "tuesday",
-  WEDNESDAY = "wednesday",
-  THURSDAY = "thursday",
-  FRIDAY = "friday"
-}
-export enum PreferredEquipment {
-  BARBELLS = "barbells",
-  DUMBBELLS = "dumbbells",
-  GYM_MACHINES = "gym machines",
-  RESISTANCE_BAND = "resistance band",
-  BODYWEIGHT = "bodyweight"
-}
-export enum Injurie {
-  NECK = "neck",
-  SHOULDERS = "shoulders",
-  BACK = "back",
-  ARMS = "arms",
-  KNEES = "knees"
-}

src/modules/common/users/models/user.model.ts

@@ -1,88 +0,0 @@
-import mongoose from "mongoose";
-import bcrypt from "bcrypt";
-export const saltrounds = 5;
-import { Role, Gender, FitnessLevel, FitnessGoal, WorkoutPlace, PreferredDay, PreferredEquipment, Injurie } from "../enums/roles.enum";
-const { Schema } = mongoose;
-
-export interface IUser {
-    name: string;
-    email: string;
-    password: string;
-    image: object;
-    role: Role;
-    gender: string;
-    dob: Date;
-    height: number;
-    weight: number;
-    fitness_level: string;
-    preferences: {
-        fitness_goal: FitnessGoal;
-        target_weight: number;
-        workout_frequency: number;
-        preferred_days: [PreferredDay];
-        workout_place: WorkoutPlace;
-        preferred_equipment: [PreferredEquipment];
-    };
-    injuries: [Injurie];
-  }
-  
-const userSchema = new Schema({
-    name: { type: String, required: true },
-    email: { type: String, required: true, unique: true, dropDups: true },
-    password: { type: String, required: true },
-    image: { type: Object },
-    gender: {
-        type: String,
-        enum: Gender,
-        required: true
-    },
-    height: { type: Number, required: true },
-    weight: { type: Number, required: true },
-    fitness_level: {
-        type: String,
-        enum: FitnessLevel,
-        required: true
-    },
-    preferences: {
-        fitness_goal: {
-            type: String,
-            enum: FitnessGoal,
-            required: true
-        },
-        target_weight: { type: Number, required: true },
-        workout_frequency: { type: Number, required: true },
-        preferred_days: [{
-            type: String,
-            enum: PreferredDay,
-            required: true
-        }],
-        workout_place: {
-            type: String,
-            enum: WorkoutPlace,
-            required: true
-        },
-        preferred_equipment: [{
-            type: String,
-            enum: PreferredEquipment,
-            required: true
-        }]
-    },
-    injuries: [{
-        type: String,
-        enum: Injurie,
-        required: true
-    }],
-    dob: { type: Date },
-    role: {
-        type: String,
-        enum: Role,
-        default: Role.USER
-    }
-});
-
-userSchema.pre("save", async function (next) {
-    this.password = await bcrypt.hash(this.password, saltrounds);
-    next();
-});
-
-export const userModel = mongoose.model<IUser>("users", userSchema);

src/modules/common/users/services/users.base.service.ts

@@ -1,114 +0,0 @@
-import { userModel } from "../models/user.model";
-
-export abstract class UsersBaseService {
-  async find(filterObject) {
-    try {
-      const resultObject = await userModel.findOne(filterObject).lean();
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
-  }
-
-  async create(form: any) {
-    try {
-      if (form.email) {
-        form.email = form.email.toLowerCase();
-        let user = await this.find({ email: form.email });
-        if (user.success)
-          return {
-            success: false,
-            error: "This email already exists",
-            code: 409,
-          };
-      }
-      let newUser = new userModel(form);
-      await newUser.save();
-      return {
-        success: true,
-        code: 201,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
-  }
-
-  async get(filterObject) {
-    try {
-      const resultObject = await userModel
-        .findOne(filterObject)
-        .lean()
-        .select("-password");
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
-  }
-
-  async list(filterObject) {
-    try {
-      const resultArray = await userModel
-        .find(filterObject)
-        .lean()
-        .select("-password");
-
-      if (!resultArray)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      const count = await userModel.countDocuments(filterObject);
-      return {
-        success: true,
-        code: 200,
-        record: resultArray,
-        count,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-}

src/modules/common/users/validation/user-register.validation.ts

@@ -1,140 +0,0 @@
-import * as joi from "joi";
-import { Role, Gender, FitnessLevel, FitnessGoal, WorkoutPlace, PreferredDay, PreferredEquipment, Injurie } from "../enums/roles.enum";
-
-export const userRegisterValidation = joi
-  .object()
-  .required()
-  .keys({
-    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",
-    }),
-    email: joi
-      .string()
-      .required()
-      .email({
-        minDomainSegments: 2,
-        tlds: { allow: ["com", "net", "org", "eg", "io"] },
-      })
-      .empty()
-      .messages({
-        "string.email": "please enter a valid email",
-        "any.required": "email must be entered",
-        "string.empty": "email can not be empty",
-      }),
-    password: joi.string().empty().min(8).required().messages({
-      "string.base": "please enter a valid password",
-      "any.required": "password must be entered",
-      "string.empty": "password cannot be empty",
-      "string.min": "password must be at least 8 characters",
-    }),
-    confirmPassword: joi.string().empty().min(8).required().messages({
-      "string.base": "please enter a valid password",
-      "any.required": "password must be entered",
-      "string.empty": "password cannot be empty",
-      "string.min": "password must be at least 8 characters",
-    }),
-    image: joi
-      .object()
-      .optional()
-      .keys({
-        url: joi.string().optional().messages({
-          "string.base": "please enter a valid url",
-        }),
-        public_id: joi.string().optional().messages({
-          "string.base": "please enter a valid public_id",
-        }),
-      }),
-    gender: joi.string().valid(...Object.values(Gender)).empty().required().messages({
-      "string.base": "please enter a valid gender",
-      "any.required": "gender must be entered",
-      "string.empty": "gender cannot be empty",
-    }),
-    height: joi.number().empty().required().messages({
-      "number.base": "please enter a valid height number",
-      "any.required": "height must be entered",
-      "number.empty": "height cannot be empty",
-    }),
-    weight: joi.number().empty().required().messages({
-      "number.base": "please enter a valid weight number",
-      "any.required": "weight must be entered",
-      "number.empty": "weight cannot 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 must be entered",
-      "string.empty": "fitness_level cannot be empty",
-    }),
-    preferences: joi
-      .object()
-      .optional()
-      .keys({
-        fitness_goal: joi.string().valid(...Object.values(FitnessGoal)).empty().required().messages({
-          "string.base": "please enter a valid fitness_goal",
-          "any.required": "fitness_goal must be entered",
-          "string.empty": "fitness_goal cannot be empty",
-        }),
-        target_weight: joi.number().empty().required().messages({
-          "number.base": "please enter a valid target_weight number",
-          "any.required": "target_weight must be entered",
-          "number.empty": "target_weight cannot be empty",
-        }),
-        workout_frequency: joi.number().empty().required().messages({
-          "number.base": "please enter a valid workout_frequency number",
-          "any.required": "workout_frequency must be entered",
-          "number.empty": "workout_frequency cannot be empty",
-        }),
-        preferred_days: joi
-          .array()
-          .valid(...Object.values(PreferredDay))
-          .empty()
-          .required()
-          .items(
-            joi.string().empty().required().messages({
-              "string.base": "please enter a valid preferred_days",
-              "any.required": "preferred_days must be entered",
-              "string.empty": "preferred_days cannot be empty",
-            })
-          ),
-        workout_place: joi.string().valid(...Object.values(WorkoutPlace)).empty().required().messages({
-          "string.base": "please enter a valid workout_place",
-          "any.required": "workout_place must be entered",
-          "string.empty": "workout_place cannot be empty",
-        }),
-        preferred_equipment: joi
-          .array()
-          .valid(...Object.values(PreferredEquipment))
-          .empty()
-          .required()
-          .items(
-            joi.string().empty().required().messages({
-              "string.base": "please enter a valid preferred_equipment",
-              "any.required": "preferred_equipment must be entered",
-              "string.empty": "preferred_equipment cannot be empty",
-            })
-          ),
-      }),
-    injuries: joi
-      .array()
-      .valid(...Object.values(Injurie))
-      .empty()
-      .required()
-      .items(
-        joi.string().empty().required().messages({
-          "string.base": "please enter a valid injuries",
-          "any.required": "injuries must be entered",
-          "string.empty": "injuries cannot be empty",
-        })
-      ),
-    dob: joi.date().empty().optional().messages({
-      "date.base": "please enter a valid date",
-    }),
-    role: joi
-      .string()
-      .valid(...Object.values(Role))
-      .optional().messages({
-        "string.base": "please enter a valid role",
-        "string.empty": "role cannot be empty"
-      }),
-  });

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

@@ -1,267 +0,0 @@
-import bcrypt from "bcrypt";
-import { Admin, IAdmin } from "../models/admin.model";
-import { config } from "../../../../configs/config";
-import { FilterQuery } from "mongoose";
-
-export class AdminsService {
-  async find(filterObject) {
-    try {
-      const resultObject = await Admin.findOne(filterObject).lean();
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async get(filterObject: FilterQuery<IAdmin>) {
-    try {
-      const resultObject = await Admin.findOne(filterObject)
-        .lean()
-        .select("-password");
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async list(filterObject) {
-    try {
-      const resultArray = await Admin.find(filterObject)
-        .lean()
-        .select("-password");
-
-      if (!resultArray)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      const count = await Admin.countDocuments(filterObject);
-      return {
-        success: true,
-        code: 200,
-        record: resultArray,
-        count,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async create(formObject) {
-    try {
-      if (formObject.email) formObject.email = formObject.email.toLowerCase();
-      const resultObject = new Admin(formObject);
-      await resultObject.save();
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 201,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async update(_id, formObject) {
-    try {
-      const existingObject = await this.find({ _id });
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-      if (formObject.email) {
-        formObject.email = formObject.email.toLowerCase();
-        const duplicate = await this.find({ email: formObject.email });
-        if (
-          duplicate.success &&
-          duplicate.record._id.toString() !=
-            existingObject.record._id.toString()
-        )
-          return {
-            success: false,
-            error: "This Email is taken by another user",
-            code: 409,
-          };
-      }
-
-      const resultObject = await Admin.findByIdAndUpdate({ _id }, formObject);
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: resultObject,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async remove(_id) {
-    try {
-      const resultObject = await Admin.findByIdAndDelete({ _id });
-      if (!resultObject)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async comparePassword(emailString, passwordString) {
-    try {
-      emailString = emailString.toLowerCase();
-      const existingObject = await this.find({ email: emailString });
-
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      const matchingPasswords = await bcrypt.compare(
-        passwordString,
-        existingObject.record.password
-      );
-      if (!matchingPasswords)
-        return {
-          success: false,
-          code: 409,
-          error: "Incorrect Password.",
-        };
-
-      return {
-        success: true,
-        record: existingObject.record,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-
-  async resetPassword(emailString, newPasswordString) {
-    try {
-      emailString = emailString.toLowerCase();
-      const existingObject = await this.find({ email: emailString });
-
-      if (!existingObject.success)
-        return {
-          success: false,
-          code: 404,
-          error: "No Matching Result Found.",
-        };
-
-      const hashedPassword = await bcrypt.hash(
-        newPasswordString,
-        config.saltRounds
-      );
-      const resultObject = await Admin.findOneAndUpdate(
-        { email: emailString },
-        { password: hashedPassword }
-      );
-
-      if (!resultObject)
-        return {
-          success: false,
-          code: 500,
-          error: "Unexpected Error Happened.",
-        };
-
-      return {
-        success: true,
-        code: 200,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: "Unexpected Error Happened.",
-      };
-    }
-  }
-}

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

@@ -1,47 +0,0 @@
-import * as joi from "joi";
-import { Role } from "../enums/roles.enum";
-
-export const createAdminSchema = joi
-  .object()
-  .required()
-  .keys({
-    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",
-    }),
-    email: joi
-      .string()
-      .required()
-      .email({
-        minDomainSegments: 2,
-        tlds: { allow: ["com", "net", "org", "eg", "io"] },
-      })
-      .empty()
-      .messages({
-        "string.email": "please enter a valid email",
-        "any.required": "email must be entered",
-        "string.empty": "email can not be empty",
-      }),
-    password: joi.string().empty().min(8).required().messages({
-      "string.base": "please enter a valid password",
-      "any.required": "password must be entered",
-      "string.empty": "password cannot be empty",
-      "string.min": "password must be at least 8 characters",
-    }),
-    dob: joi.date().empty().optional().messages({
-      "date.base": "please enter a valid date",
-    }),
-    role: joi
-      .string()
-      .valid(...Object.values(Role))
-      .optional().messages({
-        "string.base": "please enter a valid role",
-        "string.empty": "role cannot be empty"
-      }),
-    gender: joi.string().empty().required().messages({
-      "string.base": "please enter a valid gender",
-      "any.required": "gender must be entered",
-      "string.empty": "gender cannot be empty"
-    })
-  });

src/modules/console/common/guards/admins.guard.ts

@@ -0,0 +1,45 @@
+import { JwtPayload, verify } from "jsonwebtoken";
+import { Request } from "express";
+import { Role } from "@common/enums/role.enum";
+import { HttpError } from "@lib/error-handling/http-error";
+import { config } from "@configs/config";
+import { IJwtLoginPayload } from "@common/interfaces/jwt-payload.interface";
+
+type AdminGuardMiddlewareProps = {
+  roles?: Role[];
+};
+
+export const AdminGuardMiddleware =
+  (props?: AdminGuardMiddlewareProps) => (req: Request, res, next) => {
+    // get token from cookie
+    const token = req.headers.authorization?.split(" ")[1];
+    let payload: IJwtLoginPayload;
+
+    // validate token
+    if (!token) {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    try {
+      payload = verify(token, config.jwt.secret);
+    } catch (err) {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    if (payload.type !== "admin") {
+      throw new HttpError(401, "Unauthorized");
+    }
+
+    // check roles
+    if (props?.roles && props?.roles.length > 0) {
+      if (!props.roles.includes(payload.role)) {
+        throw new HttpError(401, "Unauthorized");
+      }
+    }
+
+    // inject payload in request
+    (req as unknown as { jwtPayload: JwtPayload }).jwtPayload = payload;
+
+    // go on
+    next();
+  };

src/modules/console/{admins → common}/models/admin.model.ts

@@ -1,6 +1,5 @@
 import mongoose from "mongoose";
 import bcrypt from "bcrypt";
-import { Role } from "../enums/roles.enum";
 import { config } from "../../../../configs/config";
 const { Schema } = mongoose;
 
@@ -9,7 +8,6 @@ export interface IAdmin {
   email: string;
   password: string;
   image: object;
-  role: Role;
   gender: string;
   dob: Date;
 }
@@ -19,10 +17,6 @@ const AdminSchema = new Schema({
   email: { type: String, required: true, unique: true, dropDups: true },
   password: { type: String, required: true },
   image: { type: Object, default: {} },
-  role: {
-    type: String,
-    enum: Role,
-  },
   gender: { type: String, required: true },
   dob: { type: Date },
 });
@@ -32,4 +26,6 @@ AdminSchema.pre("save", async function (next) {
   next();
 });
 
-export const Admin = mongoose.model<IAdmin>("admins", AdminSchema);
+export type AdminDocument = mongoose.Document & IAdmin;
+
+export const Admin = mongoose.model<AdminDocument>("admins", AdminSchema);

src/modules/console/{admins → modules/admins}/controllers/admins.controller.ts

@@ -1,15 +1,18 @@
-import { Request, Response, Router } from "express";
-import { BaseController } from "../../../../lib/controllers/controller.base";
+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 { Request, Response } from "express";
 import { AdminsService } from "../services/admins.service";
 import { createAdminSchema } from "../validations/create-admin.validation";
-import {
-  bodyValidator,
-  paramsValidator,
-} from "../../../../helpers/validation.helper";
-import { asyncHandler } from "../../../../helpers/async-handler";
-import { Prefix } from "../../../../lib/decorators/prefix.decorator";
+import { parsePaginationQuery } from "@helpers/pagination";
+import { JsonResponse } from "@lib/responses/json-response";
+import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
+import { AdminGuardMiddleware } from "src/modules/console/common/guards/admins.guard";
+import { Role } from "@common/enums/role.enum";
 
 @Prefix("/console/admins")
+@ControllerMiddleware(AdminGuardMiddleware({ roles: [Role.SUPER_ADMIN] }))
 export class AdminsController extends BaseController {
   private adminsService = new AdminsService();
 
@@ -34,36 +37,61 @@ export class AdminsController extends BaseController {
     );
   }
 
-  list = (_, res: Response) => {
-    this.adminsService
-      .list({})
-      .then((result) => {
-        res.status(result.code).json(result);
-      })
-      .catch((err) => {
-        res.status(500).json(err);
-      });
+  list = async (req: Request, res: Response) => {
+    const paginationQuery = parsePaginationQuery(req.query);
+    const { docs, paginationData } = await this.adminsService.list(
+      {},
+      paginationQuery
+    );
+    const response = new JsonResponse({
+      data: docs,
+      meta: paginationData,
+    });
+    return res.json(response);
   };
 
   get = async (req: Request, res: Response) => {
-    const data = await this.adminsService.get({
+    const data = await this.adminsService.findOneOrFail({
       _id: req.params.id,
     });
-    res.json(data);
+    const response = new JsonResponse({
+      data,
+    });
+    res.json(response);
   };
 
   create = async (req: Request, res: Response) => {
-    const data = await this.adminsService.create(req.body);
-    res.json(data);
+    const admin = await this.adminsService.create(req.body);
+    const response = new JsonResponse({
+      data: admin,
+    });
+    res.json(response);
   };
 
   update = async (req: Request, res: Response) => {
-    const data = await this.adminsService.update(req.params.id, req.body);
-    res.json(data);
+    const admin = await this.adminsService.update(
+      {
+        _id: req.params.id,
+      },
+      req.body
+    );
+
+    const response = new JsonResponse({
+      data: admin,
+    });
+
+    res.json(response);
   };
 
   delete = async (req: Request, res: Response) => {
-    const data = await this.adminsService.remove(req.params.id);
-    res.json(data);
+    const admin = await this.adminsService.delete({
+      _id: req.params.id,
+    });
+
+    const response = new JsonResponse({
+      data: admin,
+    });
+
+    res.json(response);
   };
 }

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

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

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

@@ -0,0 +1,55 @@
+import { Role } from "@common/enums/role.enum";
+import * as joi from "joi";
+import { createSchema } from "src/helpers/create-schema";
+
+export interface ICreateAdmin {
+  name: string;
+  email: string;
+  password: string;
+  dob: Date;
+  role?: Role;
+  gender: string;
+}
+
+export const createAdminSchema = createSchema<ICreateAdmin>({
+  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",
+  }),
+  email: joi
+    .string()
+    .required()
+    .email({
+      minDomainSegments: 2,
+      tlds: { allow: ["com", "net", "org", "eg", "io"] },
+    })
+    .empty()
+    .messages({
+      "string.email": "please enter a valid email",
+      "any.required": "email must be entered",
+      "string.empty": "email can not be empty",
+    }),
+  password: joi.string().empty().min(8).required().messages({
+    "string.base": "please enter a valid password",
+    "any.required": "password must be entered",
+    "string.empty": "password cannot be empty",
+    "string.min": "password must be at least 8 characters",
+  }),
+  dob: joi.date().empty().optional().messages({
+    "date.base": "please enter a valid date",
+  }),
+  role: joi
+    .string()
+    .valid(...Object.values(Role))
+    .optional()
+    .messages({
+      "string.base": "please enter a valid role",
+      "string.empty": "role cannot be empty",
+    }),
+  gender: joi.string().empty().required().messages({
+    "string.base": "please enter a valid gender",
+    "any.required": "gender must be entered",
+    "string.empty": "gender cannot be empty",
+  }),
+});

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

@@ -0,0 +1,29 @@
+import { userRegisterSchema } from "src/common/validations/user-register.validation";
+import { UsersService } from "../services/users.service";
+import { JsonResponse } from "src/lib/responses/json-response";
+import { Request, Response } from "express";
+import { asyncHandler } from "@helpers/async-handler";
+import { bodyValidator } from "@helpers/validation.helper";
+import { BaseController } from "@lib/controllers/controller.base";
+import { Prefix } from "@lib/decorators/prefix.decorator";
+
+@Prefix("/console/users")
+export class AdminUsersController extends BaseController {
+  private usersService: UsersService = new UsersService();
+
+  setRoutes() {
+    this.router.post(
+      "/create",
+      bodyValidator(userRegisterSchema),
+      asyncHandler(this.create)
+    );
+  }
+
+  create = async (req: Request, res: Response) => {
+    let user = await this.usersService.create(req.body);
+    const response = new JsonResponse({
+      data: user,
+    });
+    return res.json(response);
+  };
+}

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

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

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

@@ -1,37 +0,0 @@
-import { asyncHandler } from "../../../../helpers/async-handler";
-import { jwtHelper } from "../../../../helpers/jwt.helper";
-import { bodyValidator } from "../../../../helpers/validation.helper";
-import { BaseController } from "../../../../lib/controllers/controller.base";
-import { Prefix } from "../../../../lib/decorators/prefix.decorator";
-import { userRegisterValidation } from "../../../common/users/validation/user-register.validation";
-import { UsersService } from "../services/users.service";
-
-const allowedRoles = ["superAdmin", "admin"];
-
-@Prefix("/console/users")
-export class AdminUsersController extends BaseController {
-  private usersService: UsersService = new UsersService();
-
-  setRoutes() {
-    this.router.post(
-      "/create",
-      jwtHelper.verifyToken(allowedRoles),
-      bodyValidator(userRegisterValidation),
-      asyncHandler(this.create)
-    );
-  }
-
-  create = async (req, res) => {
-    try {
-      let result = await this.usersService.create(req.body);
-      return res.status(result.code).json(result);
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        code: 500,
-        error: err.message,
-      });
-    }
-  };
-}

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

@@ -1,3 +0,0 @@
-import { UsersBaseService } from "../../../common/users/services/users.base.service";
-
-export class UsersService extends UsersBaseService {}

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

@@ -1,73 +0,0 @@
-import { UsersService } from "../services/users.service";
-import { jwtHelper } from "../../../../helpers/jwt.helper";
-import { BaseController } from "../../../../lib/controllers/controller.base";
-import { bodyValidator } from "../../../../helpers/validation.helper";
-import { userRegisterValidation } from "../../../common/users/validation/user-register.validation";
-import { loginValidation } from "../validation/user.Validation";
-import { asyncHandler } from "../../../../helpers/async-handler";
-import { Prefix } from "../../../../lib/decorators/prefix.decorator";
-
-@Prefix("/user/auth")
-export class AuthController extends BaseController {
-  private usersService = new UsersService();
-
-  setRoutes(): void {
-    this.router.post(
-      "/register",
-      bodyValidator(userRegisterValidation),
-      asyncHandler(this.register)
-    );
-    this.router.post(
-      "/login",
-      bodyValidator(loginValidation),
-      asyncHandler(this.login)
-    );
-  }
-
-  register = async (req, res) => {
-    try {
-      let result = await this.usersService.create(req.body);
-      return res.status(result.code).json(result);
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        code: 500,
-        error: err.message,
-      });
-    }
-  };
-
-  login = async (req, res) => {
-    try {
-      const { email, password } = req.body;
-      let result: {
-        success: boolean;
-        code: number;
-        record?: any;
-        message?: string;
-      } = await this.usersService.comparePassword(email, password);
-      if (!result.success) return res.status(result.code).json(result);
-      let payload = {
-        _id: result.record?._id,
-        name: result.record?.name,
-        email: result.record?.email,
-        number: result.record?.number,
-        role: result.record?.role,
-      };
-      const token = jwtHelper.generateToken(payload);
-      return res.status(result.code).json({
-        success: result.success,
-        token,
-        code: result.code,
-        record: result.record,
-      });
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return res.status(500).json({
-        success: false,
-        message: err.message,
-      });
-    }
-  };
-}

src/modules/user/auth/services/users.service.ts

@@ -1,87 +0,0 @@
-import { UsersBaseService } from "../../../common/users/services/users.base.service";
-import bcrypt from "bcrypt";
-
-export class UsersService extends UsersBaseService {
-  async comparePassword(email: string, password: string) {
-    try {
-      if (email != undefined) {
-        email = email.toLowerCase();
-      }
-      let result = await this.find({ email });
-      if (!result.success) return result;
-
-      let match = await bcrypt.compare(password, result.record.password);
-      delete result.record.password;
-
-      if (!match)
-        return {
-          success: false,
-          code: 409,
-          message: "password isn't correct",
-        };
-
-      return {
-        success: true,
-        code: 200,
-        record: result.record,
-      };
-    } catch (err) {
-      console.log(`err.message`, err.message);
-      return {
-        success: false,
-        code: 500,
-        error: err.message,
-      };
-    }
-  }
-
-  // async resetPassword(_id: any, currentPassword: string, newPassword: string, confirmPassword: string) {
-  //     try {
-  //         let user = await UserBaseService.find({ _id })
-  //         let saltrouds = 5;
-  //         let oldPassword = user.record.password;
-  //         let ok = await bcrypt.compare(currentPassword, oldPassword)
-
-  //         if (user.success) {
-
-  //             if (!ok) return {
-  //                 success: false,
-  //                 code: 409,
-  //                 message: "current password isn't correct"
-  //             };
-
-  //             if (newPassword == currentPassword) return {
-  //                 success: false,
-  //                 code: 409,
-  //                 message: "new password must be different from current password"
-  //             };
-
-  //             if (newPassword != confirmPassword) return {
-  //                 success: false,
-  //                 code: 409,
-  //                 message: "passwords don't match"
-  //             };
-
-  //             const hashedPassword = await bcrypt.hash(newPassword, saltrouds)
-  //             await userModel.findByIdAndUpdate(_id, { password: hashedPassword })
-  //             return {
-  //                 success: true,
-  //                 code: 200,
-  //                 message: "password changed successfully"
-  //             };
-  //         }
-  //         else return {
-  //             success: false,
-  //             code: 404,
-  //             error: user.error
-  //         };
-  //     } catch (err) {
-  //         console.log(`err.message`, err.message);
-  //         return {
-  //             success: false,
-  //             code: 500,
-  //             error: err.message
-  //         };
-  //     }
-  // }
-}

src/modules/user/auth/validation/user.Validation.ts

@@ -1,26 +0,0 @@
-import joi from "joi";
-
-export const loginValidation = joi
-  .object()
-  .required()
-  .keys({
-    email: joi
-      .string()
-      .required()
-      .email({
-        minDomainSegments: 2,
-        tlds: { allow: ["com", "net", "org", "eg", "io"] },
-      })
-      .empty()
-      .messages({
-        "string.email": "please enter a valid email",
-        "any.required": "email must be entered",
-        "string.empty": "email can not be empty",
-      }),
-    password: joi.string().empty().min(8).required().messages({
-      "string.base": "please enter a valid password",
-      "any.required": "password must be entered",
-      "string.empty": "password cannot be empty",
-      "string.min": "password must be at least 8 characters",
-    }),
-  });

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

@@ -0,0 +1,43 @@
+import { UsersAuthService } from "../services/users.service";
+import { loginValidationSchema } from "../validation/login.validation";
+import { Request, Response } from "express";
+import { JsonResponse } from "src/lib/responses/json-response";
+import { userRegisterSchema, IUserRegister } from "src/common/validations/user-register.validation";
+import { asyncHandler } from "@helpers/async-handler";
+import { bodyValidator } from "@helpers/validation.helper";
+import { BaseController } from "@lib/controllers/controller.base";
+import { Prefix } from "@lib/decorators/prefix.decorator";
+
+@Prefix("/users/auth")
+export class UsersAuthController extends BaseController {
+  private authService = new UsersAuthService();
+
+  setRoutes(): void {
+    this.router.post(
+      "/register",
+      bodyValidator(userRegisterSchema),
+      asyncHandler(this.register)
+    );
+    this.router.post(
+      "/login",
+      bodyValidator(loginValidationSchema),
+      asyncHandler(this.login)
+    );
+  }
+
+  register = async (req: Request, res: Response) => {
+    const user = await this.authService.register(req.body as IUserRegister);
+    const response = new JsonResponse({
+      data: user,
+    });
+    return res.json(response);
+  };
+
+  login = async (req: Request, res: Response) => {
+    const { user, token } = await this.authService.login(req.body);
+    const response = new JsonResponse({
+      data: { user, token },
+    });
+    return res.json(response);
+  };
+}

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

@@ -0,0 +1,24 @@
+import bcrypt from "bcrypt";
+import { ILogin } from "../validation/login.validation";
+import { HttpError } from "src/lib/error-handling/http-error";
+import { JwtHelper } from "src/helpers/jwt.helper";
+import { userModel } from "src/common/models/user.model";
+import { IUserRegister } from "src/common/validations/user-register.validation";
+import { CrudService } from "@lib/services/crud.service";
+
+export class UsersAuthService extends CrudService(userModel) {
+  async register(createParams: IUserRegister) {
+    return this.create(createParams);
+  }
+
+  async login(loginRequest: ILogin) {
+    const user = await this.findOneOrFail({ email: loginRequest.email });
+    const isPasswordCorrect = await bcrypt.compare(
+      loginRequest.password,
+      user.password
+    );
+    if (!isPasswordCorrect) throw new HttpError(401, "Incorrect Password");
+    const token = JwtHelper.generateToken({ id: user._id, role: user.role });
+    return { user, token };
+  }
+}

src/modules/users/auth/validation/login.validation.ts

@@ -0,0 +1,31 @@
+import joi from "joi";
+import { createSchema } from "src/helpers/create-schema";
+
+export interface ILogin {
+  email: string;
+  password: string;
+}
+
+export const loginValidationKeys = {
+  email: joi
+    .string()
+    .required()
+    .email({
+      minDomainSegments: 2,
+      tlds: { allow: ["com", "net", "org", "eg", "io"] },
+    })
+    .empty()
+    .messages({
+      "string.email": "please enter a valid email",
+      "any.required": "email must be entered",
+      "string.empty": "email can not be empty",
+    }),
+  password: joi.string().empty().min(8).required().messages({
+    "string.base": "please enter a valid password",
+    "any.required": "password must be entered",
+    "string.empty": "password cannot be empty",
+    "string.min": "password must be at least 8 characters",
+  }),
+};
+
+export const loginValidationSchema = createSchema<ILogin>(loginValidationKeys);

tsconfig.json

@@ -10,7 +10,6 @@
     "experimentalDecorators": true,
     "baseUrl": ".",
     "paths": {
-      "src/*": ["src/*"],
       "@lib/*": ["src/lib/*"],
       "@common/*": ["src/common/*"],
       "@configs/*": ["src/configs/*"],