update user, auth, token, roles, done

src/controllers/auth.ts

@@ -0,0 +1,196 @@
+import { Request, Response, NextFunction, Application } from "express";
+import { ReturnHelper } from "../helpers/express/return";
+import { OrmHelper } from "../helpers/orm";
+import { User } from "../entity/users";
+import Joi from "joi";
+import config from "config";
+import { ILogObj, Logger } from "tslog";
+import { Language } from "../langs/lang";
+import { UserRefreshToken } from "../entity/user_refresh_token";
+import { UAParser } from 'ua-parser-js';
+import dayjs from 'dayjs'
+import jwt from 'jsonwebtoken';
+import fs from 'fs';
+import { UserRole } from "../entity/users_roles";
+
+const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' });
+
+export class AuthController {
+    static async login(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['Auth']
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'Login data',
+            required: true,
+            schema: {
+                username: "admin",
+                password: "123456"
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                username: Joi.string().max(64).required().label('Username'),
+                password: Joi.string().alphanum().min(6).required().label('Password')
+            });
+
+            const param: User = await schema.validateAsync(req.body);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+            const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken);
+
+            const user = await userRepository.findOne({
+                select: ['id', 'email', 'password', 'username'],
+                where: { username: param.username },
+            })
+
+            if (user != null && user.checkIfPasswordMatch(param.password)) {
+
+                const { browser, device, os } = UAParser(req.get('User-Agent'));
+
+                const refresh_token = new UserRefreshToken();
+                refresh_token.id_user = user.id;
+                refresh_token.user_agent = req.get('User-Agent');
+                refresh_token.remote_addr = req.ip;
+                refresh_token.browser = browser.name + " " + browser.version;
+                refresh_token.os = os.name + " " + os.version;
+                refresh_token.device = device.model + " " + device.vendor;
+                refresh_token.platform = device.type ?? 'desktop';
+                refresh_token.expired_at = dayjs().add(config.get('auth.refresh_token_lifetime_day'), 'day').toDate();
+
+                await userRefreshTokenRepository.save(refresh_token);
+
+                const userRoleRepository = OrmHelper.DB.getRepository(UserRole);
+                const userRole = await userRoleRepository.findOneBy({ id: user.id_role })
+
+                var privateKey = fs.readFileSync('src/helpers/key/private.key');
+
+                var token = jwt.sign(
+                    {
+                        exp: Math.floor(Date.now() / 1000) + (Number(config.get('auth.access_token_lifetime'))),
+                        data: {
+                            id: user.id,
+                            username: user.username,
+                            id_role: user.id_role,
+                            roles: userRole.roles
+                        }
+                    },
+                    privateKey,
+                    { algorithm: 'RS256' }
+                );
+
+                delete user.password;
+
+                const data = {
+                    user,
+                    token: {
+                        access_token: token,
+                        refresh_token: refresh_token.refresh_token
+                    }
+                }
+
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_login, data);
+            }
+
+            return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_insert, err.message);
+        }
+    }
+
+    static async logout(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['Auth']
+         #swagger.parameters['refresh_token'] = {
+            in: 'path',
+            description: 'Refresh Token',
+            required: true,
+            type: 'string'
+        }
+        */
+
+        try {
+            const schema = Joi.object().keys({
+                refresh_token: Joi.string().uuid().required().label('Refresh Token'),
+            });
+
+            const param: UserRefreshToken = await schema.validateAsync(req.params);
+
+            const repo = OrmHelper.DB.getRepository(UserRefreshToken);
+
+            const affected = (await repo.delete({ refresh_token: param.refresh_token })).affected;
+
+            if (affected > 0) {
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_logout);
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_logout, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_logout, err.message);
+        }
+    }
+
+    static async renewToken(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['Auth']
+         #swagger.parameters['refresh_token'] = {
+            in: 'path',
+            description: 'Refresh Token',
+            required: true,
+            type: 'string'
+        }
+        */
+        try {
+            const schema = Joi.object().keys({
+                refresh_token: Joi.string().uuid().required().label('Refresh Token'),
+            });
+
+            const param: UserRefreshToken = await schema.validateAsync(req.params);
+
+            const userRefreshTokenRepo = OrmHelper.DB.getRepository(UserRefreshToken);
+
+            const refresh_token = await userRefreshTokenRepo.findOneBy({ refresh_token: param.refresh_token });
+
+            if (refresh_token != null) {
+                const userRepo = OrmHelper.DB.getRepository(User);
+
+                const user = await userRepo.findOneBy({ id: refresh_token.id_user });
+
+                const userRoleRepository = OrmHelper.DB.getRepository(UserRole);
+                const userRole = await userRoleRepository.findOneBy({ id: user.id_role })
+
+                var privateKey = fs.readFileSync('src/helpers/key/private.key');
+
+                var token = jwt.sign(
+                    {
+                        exp: Math.floor(Date.now() / 1000) + (Number(config.get('auth.access_token_lifetime'))),
+                        data: {
+                            id: user.id,
+                            username: user.username,
+                            id_role: user.id_role,
+                            roles: userRole.roles
+                        }
+                    },
+                    privateKey,
+                    { algorithm: 'RS256' }
+                );
+
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success, { token });
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed, err.message);
+        }
+    }
+}