Merge pull request #16 from Modarb-Ai-Trainer:refactor/controllers

src/lib/controllers/controller.base.ts

@@ -1,10 +1,8 @@
 import { Router } from "express";
 
 export abstract class BaseController {
-  public static router: Router = Router();
-  public static prefix: string = "/";
+  public router: Router = Router();
+  public prefix: string = "/";
 
-  public static setRoutes(_router: Router) {
-    throw new Error(`routes not set for ${this.name}`);
-  }
+  public abstract setRoutes(): void;
 }

src/modules/common/decorators/prefix.decorator.ts

@@ -2,6 +2,13 @@ import { BaseController } from "../../../lib/controllers/controller.base";
 
 export const Prefix = (prefix: string) => {
   return (target: typeof BaseController) => {
-    target.prefix = prefix || target.prefix;
+    const originalConstructor = target;
+    const newConstructor: any = function (...args: any[]) {
+      const instance = new (originalConstructor as any)(...args);
+      instance.prefix = prefix || instance.prefix;
+      return instance;
+    };
+    newConstructor.prototype = originalConstructor.prototype;
+    return newConstructor;
   };
 };

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

@@ -1,8 +1,7 @@
-import { userModel, } from '../models/user.model'
+import { userModel } from "../models/user.model";
 
-
-export class UsersBaseService {
-  static async find(filterObject) {
+export abstract class UsersBaseService {
+  async find(filterObject) {
     try {
       const resultObject = await userModel.findOne(filterObject).lean();
 
@@ -28,33 +27,40 @@ export class UsersBaseService {
     }
   }
 
-  static async create(form: any) {
+  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 {
+      if (form.email) {
+        form.email = form.email.toLowerCase();
+        let user = await this.find({ email: form.email });
+        if (user.success)
+          return {
             success: false,
-            code: 500,
-            error: err.message
-        };
+            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,
+      };
     }
-}
+  }
 
-  static async get(filterObject) {
+  async get(filterObject) {
     try {
-      const resultObject = await userModel.findOne(filterObject).lean().select("-password");
+      const resultObject = await userModel
+        .findOne(filterObject)
+        .lean()
+        .select("-password");
       if (!resultObject)
         return {
           success: false,
@@ -76,7 +82,7 @@ export class UsersBaseService {
     }
   }
 
-  static async list(filterObject) {
+  async list(filterObject) {
     try {
       const resultArray = await userModel
         .find(filterObject)
@@ -105,8 +111,4 @@ export class UsersBaseService {
       };
     }
   }
-
 }
-
-
-

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

@@ -10,48 +10,51 @@ import {
 
 @Prefix("/console/admins")
 export class AdminsController extends BaseController {
-  static setRoutes(router: Router) {
-    router.get("/", AdminsController.list);
-    router.get("/:id", paramsValidator("id"), AdminsController.get);
-    router.post("/", bodyValidator(createAdminSchema), AdminsController.create);
-    router.patch(
+  private adminsService = new AdminsService();
+
+  setRoutes() {
+    this.router.get("/", this.list);
+    this.router.get("/:id", paramsValidator("id"), this.get);
+    this.router.post("/", bodyValidator(createAdminSchema), this.create);
+    this.router.patch(
       "/:id",
       paramsValidator("id"),
       bodyValidator(createAdminSchema),
-      AdminsController.update
+      this.update
     );
-    router.delete("/:id", paramsValidator("id"), AdminsController.delete);
+    this.router.delete("/:id", paramsValidator("id"), this.delete);
   }
 
-  static list(_, res: Response) {
-    AdminsService.list({})
+  list = (_, res: Response) => {
+    this.adminsService
+      .list({})
       .then((result) => {
         res.status(result.code).json(result);
       })
       .catch((err) => {
         res.status(500).json(err);
       });
-  }
+  };
 
-  static async get(req: Request, res: Response) {
-    const data = await AdminsService.get({
+  get = async (req: Request, res: Response) => {
+    const data = await this.adminsService.get({
       _id: req.params.id,
     });
     res.json(data);
-  }
+  };
 
-  static async create(req: Request, res: Response) {
-    const data = await AdminsService.create(req.body);
+  create = async (req: Request, res: Response) => {
+    const data = await this.adminsService.create(req.body);
     res.json(data);
-  }
+  };
 
-  static async update(req: Request, res: Response) {
-    const data = await AdminsService.update(req.params.id, req.body);
+  update = async (req: Request, res: Response) => {
+    const data = await this.adminsService.update(req.params.id, req.body);
     res.json(data);
-  }
+  };
 
-  static async delete(req: Request, res: Response) {
-    const data = await AdminsService.remove(req.params.id);
+  delete = async (req: Request, res: Response) => {
+    const data = await this.adminsService.remove(req.params.id);
     res.json(data);
-  }
+  };
 }

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

@@ -4,7 +4,7 @@ import { config } from "../../../../configs/config";
 import { FilterQuery } from "mongoose";
 
 export class AdminsService {
-  static async find(filterObject) {
+  async find(filterObject) {
     try {
       const resultObject = await Admin.findOne(filterObject).lean();
 
@@ -30,7 +30,7 @@ export class AdminsService {
     }
   }
 
-  static async get(filterObject: FilterQuery<IAdmin>) {
+  async get(filterObject: FilterQuery<IAdmin>) {
     try {
       const resultObject = await Admin.findOne(filterObject)
         .lean()
@@ -56,7 +56,7 @@ export class AdminsService {
     }
   }
 
-  static async list(filterObject) {
+  async list(filterObject) {
     try {
       const resultArray = await Admin.find(filterObject)
         .lean()
@@ -85,7 +85,7 @@ export class AdminsService {
     }
   }
 
-  static async create(formObject) {
+  async create(formObject) {
     try {
       if (formObject.email) formObject.email = formObject.email.toLowerCase();
       const resultObject = new Admin(formObject);
@@ -113,7 +113,7 @@ export class AdminsService {
     }
   }
 
-  static async update(_id, formObject) {
+  async update(_id, formObject) {
     try {
       const existingObject = await this.find({ _id });
       if (!existingObject.success)
@@ -161,7 +161,7 @@ export class AdminsService {
     }
   }
 
-  static async remove(_id) {
+  async remove(_id) {
     try {
       const resultObject = await Admin.findByIdAndDelete({ _id });
       if (!resultObject)
@@ -185,7 +185,7 @@ export class AdminsService {
     }
   }
 
-  static async comparePassword(emailString, passwordString) {
+  async comparePassword(emailString, passwordString) {
     try {
       emailString = emailString.toLowerCase();
       const existingObject = await this.find({ email: emailString });
@@ -223,7 +223,7 @@ export class AdminsService {
     }
   }
 
-  static async resetPassword(emailString, newPasswordString) {
+  async resetPassword(emailString, newPasswordString) {
     try {
       emailString = emailString.toLowerCase();
       const existingObject = await this.find({ email: emailString });

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

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

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

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

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

@@ -1,27 +1,27 @@
-import { usersService } from "../services/users.service";
+import { UsersService } from "../services/users.service";
 import { jwtHelper } from "../../../../helpers/jwt.helper";
 import { BaseController } from "../../../../lib/controllers/controller.base";
-import { Router } from "express";
 import { Prefix } from "../../../common/decorators/prefix.decorator";
-import { Env } from "../../../../configs/env";
 import { bodyValidator } from "../../../../helpers/validation.helper";
 import { userRegisterValidation } from "../../../common/users/validation/user.baseValidation";
 import { loginValidation } from "../validation/user.Validation";
 
 @Prefix("/user/auth")
 export class AuthController extends BaseController {
-  static setRoutes(router: Router): void {
-    router.post(
+  private usersService = new UsersService();
+
+  setRoutes(): void {
+    this.router.post(
       "/register",
       bodyValidator(userRegisterValidation),
-      AuthController.register
+      this.register
     );
-    router.post("/login", bodyValidator(loginValidation), AuthController.login);
+    this.router.post("/login", bodyValidator(loginValidation), this.login);
   }
 
-  static async register(req, res) {
+  register = async (req, res) => {
     try {
-      let result = await usersService.create(req.body);
+      let result = await this.usersService.create(req.body);
       return res.status(result.code).json(result);
     } catch (err) {
       console.log(`err.message`, err.message);
@@ -31,9 +31,9 @@ export class AuthController extends BaseController {
         error: err.message,
       });
     }
-  }
+  };
 
-  static async login(req, res) {
+  login = async (req, res) => {
     try {
       const { email, password } = req.body;
       let result: {
@@ -41,7 +41,7 @@ export class AuthController extends BaseController {
         code: number;
         record?: any;
         message?: string;
-      } = await usersService.comparePassword(email, password);
+      } = await this.usersService.comparePassword(email, password);
       if (!result.success) return res.status(result.code).json(result);
       let payload = {
         _id: result.record?._id,
@@ -64,5 +64,5 @@ export class AuthController extends BaseController {
         message: err.message,
       });
     }
-  }
+  };
 }

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

@@ -1,92 +1,87 @@
 import { UsersBaseService } from "../../../common/users/services/users.base.service";
-import { userModel, } from "../../../common/users/models/user.model";
 import bcrypt from "bcrypt";
 
-export class usersService extends UsersBaseService {
+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;
 
-    static async comparePassword(email: string, password: string) {
-        try {
-            if (email != undefined) {
-                email = email.toLowerCase();
-            }
-            let result = await UsersBaseService.find({ email })
-            if (!result.success) return result;
+      let match = await bcrypt.compare(password, result.record.password);
+      delete result.record.password;
 
-            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",
+        };
 
-            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
-            };
-        }
+      return {
+        success: true,
+        code: 200,
+        record: result.record,
+      };
+    } catch (err) {
+      console.log(`err.message`, err.message);
+      return {
+        success: false,
+        code: 500,
+        error: err.message,
+      };
     }
+  }
 
-    // static 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)
+  // 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 (user.success) {
 
-    //             if (!ok) return {
-    //                 success: false,
-    //                 code: 409,
-    //                 message: "current password isn't correct"
-    //             };
+  //             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 == 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"
-    //             };
+  //             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
-    //         };
-    //     }
-    // }
+  //             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/routes.ts

@@ -43,9 +43,10 @@ const importControllers = async (router: Router) => {
 
   await Promise.all(
     files.map(async (file) => {
-      const controller = await importController(file);
-      if (!controller) return;
-      controller.setRoutes(controller.router);
+      const controllerClass = await importController(file);
+      if (!controllerClass) return;
+      const controller: BaseController = new (controllerClass as any)();
+      controller.setRoutes();
       router.use(controller.prefix, controller.router);
     })
   );
@@ -54,6 +55,7 @@ const importControllers = async (router: Router) => {
 const importController = async (file: string) => {
   const controllers = Object.values(await import(file));
   return controllers.find(
-    (controller: { router?: Router }) => controller.router
+    (controller: { prototype: typeof BaseController }) =>
+      controller.prototype instanceof BaseController
   ) as typeof BaseController;
 };