login with email and password

gambitier · gambitier · commit 82493eeceee7 · 2022-03-18T22:03:52.000+05:30
diff --git a/Projects/BooksLibrary/.env.sample b/Projects/BooksLibrary/.env.sample
@@ -6,4 +6,6 @@ API_VERSION=0.0.1
 DB_USER_NAME = someusername
 DB_USER_PASSWORD = somepass
 DB_NAME = somename
-DB_HOST = host
+DB_HOST = host
+
+USER_ACCESS_TOKEN_SECRET = test
diff --git a/Projects/BooksLibrary/src/api/controllers/user.controller.ts b/Projects/BooksLibrary/src/api/controllers/user.controller.ts
@@ -1,7 +1,7 @@
 import { UserValidator } from 'api/validators/user.validator';
 import { Authorizer } from 'auth/authorizer';
 import { ResponseHandler } from 'common/response.handler';
-import { UserDomainModel } from 'domain.types/user/user.domain.model';
+import { UserDomainModel, UserLoginDetails } from 'domain.types/user/user.domain.model';
 import { UserDetailsDto } from 'domain.types/user/user.dto';
 import express from 'express';
 import { UserService } from 'services/user.service';
@@ -55,4 +55,34 @@ export class UserController {
             ResponseHandler.handleError(request, response, err);
         }
     };
+
+    loginWithPassword = async (request: express.Request, response: express.Response): Promise<void> => {
+        try {
+            // request.context = 'User.create';
+
+            const domainData: UserLoginDetails = await UserValidator.loginWithPassword(request, response);
+
+            const userdetails = await this._service.loginWithPassword(domainData);
+
+            const message = `User '${userdetails.user.FirstName}' logged in successfully!`;
+
+            const data = {
+                AccessToken: userdetails.accessToken,
+                User: userdetails.user,
+            };
+
+            ResponseHandler.success(
+                request,
+                response,
+                message,
+                200,
+                {
+                    entity: data,
+                },
+                false
+            );
+        } catch (err) {
+            ResponseHandler.handleError(request, response, err);
+        }
+    };
 }
diff --git a/Projects/BooksLibrary/src/api/routes/auth.routes.ts b/Projects/BooksLibrary/src/api/routes/auth.routes.ts
@@ -0,0 +1,18 @@
+import express, { Router } from 'express';
+// import { Loader } from '../../startup/loader';
+import { UserController } from '../controllers/user.controller';
+
+///////////////////////////////////////////////////////////////////////////////////
+
+export const register = (app: express.Application): void => {
+    const router: Router = express.Router();
+    // const authenticator = Loader.authenticator;
+    const controller = new UserController();
+
+    router.post('/login', controller.loginWithPassword);
+    // router.get('/', authenticator.authenticateUser, controller.search);
+    // router.get('/:id', authenticator.authenticateUser, controller.getById);
+    // router.delete('/:id', authenticator.authenticateUser, controller.delete);
+
+    app.use('/api/v1/auth', router);
+};
diff --git a/Projects/BooksLibrary/src/api/routes/router.ts b/Projects/BooksLibrary/src/api/routes/router.ts
@@ -1,6 +1,7 @@
 import express from 'express';
 import { Logger } from '../../common/logger';
-import { register } from './user.routes';
+import { register as registerUserRoutes } from './user.routes';
+import { register as registerAuthRoutes } from './auth.routes';
 
 export class Router {
     private _app = null;
@@ -19,7 +20,8 @@ export class Router {
                     });
                 });
 
-                register(this._app);
+                registerUserRoutes(this._app);
+                registerAuthRoutes(this._app);
 
                 resolve(true);
             } catch (error) {
diff --git a/Projects/BooksLibrary/src/api/validators/user.validator.ts b/Projects/BooksLibrary/src/api/validators/user.validator.ts
@@ -1,11 +1,37 @@
 /* eslint-disable newline-per-chained-call */
 import { Helper } from 'common/helper';
 import { ResponseHandler } from 'common/response.handler';
-import { UserDomainModel } from 'domain.types/user/user.domain.model';
+import { UserDomainModel, UserLoginDetails } from 'domain.types/user/user.domain.model';
 import express from 'express';
 import { body, oneOf, param, query, validationResult } from 'express-validator';
 
 export class UserValidator {
+    //
+
+    static loginWithPassword = async (
+        request: express.Request,
+        response: express.Response
+    ): Promise<UserLoginDetails> => {
+        try {
+            await body('Email').isString().notEmpty().trim().run(request);
+            await body('Password').isString().notEmpty().trim().run(request);
+
+            const result = validationResult(request);
+            if (!result.isEmpty()) {
+                Helper.handleValidationError(result);
+            }
+
+            const domainModel: UserLoginDetails = {
+                Email: request.body.Email,
+                Password: request.body.Password,
+            };
+
+            return domainModel;
+        } catch (err) {
+            ResponseHandler.handleError(request, response, err);
+        }
+    };
+
     static create = async (request: express.Request, response: express.Response): Promise<UserDomainModel> => {
         try {
             await body('Prefix').optional().trim().run(request);
diff --git a/Projects/BooksLibrary/src/auth/custom/custom.authorizer.ts b/Projects/BooksLibrary/src/auth/custom/custom.authorizer.ts
@@ -66,7 +66,7 @@ export class CustomAuthorizer implements IAuthorizer {
         return false;
     };
 
-    private hasConsent = async (currentRoleId: number, context: string): Promise<boolean> => {
+    private hasConsent = async (currentRoleId: string, context: string): Promise<boolean> => {
         Logger.instance().log('Current role id: ' + currentRoleId);
         Logger.instance().log('Context: ' + context);
 
diff --git a/Projects/BooksLibrary/src/database/repository.interfaces/role.privilege.repo.interface.ts b/Projects/BooksLibrary/src/database/repository.interfaces/role.privilege.repo.interface.ts
@@ -7,9 +7,9 @@ export interface IRolePrivilegeRepo {
 
     search(): Promise<RolePrivilegeDto[]>;
 
-    getPrivilegesForRole(roleId: number): Promise<RolePrivilegeDto[]>;
+    getPrivilegesForRole(roleId: string): Promise<RolePrivilegeDto[]>;
 
-    hasPrivilegeForRole(roleId: number, privilege: string): Promise<boolean>;
+    hasPrivilegeForRole(roleId: string, privilege: string): Promise<boolean>;
 
     delete(id: string): Promise<boolean>;
 }
diff --git a/Projects/BooksLibrary/src/database/repository.interfaces/user.repo.intrerface.ts b/Projects/BooksLibrary/src/database/repository.interfaces/user.repo.intrerface.ts
@@ -2,6 +2,14 @@ import { UserDomainModel } from 'domain.types/user/user.domain.model';
 import { UserDetailsDto } from 'domain.types/user/user.dto';
 
 export interface IUserRepo {
+    getUserHashedPassword(id: string): Promise<string>;
+    findOneUser(options: UserFindOptions): Promise<UserDetailsDto>;
     findUsersByRoleId(id: string): Promise<UserDetailsDto[]>;
     createUser(userDetails: UserDomainModel): Promise<UserDetailsDto>;
 }
+
+export class UserFindOptions {
+    userId?: string;
+    email?: string;
+    isActive: boolean;
+}
diff --git a/Projects/BooksLibrary/src/database/sql/sequelize/mapper/user.mapper.ts b/Projects/BooksLibrary/src/database/sql/sequelize/mapper/user.mapper.ts
@@ -3,6 +3,10 @@ import User from '../models/user.model';
 
 export class UserMapper {
     static toDetailsDto = async (entity: User): Promise<UserDetailsDto> => {
+        if (entity === null) {
+            return null;
+        }
+
         const dto: UserDetailsDto = {
             id: entity.id,
             FirstName: entity.FirstName,
@@ -13,6 +17,7 @@ export class UserMapper {
             CreatedAt: entity.createdAt,
             UpdatedAt: entity.updatedAt,
             DeletedAt: entity.deletedAt,
+            RoleId: entity.RoleId,
         };
 
         return dto;
diff --git a/Projects/BooksLibrary/src/database/sql/sequelize/repositories/user.repo.ts b/Projects/BooksLibrary/src/database/sql/sequelize/repositories/user.repo.ts
@@ -1,10 +1,51 @@
-import { IUserRepo } from 'database/repository.interfaces/user.repo.intrerface';
+import { IUserRepo, UserFindOptions } from 'database/repository.interfaces/user.repo.intrerface';
 import { UserDomainModel } from 'domain.types/user/user.domain.model';
 import { UserDetailsDto } from 'domain.types/user/user.dto';
+import { Op } from 'sequelize';
 import { UserMapper } from '../mapper/user.mapper';
 import User from '../models/user.model';
 
 export class UserRepo implements IUserRepo {
+    async getUserHashedPassword(userId: string): Promise<string> {
+        const user: User = await User.findOne({
+            where: {
+                id: userId,
+            },
+        });
+
+        return user.Password;
+    }
+
+    async findOneUser(options: UserFindOptions): Promise<UserDetailsDto> {
+        const DeletedAt = options.isActive === true ? { DeletedAt: null } : { DeletedAt: { [Op.not]: null } };
+
+        let findByEmail = {};
+        if (options.email) {
+            findByEmail = {
+                Email: options.email,
+            };
+        }
+
+        let findByUserId = {};
+        if (options.userId) {
+            findByUserId = {
+                id: options.userId,
+            };
+        }
+
+        const user: User = await User.findOne({
+            where: {
+                ...findByEmail,
+                ...findByUserId,
+                ...DeletedAt,
+            },
+        });
+
+        const details: UserDetailsDto = await UserMapper.toDetailsDto(user);
+
+        return details;
+    }
+
     async findUsersByRoleId(roleid: string): Promise<UserDetailsDto[]> {
         const users: User[] = await User.findAll({
             where: {
diff --git a/Projects/BooksLibrary/src/domain.types/miscellaneous/current.user.ts b/Projects/BooksLibrary/src/domain.types/miscellaneous/current.user.ts
@@ -1,9 +1,6 @@
-
 export interface CurrentUser {
     UserId: string;
     DisplayName: string;
-    Phone: string;
     Email: string;
-    UserName: string;
-    CurrentRoleId: number;
+    CurrentRoleId: string;
 }
diff --git a/Projects/BooksLibrary/src/domain.types/user/user.domain.model.ts b/Projects/BooksLibrary/src/domain.types/user/user.domain.model.ts
@@ -7,3 +7,8 @@ export interface UserDomainModel {
     Password: string;
     RoleId: string;
 }
+
+export interface UserLoginDetails {
+    Email: string;
+    Password: string;
+}
diff --git a/Projects/BooksLibrary/src/domain.types/user/user.dto.ts b/Projects/BooksLibrary/src/domain.types/user/user.dto.ts
@@ -5,7 +5,7 @@ export interface UserDetailsDto {
     MiddleName: string;
     LastName: string;
     Email: string;
-
+    RoleId: string;
     CreatedAt: Date;
 
     UpdatedAt: Date;
diff --git a/Projects/BooksLibrary/src/services/role.privilege.service.ts b/Projects/BooksLibrary/src/services/role.privilege.service.ts
@@ -16,11 +16,11 @@ export class RolePrivilegeService {
         return await this._rolePrivilegeRepo.getById(id);
     };
 
-    getPrivilegesForRole = async (roleId: number): Promise<RolePrivilegeDto[]> => {
+    getPrivilegesForRole = async (roleId: string): Promise<RolePrivilegeDto[]> => {
         return await this._rolePrivilegeRepo.getPrivilegesForRole(roleId);
     };
 
-    hasPrivilegeForRole = async (roleId: number, privilege: string): Promise<boolean> => {
+    hasPrivilegeForRole = async (roleId: string, privilege: string): Promise<boolean> => {
         return await this._rolePrivilegeRepo.hasPrivilegeForRole(roleId, privilege);
     };
 
diff --git a/Projects/BooksLibrary/src/services/user.service.ts b/Projects/BooksLibrary/src/services/user.service.ts
@@ -1,8 +1,12 @@
+import { ApiError } from 'common/api.error';
+import { Helper } from 'common/helper';
 import { IRoleRepo } from 'database/repository.interfaces/user.role.repo.interface';
+import { CurrentUser } from 'domain.types/miscellaneous/current.user';
 import { RoleDto } from 'domain.types/role/role.dto';
 import { Roles } from 'domain.types/role/role.types';
-import { UserDomainModel } from 'domain.types/user/user.domain.model';
+import { UserDomainModel, UserLoginDetails } from 'domain.types/user/user.domain.model';
 import { UserDetailsDto } from 'domain.types/user/user.dto';
+import { Loader } from 'startup/loader';
 import { inject, injectable } from 'tsyringe';
 import { IUserRepo } from '../database/repository.interfaces/user.repo.intrerface';
 
@@ -17,4 +21,34 @@ export class UserService {
 
         return userDetailsDto;
     };
+
+    loginWithPassword = async (
+        loginModel: UserLoginDetails
+    ): Promise<{ user: UserDetailsDto; accessToken: string }> => {
+        const user: UserDetailsDto = await this._userRepo.findOneUser({
+            email: loginModel.Email,
+            isActive: true,
+        });
+
+        if (user === null) {
+            throw new Error('User not found.');
+        }
+
+        const hashedPassword: string = await this._userRepo.getUserHashedPassword(user.id);
+        const isPasswordValid = Helper.compare(loginModel.Password, hashedPassword);
+        if (!isPasswordValid) {
+            throw new ApiError(401, 'Invalid password!');
+        }
+
+        const currentUser: CurrentUser = {
+            UserId: user.id,
+            DisplayName: `${user.FirstName} ${user.LastName}`,
+            Email: user.Email,
+            CurrentRoleId: user.RoleId,
+        };
+
+        const accessToken = await Loader.authorizer.generateUserSessionToken(currentUser);
+
+        return { user: user, accessToken: accessToken };
+    };
 }
diff --git a/Projects/BooksLibrary/src/startup/injector.ts b/Projects/BooksLibrary/src/startup/injector.ts
@@ -1,8 +1,11 @@
+import { AuthInjector } from 'auth/auth.injector';
 import { DatabaseInjector } from 'database/database.injector';
 import { DependencyContainer } from 'tsyringe';
 
 export class Injector {
     static registerInjections(container: DependencyContainer) {
+        AuthInjector.registerInjections(container);
+
         DatabaseInjector.registerInjections(container);
     }
 }
diff --git a/Projects/BooksLibrary/src/startup/loader.ts b/Projects/BooksLibrary/src/startup/loader.ts
@@ -47,6 +47,8 @@ export class Loader {
 
             Loader._seeder = container.resolve(Seeder);
 
+            Loader._authorizer = container.resolve(Authorizer);
+
             return true;
         } catch (error) {
             Logger.instance().log(error.message);

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@ export interface IRolePrivilegeRepo {`
`7`	`7`
`8`	`8`	`search(): Promise<RolePrivilegeDto[]>;`
`9`	`9`
`10`		`- getPrivilegesForRole(roleId: number): Promise<RolePrivilegeDto[]>;`
	`10`	`+ getPrivilegesForRole(roleId: string): Promise<RolePrivilegeDto[]>;`
`11`	`11`
`12`		`- hasPrivilegeForRole(roleId: number, privilege: string): Promise<boolean>;`
	`12`	`+ hasPrivilegeForRole(roleId: string, privilege: string): Promise<boolean>;`
`13`	`13`
`14`	`14`	`delete(id: string): Promise<boolean>;`
`15`	`15`	`}`