User registeration & login

.env.example

@@ -1,5 +1,5 @@
 PORT =
-
+ACCESS_TOKEN_SECRET =
 LOCAL_DB_CONNECTION_STRING =
 DEV_DB_CONNECTION_STRING = 
 

package-lock.json

@@ -15,6 +15,8 @@
         "dotenv": "^16.3.1",
         "express": "^4.18.2",
         "http": "^0.0.1-security",
+        "joi": "^17.11.0",
+        "jsonwebtoken": "^9.0.2",
         "mongoose": "^8.0.3",
         "path": "^0.12.7"
       },
@@ -36,6 +38,19 @@
         "node": ">=12"
       }
     },
+    "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/topo": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@hapi/topo/-/topo-5.1.0.tgz",
+      "integrity": "sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==",
+      "dependencies": {
+        "@hapi/hoek": "^9.0.0"
+      }
+    },
     "node_modules/@jridgewell/resolve-uri": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz",
@@ -102,6 +117,24 @@
         "sparse-bitfield": "^3.0.3"
       }
     },
+    "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==",
+      "dependencies": {
+        "@hapi/hoek": "^9.0.0"
+      }
+    },
+    "node_modules/@sideway/formula": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz",
+      "integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg=="
+    },
+    "node_modules/@sideway/pinpoint": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz",
+      "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ=="
+    },
     "node_modules/@tsconfig/node10": {
       "version": "1.0.9",
       "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz",
@@ -338,6 +371,11 @@
         "node": ">=16.20.1"
       }
     },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="
+    },
     "node_modules/bytes": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
@@ -541,6 +579,14 @@
         "url": "https://github.com/motdotla/dotenv?sponsor=1"
       }
     },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
@@ -1024,6 +1070,58 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/joi": {
+      "version": "17.11.0",
+      "resolved": "https://registry.npmjs.org/joi/-/joi-17.11.0.tgz",
+      "integrity": "sha512-NgB+lZLNoqISVy1rZocE9PZI36bL/77ie924Ri43yEvi9GUUMPeyVIr8KdFTMUlby1p0PBYMk9spIxEUQYqrJQ==",
+      "dependencies": {
+        "@hapi/hoek": "^9.0.0",
+        "@hapi/topo": "^5.0.0",
+        "@sideway/address": "^4.1.3",
+        "@sideway/formula": "^3.0.1",
+        "@sideway/pinpoint": "^2.0.0"
+      }
+    },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz",
+      "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==",
+      "dependencies": {
+        "jws": "^3.2.2",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jwa": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.1.tgz",
+      "integrity": "sha512-qiLX/xhEEFKUAJ6FiBMbes3w9ATzyk5W7Hvzpa/SLYdxNtng+gcurvrI7TbACjIXlsJyr05/S1oUhZrc63evQA==",
+      "dependencies": {
+        "buffer-equal-constant-time": "1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz",
+      "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+      "dependencies": {
+        "jwa": "^1.4.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
     "node_modules/kareem": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/kareem/-/kareem-2.5.1.tgz",
@@ -1032,6 +1130,41 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg=="
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA=="
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw=="
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="
+    },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg=="
+    },
     "node_modules/lru-cache": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",

package.json

@@ -23,6 +23,8 @@
     "dotenv": "^16.3.1",
     "express": "^4.18.2",
     "http": "^0.0.1-security",
+    "joi": "^17.11.0",
+    "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.0.3",
     "path": "^0.12.7"
   }

src/configs/app.ts

@@ -4,12 +4,14 @@ import express from "express";
 import bodyParser from "body-parser";
 import cors from "cors";
 import path from 'path';
+import { routes } from "../index.route";
 import { connection as databaseConnection } from "./database";
 
 databaseConnection();
 export const app = express();
 app.use(cors());
 app.use(express.json());
+app.use(routes);
 app.use(bodyParser.json());
 
 app.use(bodyParser.urlencoded({ extended: false }));

src/helpers/jwt.helper.ts

@@ -0,0 +1,23 @@
+import jwt from "jsonwebtoken";
+
+export class jwtHelper {
+    static generateToken(payload: any) {
+        return jwt.sign(payload, process.env.ACCESS_TOKEN_SECRET || "secret", { expiresIn: '30d' })
+    }
+
+    static verifyToken(role: any) {
+        return (req: any, res: any, next: any) => {
+            let authHeader = req.headers['authorization']
+            const token = authHeader && authHeader.split(" ")[1]
+            if (token) {
+                jwt.verify(token, process.env.ACCESS_TOKEN_SECRET || "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 return res.status(401).json({ success: false, code: 401, message: "Unauthorized" })
+        }
+    }
+}

src/helpers/validation.helper.ts

@@ -0,0 +1,18 @@
+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 });
+        }
+    };
+};

src/index.route.ts

@@ -0,0 +1,38 @@
+import express from 'express';
+const app = express.Router();
+
+import { userRoutes } from './modules/user/index.route';
+import { adminRoutes } from './modules/console/index.route';
+
+app.use("/api/v1/user", userRoutes);
+app.use("/api/v1/admin", adminRoutes);
+
+
+app.get("/", (req: any, res: any) => {
+    res.status(200).json({ success: true, message: 'Welcome Message', code: 200 })
+})
+
+app.get("*", (req: any, res: any) => {
+    res.status(404).json({ success: false, message: "Invalid URL!", code: 404 })
+})
+
+app.post("*", (req: any, res: any) => {
+    res.status(404).json({ success: false, message: "Invalid URL!", code: 404 })
+})
+
+app.put("*", (req: any, res: any) => {
+    res.status(404).json({ success: false, message: "Invalid URL!", code: 404 })
+})
+
+app.delete("*", (req: any, res: any) => {
+    res.status(404).json({ success: false, message: "Invalid URL!", code: 404 })
+})
+
+
+app.patch("*", (req: any, res: any) => {
+    res.status(404).json({ success: false, message: "Invalid URL!", code: 404 })
+})
+
+
+
+export { app as routes };

src/index.ts

@@ -1,4 +1,3 @@
-
 import { app } from "./configs/app"
 import http from 'http';
 

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

@@ -2,54 +2,57 @@ import mongoose from "mongoose";
 import bcrypt from "bcrypt";
 export const saltrounds = 5;
 const { Schema } = mongoose;
+enum Role {
+    USER = "user"
+}
 enum Gender {
-    MALE= "male",
-    FEMALE= "female"
+    MALE = "male",
+    FEMALE = "female"
 }
 enum FitnessLevel {
-    BEGINNER= "beginner",
-    INTERMEDIATE= "intermediate",
-    ADVANCED= "advanced"
+    BEGINNER = "beginner",
+    INTERMEDIATE = "intermediate",
+    ADVANCED = "advanced"
 }
 enum FitnessGoal {
-    LOSE_WEIGHT= "lose weight",
-    GAIN_MUSCLE= "gain muscle",
-    GET_FITTER= "get fitter"
+    LOSE_WEIGHT = "lose weight",
+    GAIN_MUSCLE = "gain muscle",
+    GET_FITTER = "get fitter"
 }
 enum WorkoutPlace {
-    GYM= "gym",
-    HOME= "home",
-    BOTH= "both"
+    GYM = "gym",
+    HOME = "home",
+    BOTH = "both"
 }
 enum PreferredDay {
-    SATURDAY= "saturday",
-    SUNDAY= "sunday",
-    MONDAY= "monday",
-    TUESDAY= "tuesday",
-    WEDNESDAY= "wednesday",
-    THURSDAY= "thursday",
-    FRIDAY= "friday"
+    SATURDAY = "saturday",
+    SUNDAY = "sunday",
+    MONDAY = "monday",
+    TUESDAY = "tuesday",
+    WEDNESDAY = "wednesday",
+    THURSDAY = "thursday",
+    FRIDAY = "friday"
 }
 enum PreferredEquipment {
-    BARBELLS= "barbells",
-    DUMBBELLS= "dumbbells",
-    GYM_MACHINES= "gym machines",
-    RESISTANCE_BAND= "resistance band",
-    BODYWEIGHT= "bodyweight"
+    BARBELLS = "barbells",
+    DUMBBELLS = "dumbbells",
+    GYM_MACHINES = "gym machines",
+    RESISTANCE_BAND = "resistance band",
+    BODYWEIGHT = "bodyweight"
 }
 enum Injurie {
-    NECK= "neck",
-    SHOULDERS= "shoulders",
-    BACK= "back",
-    ARMS= "arms",
-    KNEES= "knees"
+    NECK = "neck",
+    SHOULDERS = "shoulders",
+    BACK = "back",
+    ARMS = "arms",
+    KNEES = "knees"
 }
 
 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: String },
+    image: { type: Object },
     gender: {
         type: String,
         enum: Gender,
@@ -91,7 +94,12 @@ const userSchema = new Schema({
         enum: Injurie,
         required: true
     }],
-    dob: { type: Date }
+    dob: { type: Date },
+    role: {
+        type: String,
+        enum: Role,
+        required: true
+    }
 });
 
 userSchema.pre("save", async function (next) {

src/modules/common/User/services/user.base.service.ts

@@ -16,18 +16,43 @@ export class UserBaseService {
       return {
         success: true,
         code: 200,
-        result: resultObject,
+        record: resultObject,
       };
     } catch (err) {
       console.log(`err.message`, err.message);
       return {
         success: false,
         code: 500,
-        error: "Unexpected Error Happened.",
+        error: err.message,
       };
     }
   }
 
+  static async create(form: { email: string }) {
+    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
+        };
+    }
+}
+
   static async get(filterObject) {
     try {
       const resultObject = await userModel.findOne(filterObject).lean().select("-password");
@@ -40,14 +65,14 @@ export class UserBaseService {
       return {
         success: true,
         code: 200,
-        result: resultObject,
+        record: resultObject,
       };
     } catch (err) {
       console.log(`err.message`, err.message);
       return {
         success: false,
         code: 500,
-        error: "Unexpected Error Happened.",
+        error: err.message,
       };
     }
   }
@@ -69,7 +94,7 @@ export class UserBaseService {
       return {
         success: true,
         code: 200,
-        result: resultArray,
+        record: resultArray,
         count,
       };
     } catch (err) {

src/modules/common/User/validation/user.baseValidation.ts

@@ -0,0 +1,98 @@
+import joi from 'joi';
+
+export class userBaseValidation {
+    static createValidation = {
+        body: 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().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().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().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().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().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().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().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",
+            })
+        })
+    }
+}

src/modules/console/Admin/services/admin.service.ts

@@ -17,7 +17,7 @@ export class AdminService {
       return {
         success: true,
         code: 200,
-        result: resultObject,
+        record: resultObject,
       };
     } catch (err) {
       console.log(`err.message`, err.message);
@@ -41,7 +41,7 @@ export class AdminService {
       return {
         success: true,
         code: 200,
-        result: resultObject,
+        record: resultObject,
       };
     } catch (err) {
       console.log(`err.message`, err.message);
@@ -70,7 +70,7 @@ export class AdminService {
       return {
         success: true,
         code: 200,
-        result: resultArray,
+        record: resultArray,
         count,
       };
     } catch (err) {
@@ -99,7 +99,7 @@ export class AdminService {
       return {
         success: true,
         code: 201,
-        result: resultObject,
+        record: resultObject,
       };
     } catch (err) {
       console.log(`err.message`, err.message);
@@ -125,7 +125,7 @@ export class AdminService {
         const duplicate = await this.find({ email: formObject.email });
         if (
           duplicate.success &&
-          duplicate.result._id.toString() != existingObject.result._id.toString()
+          duplicate.record._id.toString() != existingObject.record._id.toString()
         )
           return {
             success: false,
@@ -173,8 +173,7 @@ export class AdminService {
 
       return {
         success: true,
-        code: 200,
-        result: "Deleted Successfully.",
+        code: 200
       };
     } catch (err) {
       console.log(`err.message`, err.message);
@@ -200,7 +199,7 @@ export class AdminService {
 
       const matchingPasswords = await bcrypt.compare(
         passwordString,
-        existingObject.result.password
+        existingObject.record.password
       );
       if (!matchingPasswords)
         return {
@@ -211,7 +210,7 @@ export class AdminService {
 
       return {
         success: true,
-        result: existingObject.result,
+        result: existingObject.record,
         code: 200,
       };
     } catch (err) {

src/modules/console/User/controllers/user.controller.ts

@@ -0,0 +1,18 @@
+import { userService } from "../services/user.service";
+
+export class adminUserController {
+
+    static async create(req, res) {
+        try {
+            let result = await userService.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/User/routes/admin.userRoute.ts

@@ -0,0 +1,11 @@
+import express from "express";
+import { adminUserController } from "../controllers/user.controller";
+import { adminUserValidation } from "../validation/admin.userValidation";
+import { validator } from "../../../../helpers/validation.helper";
+
+const app = express.Router();
+
+app.post("/create", validator(adminUserValidation.createValidation), adminUserController.create);
+
+export { app as adminUserRoutes };
+

src/modules/console/User/services/user.service.ts

@@ -1,7 +1,5 @@
 import { UserBaseService } from "../../../common/User/services/user.base.service";
 
-
-
 export class userService extends UserBaseService {
 
 }

src/modules/console/User/validation/admin.userValidation.ts

@@ -0,0 +1,6 @@
+import joi from 'joi';
+import { userBaseValidation } from '../../../common/User/validation/user.baseValidation';
+
+export class adminUserValidation extends userBaseValidation {
+
+}

src/modules/console/index.route.ts

@@ -0,0 +1,11 @@
+import express from 'express';
+const app = express();
+
+import { jwtHelper } from '../../helpers/jwt.helper';
+const allowedRoles = ["superAdmin", "admin"];
+
+import { adminUserRoutes } from './User/routes/admin.userRoute';
+
+app.use("/users", jwtHelper.verifyToken(allowedRoles), adminUserRoutes);
+
+export { app as adminRoutes };

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

@@ -0,0 +1,46 @@
+import { userService } from "../services/user.service";
+import { jwtHelper } from "../../../../helpers/jwt.helper";
+
+export class authController {
+
+    static async register(req, res) {
+        try {
+            let result = await userService.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
+            })
+        }
+    }
+
+    static async login(req, res) {
+        try {
+            const { email, password } = req.body;
+            let result: { success: boolean; code: number; record?: any; message?: string } = await userService.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/User/routes/auth.route.ts

@@ -0,0 +1,12 @@
+import express from "express";
+import { authController } from "../controllers/auth.controller";
+import { userValidation } from "../validation/user.Validation";
+import { validator } from "../../../../helpers/validation.helper";
+
+const app = express.Router();
+
+app.post("/register", validator(userValidation.createValidation), authController.register);
+app.post("/login", validator(userValidation.loginValidation), authController.login);
+
+export { app as authRoutes };
+

src/modules/user/User/services/user.service.ts

@@ -0,0 +1,92 @@
+import { UserBaseService } from "../../../common/User/services/user.base.service";
+import { userModel, } from "../../../common/User/models/user.model";
+import bcrypt from "bcrypt";
+
+export class userService extends UserBaseService {
+
+    static async comparePassword(email: string, password: string) {
+        try {
+            if (email != undefined) {
+                email = email.toLowerCase();
+            }
+            let result = await UserBaseService.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
+            };
+        }
+    }
+
+    // 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)
+
+    //         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/User/validation/user.Validation.ts

@@ -0,0 +1,21 @@
+import joi from 'joi';
+import { userBaseValidation } from '../../../common/User/validation/user.baseValidation';
+
+export class userValidation extends userBaseValidation {
+    static loginValidation = {
+        body: 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/user/index.route.ts

@@ -0,0 +1,11 @@
+import express from 'express';
+const app = express();
+
+import { jwtHelper } from '../../helpers/jwt.helper';
+const allowedRoles = ["user"];
+
+import { authRoutes } from './User/routes/auth.route';
+
+app.use(authRoutes);
+
+export { app as userRoutes };