update user, auth, token, roles, done

config/default.json

@@ -20,5 +20,9 @@
         "username": "postgres",
         "password": "123",
         "database": "bri-erp"
+    },
+    "auth": {
+        "refresh_token_lifetime_day": 30,
+        "access_token_lifetime": 300
     }
 }

package.json

@@ -18,10 +18,13 @@
         "compression": "^1.7.5",
         "config": "^3.3.12",
         "cors": "^2.8.5",
+        "dayjs": "^1.11.13",
         "express": "^4.21.1",
+        "express-jwt": "^8.4.1",
         "helmet": "^8.0.0",
         "i": "^0.3.7",
         "joi": "^17.13.3",
+        "jsonwebtoken": "^9.0.2",
         "morgan": "^1.10.0",
         "npm": "^10.9.1",
         "pg": "^8.13.1",
@@ -30,7 +33,8 @@
         "swagger-jsdoc": "^6.2.8",
         "swagger-ui-express": "^5.0.1",
         "tslog": "^4.9.3",
-        "typeorm": "^0.3.20"
+        "typeorm": "^0.3.20",
+        "ua-parser-js": "^2.0.0"
     },
     "devDependencies": {
         "@types/bcryptjs": "^2.4.6",

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);
+        }
+    }
+}

src/controllers/user.ts

@@ -0,0 +1,422 @@
+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 { ILogObj, Logger } from "tslog";
+import { Language } from "../langs/lang";
+import { Paging } from "../types/paging";
+import CommonHelper from "../helpers/common";
+
+const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' });
+
+export class UserController {
+    static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+        #swagger.security = [{
+            "bearerAuth": []
+        }]
+        #swagger.parameters['filter'] = {
+            in: 'query',
+            type: 'string'
+        }
+        #swagger.parameters['limit'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['page'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['with_deleted'] = {
+            in: 'query',
+            required: true,
+            type: 'boolean'
+        }
+        #swagger.parameters['order_field'] = {
+            in: 'query',
+            required: true,
+            type: 'string'
+        }
+        #swagger.parameters['order_direction'] = {
+            in: 'query',
+            required: true,
+            enum: [ "ASC", "DESC"]
+        }
+        */
+
+        try {
+            const schema = Joi.object().keys({
+                filter: Joi.string().allow('').optional().label('Filter'),
+                page: Joi.number().required().min(1).label('Page'),
+                limit: Joi.number().required().min(1).label('Limit'),
+                with_deleted: Joi.bool().required().label('With Deleted'),
+                order_field: Joi.string().required().label('Order Field'),
+                order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
+            });
+
+            const param: Paging = await schema.validateAsync(req.query);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const offset = (param.page - 1) * param.limit
+
+            let whereAttr = '';
+            let whereVal: any = {};
+
+            if (param.filter) {
+                whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
+                whereVal['filter'] = param.filter
+                whereVal['filter_like'] = '%' + param.filter + '%'
+            }
+
+            const res_count = userRepository.createQueryBuilder()
+                .where(whereAttr, whereVal);
+            const res_list = userRepository.createQueryBuilder()
+                .where(whereAttr, whereVal)
+                .orderBy(param.order_field, param.order_direction)
+                .skip(offset)
+                .limit(param.limit);
+
+            if (param.with_deleted) {
+                res_count.withDeleted();
+                res_list.withDeleted();
+            }
+
+            const current_page = param.page;
+            const total_count_data = await res_count.getCount();
+            const list_data = await res_list.getMany();
+            const count_data = CommonHelper.countObject(list_data);
+
+            return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
+        }
+    }
+
+    static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'User data',
+            required: true,
+            schema: {
+                email: "admin@gmail.com",
+                username: "admin",
+                password: "123456",
+                retype_password: "123456",
+                name: "Administrator",
+                id_role: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
+                status:"Y"
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                email: Joi.string().email().max(64).required().label('Email'),
+                username: Joi.string().max(64).required().label('Username'),
+                password: Joi.string().alphanum().min(6).required().label('Password'),
+                retype_password: Joi.ref('password'),
+                name: Joi.string().max(64).required().label('Name'),
+                id_role: Joi.string().uuid().required().label('Role'),
+                status: Joi.string().required().label('Status'),
+            });
+
+            const param: User = await schema.validateAsync(req.body);
+
+            const data = new User()
+            data.name = param.name
+            data.username = param.username
+            data.password = param.password
+            data.email = param.email
+            data.id_role = param.id_role
+            data.status = param.status
+
+            data.hashPassword();
+
+            await OrmHelper.DB.manager.save(data);
+
+            return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
+        }
+    }
+
+    static async updateProfile(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+         #swagger.parameters['id'] = {
+            in: 'path',
+            description: 'User ID.',
+            required: true,
+            type: 'string'
+        }
+
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'User data',
+            required: true,
+            schema: {
+                email: "admin@gmail.com",
+                username: "admin",
+                name: "Administrator"
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label('ID'),
+                email: Joi.string().email().max(64).required().label('Email'),
+                username: Joi.string().max(64).required().label('Username'),
+                name: Joi.string().max(64).required().label('Name'),
+            });
+
+            req.body.id = req.params['id'];
+
+            const param: User = await schema.validateAsync(req.body);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const data = await userRepository.findOneBy({ id: param.id });
+
+            if (data != null) {
+                data.name = param.name
+                data.username = param.username
+                data.email = param.email
+
+                await userRepository.save(data);
+
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
+        }
+    }
+
+    static async updatePassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+         #swagger.parameters['id'] = {
+            in: 'path',
+            description: 'User ID.',
+            required: true,
+            type: 'string'
+        }
+
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'User data',
+            required: true,
+            schema: {
+                password: "123456",
+                retype_password: "123456",
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label('ID'),
+                password: Joi.string().required().label('Password'),
+                retype_password: Joi.ref('password'),
+            });
+
+            req.body.id = req.params['id'];
+
+            const param: User = await schema.validateAsync(req.body);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const data = await userRepository.findOneBy({ id: param.id });
+
+            if (data != null) {
+                if (param.password) {
+                    data.password = param.password
+                    data.hashPassword();
+                }
+
+                await userRepository.save(data);
+
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
+        }
+    }
+
+    static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+         #swagger.parameters['id'] = {
+            in: 'path',
+            description: 'User ID.',
+            required: true,
+            type: 'string'
+        }
+
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'User data',
+            required: true,
+            schema: {
+                email: "admin@gmail.com",
+                username: "admin",
+                password: "123456",
+                retype_password: "123456",
+                name: "Administrator",
+                id_role: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
+                status:"Y"
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label('ID'),
+                email: Joi.string().email().max(64).required().label('Email'),
+                username: Joi.string().max(64).required().label('Username'),
+                password: Joi.string().allow('').optional().label('Password'),
+                retype_password: Joi.ref('password'),
+                name: Joi.string().max(64).required().label('Name'),
+                id_role: Joi.string().uuid().required().label('Role'),
+                status: Joi.string().required().label('Status'),
+            });
+
+            req.body.id = req.params['id'];
+
+            const param: User = await schema.validateAsync(req.body);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const data = await userRepository.findOneBy({ id: param.id });
+
+            if (data != null) {
+                data.name = param.name
+                data.username = param.username
+                data.email = param.email
+                data.id_role = param.id_role
+                data.status = param.status
+
+                if (param.password) {
+                    data.password = param.password
+                    data.hashPassword();
+                }
+
+                await userRepository.save(data);
+
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
+        }
+    }
+
+    static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+        #swagger.parameters['id'] = {
+            in: 'path',
+            description: 'User ID.',
+            required: true,
+            type: 'string'
+        }
+        */
+        try {
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label('ID')
+            });
+
+            const param: User = await schema.validateAsync(req.params);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const affected = (await userRepository.softDelete({ id: param.id })).affected;
+
+            if (affected > 0) {
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {});
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message);
+        }
+    }
+
+    static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User']
+#swagger.security = [{
+            "bearerAuth": []
+        }]
+        #swagger.parameters['id'] = {
+            in: 'path',
+            description: 'User ID.',
+            required: true,
+            type: 'string'
+        }
+        */
+        try {
+            const schema = Joi.object().keys({
+                id: Joi.string().uuid().required().label('ID')
+            });
+
+            const param: User = await schema.validateAsync(req.params);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const affected = (await userRepository.restore({ id: param.id })).affected;
+
+            if (affected > 0) {
+                return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {});
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_restore, err.message);
+        }
+    }
+}

src/controllers/user_activity.ts

@@ -0,0 +1,152 @@
+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 { ILogObj, Logger } from "tslog";
+import { Language } from "../langs/lang";
+import { Paging } from "../types/paging";
+import CommonHelper from "../helpers/common";
+import { ActivityType } from "../types/action";
+import { UserActivity } from "../entity/user_activity";
+
+const log: Logger<ILogObj> = new Logger({ name: '[UserActivityController]', type: 'pretty' });
+
+export class UserActivityController {
+    static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User Activity']
+        #swagger.parameters['filter'] = {
+            in: 'query',
+            type: 'string'
+        }
+        #swagger.parameters['limit'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['page'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['with_deleted'] = {
+            in: 'query',
+            required: true,
+            type: 'boolean'
+        }
+        #swagger.parameters['order_field'] = {
+            in: 'query',
+            required: true,
+            type: 'string'
+        }
+        #swagger.parameters['order_direction'] = {
+            in: 'query',
+            required: true,
+            enum: [ "ASC", "DESC"]
+        }
+        */
+
+        try {
+            const schema = Joi.object().keys({
+                filter: Joi.string().allow('').optional().label('Filter'),
+                page: Joi.number().required().min(1).label('Page'),
+                limit: Joi.number().required().min(1).label('Limit'),
+                with_deleted: Joi.bool().required().label('With Deleted'),
+                order_field: Joi.string().required().label('Order Field'),
+                order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
+            });
+
+            const param: Paging = await schema.validateAsync(req.query);
+
+            const userRepository = OrmHelper.DB.getRepository(User);
+
+            const offset = (param.page - 1) * param.limit
+
+            let whereAttr = '';
+            let whereVal: any = {};
+
+            if (param.filter) {
+                whereAttr = 'module like :filter_like or username like :filter_like or email = :filter ';
+                whereVal['filter'] = param.filter
+                whereVal['filter_like'] = '%' + param.filter + '%'
+            }
+
+            const res_count = userRepository.createQueryBuilder()
+                .where(whereAttr, whereVal);
+            const res_list = userRepository.createQueryBuilder()
+                .where(whereAttr, whereVal)
+                .orderBy(param.order_field, param.order_direction)
+                .skip(offset)
+                .limit(param.limit);
+
+            if (param.with_deleted) {
+                res_count.withDeleted();
+                res_list.withDeleted();
+            }
+
+            const current_page = param.page;
+            const total_count_data = await res_count.getCount();
+            const list_data = await res_list.getMany();
+            const count_data = CommonHelper.countObject(list_data);
+
+            return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
+        }
+    }
+
+    static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User Activity']
+        #swagger.parameters['body'] = {
+            in: 'body',
+            description: 'User Activity data',
+            required: true,
+            schema: {
+                id_user: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
+                refresh_token: "1a1221b6-78a0-4b3b-bf5c-fa0af5f69be8",
+                module: "dashboard",
+                description: "Main Dashboard",
+                action: "V",
+                url: "https://bri-dev.shiblysolution.id/",
+                data_body:"{\"from\":\"2024-11-01\",\"to\":\"2024-11-26\"}"
+            }
+        }*/
+
+        try {
+            const schema = Joi.object().keys({
+                id_user: Joi.string().uuid().required().label('ID User'),
+                refresh_token: Joi.string().uuid().required().label('Refresh Token'),
+                module: Joi.string().required().label('Module'),
+                description: Joi.string().required().label('Description'),
+                action: Joi.string().allow(...Object.values(ActivityType)).required().label('Action'),
+                url: Joi.string().optional().allow('').label('URL'),
+                data_body: Joi.string().optional().allow('').label('data_body'),
+            });
+
+            const param: UserActivity = await schema.validateAsync(req.body);
+
+            const data = new UserActivity()
+            data.id_user = param.id_user
+            data.refresh_token = param.refresh_token
+            data.module = param.module
+            data.description = param.description
+            data.action = param.action
+            data.url = param.url
+            data.data_body = param.data_body
+
+            await OrmHelper.DB.manager.save(data);
+
+            return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
+        }
+    }
+}

src/controllers/user_refresh_token.ts

@@ -0,0 +1,127 @@
+import { Request, Response, NextFunction, Application } from "express";
+import { ReturnHelper } from "../helpers/express/return";
+import { OrmHelper } from "../helpers/orm";
+import Joi from "joi";
+import { ILogObj, Logger } from "tslog";
+import { Language } from "../langs/lang";
+import { Paging } from "../types/paging";
+import CommonHelper from "../helpers/common";
+import { UserRefreshToken } from "../entity/user_refresh_token";
+
+const log: Logger<ILogObj> = new Logger({ name: '[UserRefreshTokenController]', type: 'pretty' });
+
+export class UserRefreshTokenController {
+    static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User Refresh Token']
+        #swagger.parameters['filter'] = {
+            in: 'query',
+            type: 'string'
+        }
+        #swagger.parameters['limit'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['page'] = {
+            in: 'query',
+            required: true,
+            type: 'number'
+        }
+        #swagger.parameters['order_field'] = {
+            in: 'query',
+            required: true,
+            type: 'string'
+        }
+        #swagger.parameters['order_direction'] = {
+            in: 'query',
+            required: true,
+            enum: [ "ASC", "DESC"]
+        }
+        */
+
+        try {
+            const schema = Joi.object().keys({
+                filter: Joi.string().allow('').optional().label('Filter'),
+                page: Joi.number().required().min(1).label('Page'),
+                limit: Joi.number().required().min(1).label('Limit'),
+                order_field: Joi.string().required().label('Order Field'),
+                order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
+            });
+
+            const param: Paging = await schema.validateAsync(req.query);
+
+            const repo = OrmHelper.DB.getRepository(UserRefreshToken);
+
+            const offset = (param.page - 1) * param.limit
+
+            let whereAttr = '';
+            let whereVal: any = {};
+
+            if (param.filter) {
+                whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
+                whereVal['filter'] = param.filter
+                whereVal['filter_like'] = '%' + param.filter + '%'
+            }
+
+            const res_count = repo.createQueryBuilder()
+                .where(whereAttr, whereVal);
+            const res_list = repo.createQueryBuilder()
+                .where(whereAttr, whereVal)
+                .orderBy(param.order_field, param.order_direction)
+                .skip(offset)
+                .limit(param.limit);
+
+            if (param.with_deleted) {
+                res_count.withDeleted();
+                res_list.withDeleted();
+            }
+
+            const current_page = param.page;
+            const total_count_data = await res_count.getCount();
+            const list_data = await res_list.getMany();
+            const count_data = CommonHelper.countObject(list_data);
+
+            return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
+        }
+    }
+
+    static async forceLogout(req: Request, res: Response, next: NextFunction): Promise<Response> {
+        /*
+        #swagger.tags = ['User Refresh Token']
+        #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_delete, {});
+            } else {
+                return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
+            }
+        } catch (e: unknown) {
+            log.error(e);
+            const err = e as Error;
+
+            return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message);
+        }
+    }
+}

src/controllers/user_roles.ts

@@ -1,18 +1,20 @@
 import { Request, Response, NextFunction, Application } from "express";
-import { ReturnHelper } from "../../helpers/express/return";
+import { ReturnHelper } from "../helpers/express/return";
-import { OrmHelper } from "../../helpers/orm";
+import { OrmHelper } from "../helpers/orm";
-import { User } from "../../entity/users";
 import Joi from "joi";
 import { ILogObj, Logger } from "tslog";
-import { Language } from "../../langs/lang";
+import { Language } from "../langs/lang";
-import { Paging } from "../../types/paging";
+import { Paging } from "../types/paging";
-import CommonHelper from "../../helpers/common";
+import CommonHelper from "../helpers/common";
+import { Status } from "../types/status";
+import { UserRole } from "../entity/users_roles";
 
-const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' });
+const log: Logger<ILogObj> = new Logger({ name: '[UserRoleController]', type: 'pretty' });
 
-export class UserController {
+export class UserRoleController {
     static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
         /*
+        #swagger.tags = ['User Roles']
         #swagger.parameters['filter'] = {
             in: 'query',
             type: 'string'
@@ -56,7 +58,7 @@ export class UserController {
 
             const param: Paging = await schema.validateAsync(req.query);
 
-            const userRepository = OrmHelper.DB.getRepository(User);
+            const repo = OrmHelper.DB.getRepository(UserRole);
 
             const offset = (param.page - 1) * param.limit
 
@@ -64,14 +66,14 @@ export class UserController {
             let whereVal: any = {};
 
             if (param.filter) {
-                whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
+                whereAttr = 'name like :filter_like';
-                whereVal['filter'] = param.filter
+                // whereVal['filter'] = param.filter
                 whereVal['filter_like'] = '%' + param.filter + '%'
             }
 
-            const res_count = userRepository.createQueryBuilder()
+            const res_count = repo.createQueryBuilder()
                 .where(whereAttr, whereVal);
-            const res_list = userRepository.createQueryBuilder()
+            const res_list = repo.createQueryBuilder()
                 .where(whereAttr, whereVal)
                 .orderBy(param.order_field, param.order_direction)
                 .skip(offset)
@@ -87,7 +89,7 @@ export class UserController {
             const list_data = await res_list.getMany();
             const count_data = CommonHelper.countObject(list_data);
 
-            return ReturnHelper.successResponseList(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
+            return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
         } catch (e: unknown) {
             log.error(e);
             const err = e as Error;
@@ -98,40 +100,30 @@ export class UserController {
 
     static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
         /*
+        #swagger.tags = ['User Roles']
         #swagger.parameters['body'] = {
             in: 'body',
-            description: 'User data',
+            description: 'User role data',
             required: true,
             schema: {
-                email: "admin@gmail.com",
-                username: "admin",
-                password: "123456",
-                retype_password: "123456",
                 name: "Administrator",
-                role: "ADMINISTRATOR",
+                roles: ["dashboard"],
                 status:"Y"
             }
         }*/
 
         try {
             const schema = Joi.object().keys({
-                email: Joi.string().email().max(64).required().label('Email'),
-                username: Joi.string().max(64).required().label('Username'),
-                password: Joi.string().alphanum().min(6).required().label('Password'),
-                retype_password: Joi.ref('password'),
                 name: Joi.string().max(64).required().label('Name'),
-                role: Joi.string().required().label('Role'),
+                roles: Joi.array().required().label('Roles'),
-                status: Joi.string().required().label('Status'),
+                status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
             });
 
-            const param: User = await schema.validateAsync(req.body);
+            const param: UserRole = await schema.validateAsync(req.body);
 
-            const data = new User()
+            const data = new UserRole()
             data.name = param.name
-            data.username = param.username
+            data.roles = param.roles
-            data.password = param.password
-            data.email = param.email
-            data.role = param.role
             data.status = param.status
 
             await OrmHelper.DB.manager.save(data);
@@ -147,24 +139,21 @@ export class UserController {
 
     static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
         /*
+        #swagger.tags = ['User Roles']
          #swagger.parameters['id'] = {
             in: 'path',
-            description: 'User ID.',
+            description: 'User role ID.',
             required: true,
-            type: 'uuid'
+            type: 'string'
         }
 
         #swagger.parameters['body'] = {
             in: 'body',
-            description: 'User data',
+            description: 'User role data',
             required: true,
             schema: {
-                email: "admin@gmail.com",
-                username: "admin",
-                password: "123456",
-                retype_password: "123456",
                 name: "Administrator",
-                role: "ADMINISTRATOR",
+                roles: ["dashboard"],
                 status:"Y"
             }
         }*/
@@ -172,32 +161,25 @@ export class UserController {
         try {
             const schema = Joi.object().keys({
                 id: Joi.string().uuid().required().label('ID'),
-                email: Joi.string().email().max(64).required().label('Email'),
-                username: Joi.string().max(64).required().label('Username'),
-                password: Joi.string().allow('').optional().label('Password'),
-                retype_password: Joi.ref('password'),
                 name: Joi.string().max(64).required().label('Name'),
-                role: Joi.string().required().label('Role'),
+                roles: Joi.array().required().label('Roles'),
-                status: Joi.string().required().label('Status'),
+                status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
             });
 
             req.body.id = req.params['id'];
 
-            const param: User = await schema.validateAsync(req.body);
+            const param: UserRole = await schema.validateAsync(req.body);
 
-            const userRepository = OrmHelper.DB.getRepository(User);
+            const repo = OrmHelper.DB.getRepository(UserRole);
 
-            const data = await userRepository.findOneBy({ id: param.id });
+            const data = await repo.findOneBy({ id: param.id });
 
             if (data != null) {
                 data.name = param.name
-                data.username = param.username
+                data.roles = param.roles
-                data.password = param.password
-                data.email = param.email
-                data.role = param.role
                 data.status = param.status
 
-                await userRepository.save(data);
+                await repo.save(data);
 
                 return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
             } else {
@@ -213,11 +195,12 @@ export class UserController {
 
     static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
         /*
+        #swagger.tags = ['User Roles']
         #swagger.parameters['id'] = {
             in: 'path',
-            description: 'User ID.',
+            description: 'User role ID.',
             required: true,
-            type: 'uuid'
+            type: 'string'
         }
         */
         try {
@@ -225,11 +208,11 @@ export class UserController {
                 id: Joi.string().uuid().required().label('ID')
             });
 
-            const param: User = await schema.validateAsync(req.params);
+            const param: UserRole = await schema.validateAsync(req.params);
 
-            const userRepository = OrmHelper.DB.getRepository(User);
+            const repo = OrmHelper.DB.getRepository(UserRole);
 
-            const affected = (await userRepository.softDelete({ id: param.id })).affected;
+            const affected = (await repo.softDelete({ id: param.id })).affected;
 
             if (affected > 0) {
                 return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {});
@@ -246,11 +229,12 @@ export class UserController {
 
     static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
         /*
+        #swagger.tags = ['User Roles']
         #swagger.parameters['id'] = {
             in: 'path',
-            description: 'User ID.',
+            description: 'User role ID.',
             required: true,
-            type: 'uuid'
+            type: 'string'
         }
         */
         try {
@@ -258,11 +242,11 @@ export class UserController {
                 id: Joi.string().uuid().required().label('ID')
             });
 
-            const param: User = await schema.validateAsync(req.params);
+            const param: UserRole = await schema.validateAsync(req.params);
 
-            const userRepository = OrmHelper.DB.getRepository(User);
+            const repo = OrmHelper.DB.getRepository(UserRole);
 
-            const affected = (await userRepository.restore({ id: param.id })).affected;
+            const affected = (await repo.restore({ id: param.id })).affected;
 
             if (affected > 0) {
                 return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {});

src/entity/user_refresh_token.ts

@@ -3,7 +3,7 @@ import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateCol
 @Entity('user_refresh_tokens')
 export class UserRefreshToken {
     @PrimaryGeneratedColumn('uuid')
-    id: string;
+    refresh_token: string;
 
     @Index()
     @Column({
@@ -19,10 +19,22 @@ export class UserRefreshToken {
 
     @Column({
         nullable: true,
-        length: 64
+        length: 128
     })
     os: string;
 
+    @Column({
+        nullable: true,
+        length: 256
+    })
+    device: string;
+
+    @Column({
+        nullable: true,
+        length: 64
+    })
+    platform: string;
+
     @Column({
         nullable: true,
         length: 64
@@ -35,6 +47,9 @@ export class UserRefreshToken {
     })
     remote_addr: string;
 
+    @Column('timestamp')
+    expired_at: Date;
+
     @Column()
     @CreateDateColumn()
     created_at: Date;

src/entity/users.ts

@@ -1,7 +1,6 @@
 import bcrypt from 'bcryptjs';
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn } from 'typeorm';
 
-import { Role } from '../types/role';
 import { Status } from '../types/status';
 
 @Entity('users')
@@ -38,10 +37,9 @@ export class User {
 
     @Column({
         nullable: false,
-        default: 'STAFF' as Role,
+        type: 'uuid'
-        length: 30,
     })
-    role: Role;
+    id_role: string;
 
     @Column({
         nullable: false,

src/entity/users_roles.ts

@@ -0,0 +1,41 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn } from 'typeorm';
+
+import { Status } from '../types/status';
+import { RoleList } from '../types/role';
+
+@Entity('user_roles')
+export class UserRole {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column({
+        nullable: false,
+        unique: true,
+        length: 128
+    })
+    name: string;
+
+    @Column({
+        nullable: false,
+        type: 'jsonb'
+    })
+    roles: RoleList[];
+
+    @Column({
+        nullable: false,
+        length: 64
+    })
+    status: Status;
+
+    @Column()
+    @CreateDateColumn()
+    created_at: Date;
+
+    @Column({ nullable: true })
+    @UpdateDateColumn()
+    updated_at: Date;
+
+    @Column({ nullable: true })
+    @DeleteDateColumn()
+    deleted_at: Date;
+}

src/helpers/express/return.ts

@@ -17,7 +17,7 @@ export class ReturnHelper {
         });
     };
 
-    static successResponseList(
+    static successResponselist(
         res: Response,
         status_code: number,
         message: string,

src/helpers/express/swagger.ts

@@ -6,7 +6,7 @@ import swaggerDocument from '../../swagger/swagger.json';
 export class SwaggerHelper {
     static setup(app: express.Application) {
         var options = {
-            explorer: false
+            explorer: false,
         };
 
         app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument, options));

src/helpers/express/trust_proxy.ts

@@ -0,0 +1,7 @@
+import express from 'express';
+
+export class TrustProxyHelper {
+    static setup(app: express.Application) {
+        app.set('trust proxy', true);
+    }
+}

src/helpers/jwt.ts

@@ -0,0 +1,38 @@
+import { NextFunction, Response } from 'express';
+import { Logger, ILogObj } from 'tslog';
+import { Request, expressjwt } from "express-jwt";
+import fs from 'fs';
+import { Language } from '../langs/lang';
+import { ReturnHelper } from './express/return';
+import express from 'express';
+
+const log: Logger<ILogObj> = new Logger({ name: '[JwtHelper]', type: 'pretty' });
+
+export default class JwtHelper {
+    static secure = (app: express.Application) => {
+
+        var publicKey = fs.readFileSync("src/helpers/key/public.key");
+
+        app.use(
+            expressjwt({
+                secret: publicKey, algorithms: ["RS256"]
+            }).unless({ path: ["/token"] }),
+            function (req: Request, res: Response, next: NextFunction) {
+                if (!req.auth?.data.id) {
+                    return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access);
+                }
+
+                return next();
+            }
+        )
+
+        app.use(function (err: any, req: Request, res: Response, next: NextFunction) {
+            if (err.name === 'UnauthorizedError') {
+                return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access);
+            }
+
+            return next();
+        });
+
+    }
+}

src/helpers/key/private.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC0sdcneY7W32xE
+8hbjFPR4/AZFdtQqwQ3lEsuUFcsYh2KR0wP0umqtIMGLle3603lhQ/AMXDlKBBJt
+IAP1SJNvGYY6fUdm+AZ0NFmst3CCiFsw7N5F+KXKEW1g/vUO9OKJ2Hg9lXuOkYAh
+DYv+d0R5nsHu5l7WAesHtrcuNwezmENeAwjgWNezlwJmf54soNrV+EE7zPxTyye1
+se3b8LjMgB/zDTF2UkdrvrVulpshG0JMvDy1n7QG/+K3u3BcGakRws5GZu7LZug4
+ZNdURajL0oqN9bxPQRWR5+7jVqm1gYNRGQfPJuBXUiqd/AXa+ap0M0RPBFWfomjf
+xn21QpdVAgMBAAECggEAKUMRHCEMhrG3YhkcM9fFqdj3P6aOdYLnPt+nYFYHrj7A
+OgeDOD/Xe1hnCg5/LQ9cgOMILnJi3K2IXaX5cWoUzMJ53eJcyz0pECEiNygeh5hG
+pqn4aecJSNbo8MTXxgYSsyKc9ocrk1dTeHjE9qNaniEsLPcrQdhnSLgnJWUIm7Bv
+HqFFhgINdbZmE3Wx0a1Y71jGePcm3Zqx0a5sZDmZN2Vh7fNs1X8y2rnNvsKOBG5T
+RmB8zlnj5SkjtD9RKkis0gGDVGjtkfskClY6wARUgSajfJnBAwpbdqrR0bmOox5k
+T39aL6dxcPBQc8L0HX1sYW4yCIba1snxOUXtLEjdkQKBgQDwepPKv09waBlp7Q5W
+c7Fn5dLBJ8ungbeDf83jZbIUs2I0wJ0v/UJiUegVP/h005kpEyY9NjFhcN5GXnTo
+Ru1jmZ2w0UC+iOa7+JplXsS7kZfieaPIWHcmg0IkQpWHXRjoeWrd2dA+unc+6BGf
+ZvUlb9XPZBATShARnjHu1z5CiQKBgQDAW3PBjLwgrT7NlRkpjuLMEvzimso1yTKa
+yYdTNhJYkz5YnlPeu197seqqeGQPuRuR9KlMjfe7IQOvo0AGNB7VMxCxfF0Obyb9
+hBT5fFci5dweKqgN3bR/+ppj/bpLS0veMwYNKzhaHsMrwRQzaxrRypRkri2rT7dx
+jZAI0ilrbQKBgGmk//5m80gng1qkmNLj+oDxVxgiGnbZJryvTczjZUtwzujr4WIu
+uZYl83Y6ZzUzrCp+TiNABouPISb64hMU7b7+wmbmVrIdxHe5rGJyMq1QNdB5rbkb
+HCUgLtNtKPGRtZqTlJ4nzTNxiWdqXiuP+IxcyCpXBDTlKZAD1l3d0205AoGBAJTk
+NO2UKeqBLyOiTR/F4fdkmyor9mk7m1gEtiLKr9iv4IpnwzOchYQRazsYhRtGhPit
+EH6ZRTArldbV3jDvFw6fwEQhp0YM83k4S6PxguEYWxFeo0ZYXebR67+KHjE5zzfm
+9sAqvCvFs/yiLyi9try8ubBUwjTgN3ZFxT+OrVDhAoGAUhFkd/Fy0FCsMROPKK5l
+uadRukj5zKLMw+JJegXO+0AntV2vWPam73x2ulvVig9TqrJLqtOfqYNNX789Fzri
+PBcqDaMJKfMc6ac7YgZTNP6vk7avjqWUpoJqlj1g8y3suAYkm/xfLd1HvAqQh0p8
+i3/cmSzkc1MCE2YxYop0gpc=
+-----END PRIVATE KEY-----

src/helpers/key/public.key

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtLHXJ3mO1t9sRPIW4xT0
+ePwGRXbUKsEN5RLLlBXLGIdikdMD9LpqrSDBi5Xt+tN5YUPwDFw5SgQSbSAD9UiT
+bxmGOn1HZvgGdDRZrLdwgohbMOzeRfilyhFtYP71DvTiidh4PZV7jpGAIQ2L/ndE
+eZ7B7uZe1gHrB7a3LjcHs5hDXgMI4FjXs5cCZn+eLKDa1fhBO8z8U8sntbHt2/C4
+zIAf8w0xdlJHa761bpabIRtCTLw8tZ+0Bv/it7twXBmpEcLORmbuy2boOGTXVEWo
+y9KKjfW8T0EVkefu41aptYGDURkHzybgV1IqnfwF2vmqdDNETwRVn6Jo38Z9tUKX
+VQIDAQAB
+-----END PUBLIC KEY-----

src/helpers/orm.ts

@@ -2,8 +2,9 @@ import config from 'config';
 import { DataSource } from "typeorm";
 import { User } from "../entity/users";
 import { ILogObj, Logger } from 'tslog';
-import { UserActivity } from '../entity/users_activity';
+import { UserActivity } from '../entity/user_activity';
-import { UserRefreshToken } from '../entity/users_refresh_token';
+import { UserRefreshToken } from '../entity/user_refresh_token';
+import { UserRole } from '../entity/users_roles';
 
 export class OrmHelper {
     static DB: DataSource = null
@@ -22,7 +23,7 @@ export class OrmHelper {
             database: String(config.get("database.database")),
             synchronize: true,
             logging: true,
-            entities: [User, UserActivity, UserRefreshToken],
+            entities: [User, UserRole, UserActivity, UserRefreshToken],
             subscribers: [],
             migrations: [],
         })

src/langs/json/en.json

@@ -6,8 +6,9 @@
     "success_view": "Data has been successfully fetched",
     "success": "Operation has been success",
     "success_valid_otp": "Operation has been success, valid for 1 minutes",
+    "success_logout": "Logout has been success",
     "failed": "Operation has been failed",
-    "failed_access": "You're not allowed to acces",
+    "failed_access": "You're not allowed to access",
     "failed_access_otp": "Please provide valid OTP code",
     "failed_expired_otp": "Your OTP has been expired, Please provide valid OTP code",
     "failed_access_pin": "Please provide valid PIN code",
@@ -28,5 +29,6 @@
     "failed_limit_link_code": "Please send verification link 1 minutes later",
     "failed_expired_token": "Token has been expired",
     "failed_token": "Your session has been expired, please re-login",
-    "failed_add_point": "Add point failed, please try again later"
+    "failed_add_point": "Add point failed, please try again later",
+    "failed_logout": "Logout has been failed, please try again later"
 }

src/langs/lang.ts

@@ -10,6 +10,7 @@ interface LanguageValue {
     success_view?: string;
     success?: string;
     success_valid_otp?: string;
+    success_logout?: string;
 
     failed?: string;
     failed_access?: string;
@@ -32,6 +33,7 @@ interface LanguageValue {
     failed_expired_token?: string;
     failed_token?: string;
     failed_add_point?: string;
+    failed_logout?: string;
 
     //login
     success_login?: string;

src/routes/private.ts

@@ -1,11 +1,36 @@
 import express from 'express';
 import { Language } from '../langs/lang';
+import { UserController } from '../controllers/user';
+import { UserActivityController } from '../controllers/user_activity';
+import { UserRefreshTokenController } from '../controllers/user_refresh_token';
+import JwtHelper from '../helpers/jwt';
+import { UserRoleController } from '../controllers/user_roles';
 
 export class RoutePrivate {
     static setup(app: express.Application) {
 
-        // app.use(Language.apply)
+        app.use(Language.apply)
 
+        JwtHelper.secure(app);
 
+        app.get('/api/user/list', UserController.list)
+        app.post('/api/user/create', UserController.create)
+        app.put('/api/user/update/:id', UserController.update)
+        app.put('/api/user/update_profile/:id', UserController.updateProfile)
+        app.put('/api/user/update_password/:id', UserController.updatePassword)
+        app.delete('/api/user/delete/:id', UserController.delete)
+        app.put('/api/user/restore/:id', UserController.restore)
+
+        app.get('/api/user_role/list', UserRoleController.list)
+        app.post('/api/user_role/create', UserRoleController.create)
+        app.put('/api/user_role/update/:id', UserRoleController.update)
+        app.delete('/api/user_role/delete/:id', UserRoleController.delete)
+        app.put('/api/user_role/restore/:id', UserRoleController.restore)
+
+        app.get('/api/user_activity', UserActivityController.list)
+        app.post('/api/user_activity/create', UserActivityController.create)
+
+        app.get('/api/refresh_token/list', UserRefreshTokenController.list)
+        app.put('/api/refresh_token/force_logout/:refresh_token', UserRefreshTokenController.forceLogout)
     }
 }

src/routes/public.ts

@@ -1,16 +1,13 @@
 import express from 'express';
-import { UserController } from '../controllers/user/user';
+
-import { Language } from '../langs/lang';
+import { AuthController } from '../controllers/auth';
 
 export class RoutePublic {
     static setup(app: express.Application) {
 
-        app.use(Language.apply)
+        app.post('/api/login', AuthController.login)
+        app.put('/api/logout/:refresh_token', AuthController.logout)
+        app.put('/api/renew_token/:refresh_token', AuthController.renewToken)
 
-        app.get('/api/user/list', UserController.list)
-        app.post('/api/user/create', UserController.create)
-        app.put('/api/user/update/:id', UserController.update)
-        app.delete('/api/user/delete/:id', UserController.delete)
-        app.put('/api/user/restore/:id', UserController.restore)
     }
 }

src/server.ts

@@ -9,6 +9,7 @@ import { RoutePrivate } from './routes/private';
 import { RoutePublic } from './routes/public';
 import { Language } from './langs/lang';
 import { SwaggerHelper } from './helpers/express/swagger';
+import { TrustProxyHelper } from './helpers/express/trust_proxy';
 
 const app = express();
 
@@ -19,8 +20,9 @@ JsonHelper.setup(app);
 UrlencodedHelper.setup(app);
 OrmHelper.setup();
 Language.setup();
-RoutePrivate.setup(app);
+TrustProxyHelper.setup(app);
-RoutePublic.setup(app);
 SwaggerHelper.setup(app);
+RoutePublic.setup(app);
+RoutePrivate.setup(app);
 
 export { app };

src/swagger/builder.js

@@ -1,4 +1,4 @@
-const swaggerAutogen = require('swagger-autogen')();
+const swaggerAutogen = require('swagger-autogen')({ openapi: '3.0.0' });
 const config = require('config');
 
 const doc = {
@@ -8,6 +8,14 @@ const doc = {
         version: config.get('app.version')
     },
     host: config.get('server.host_swagger') + ':' + config.get('server.port'),
+    components: {
+        securitySchemes: {
+            bearerAuth: {
+                type: 'http',
+                scheme: 'bearer'
+            }
+        }
+    }
 };
 
 const outputFile = './swagger.json';

src/swagger/swagger.json

@@ -1,48 +1,61 @@
 {
-  "swagger": "2.0",
+  "openapi": "3.0.0",
   "info": {
     "title": "Service Name",
     "description": "Description of service",
     "version": "1.0.0"
   },
-  "host": "127.0.0.1:4001",
+  "servers": [
-  "basePath": "/",
+    {
-  "schemes": [
+      "url": "http://127.0.0.1:4001/"
-    "http"
+    }
   ],
   "paths": {
     "/api/user/list": {
       "get": {
+        "tags": [
+          "User"
+        ],
         "description": "",
         "parameters": [
           {
             "name": "filter",
             "in": "query",
+            "schema": {
               "type": "string"
+            }
           },
           {
             "name": "limit",
             "in": "query",
             "required": true,
+            "schema": {
               "type": "number"
+            }
           },
           {
             "name": "page",
             "in": "query",
             "required": true,
+            "schema": {
               "type": "number"
+            }
           },
           {
             "name": "with_deleted",
             "in": "query",
             "required": true,
+            "schema": {
               "type": "boolean"
+            }
           },
           {
             "name": "order_field",
             "in": "query",
             "required": true,
+            "schema": {
               "type": "string"
+            }
           },
           {
             "name": "order_direction",
@@ -52,18 +65,28 @@
               "ASC",
               "DESC"
             ],
+            "schema": {
               "type": "string"
             }
+          }
         ],
         "responses": {
           "default": {
             "description": ""
           }
+        },
+        "security": [
+          {
+            "bearerAuth": []
           }
+        ]
       }
     },
     "/api/user/create": {
       "post": {
+        "tags": [
+          "User"
+        ],
         "description": "",
         "parameters": [
           {
@@ -94,9 +117,9 @@
                   "type": "string",
                   "example": "Administrator"
                 },
-                "role": {
+                "id_role": {
                   "type": "string",
-                  "example": "ADMINISTRATOR"
+                  "example": "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8"
                 },
                 "status": {
                   "type": "string",
@@ -110,79 +133,260 @@
           "default": {
             "description": ""
           }
+        },
+        "security": [
+          {
+            "bearerAuth": []
           }
+        ]
       }
     },
     "/api/user/update/{id}": {
       "put": {
+        "tags": [
+          "User"
+        ],
         "description": "",
         "parameters": [
           {
             "name": "id",
             "in": "path",
             "required": true,
-            "type": "uuid",
-            "description": "User ID."
-          },
-          {
-            "name": "body",
-            "in": "body",
-            "description": "User data",
-            "required": true,
             "schema": {
-              "type": "object",
+              "type": "string"
-              "properties": {
-                "email": {
-                  "type": "string",
-                  "example": "admin@gmail.com"
             },
-                "username": {
+            "description": "User ID."
-                  "type": "string",
-                  "example": "admin"
-                },
-                "password": {
-                  "type": "string",
-                  "example": "123456"
-                },
-                "retype_password": {
-                  "type": "string",
-                  "example": "123456"
-                },
-                "name": {
-                  "type": "string",
-                  "example": "Administrator"
-                },
-                "role": {
-                  "type": "string",
-                  "example": "ADMINISTRATOR"
-                },
-                "status": {
-                  "type": "string",
-                  "example": "Y"
-                }
-              }
-            }
           }
         ],
         "responses": {
           "default": {
             "description": ""
           }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "id": {
+                    "example": "any"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/user/update_profile/{id}": {
+      "put": {
+        "tags": [
+          "User"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "User ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "id": {
+                    "example": "any"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/user/update_password/{id}": {
+      "put": {
+        "tags": [
+          "User"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "User ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "id": {
+                    "example": "any"
+                  }
+                }
+              }
+            }
+          }
         }
       }
     },
     "/api/user/delete/{id}": {
       "delete": {
+        "tags": [
+          "User"
+        ],
         "description": "",
         "parameters": [
           {
             "name": "id",
             "in": "path",
             "required": true,
-            "type": "uuid",
+            "schema": {
+              "type": "string"
+            },
             "description": "User ID."
           }
         ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ]
+      }
+    },
+    "/api/user/restore/{id}": {
+      "put": {
+        "tags": [
+          "User"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "User ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ]
+      }
+    },
+    "/api/user_role/list": {
+      "get": {
+        "tags": [
+          "User Roles"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "filter",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "page",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "with_deleted",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "name": "order_field",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "order_direction",
+            "in": "query",
+            "required": true,
+            "enum": [
+              "ASC",
+              "DESC"
+            ],
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
         "responses": {
           "default": {
             "description": ""
@@ -190,16 +394,410 @@
         }
       }
     },
-    "/api/user/restore/{id}": {
+    "/api/user_role/create": {
+      "post": {
+        "tags": [
+          "User Roles"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "description": "User role data",
+            "required": true,
+            "schema": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "example": "Administrator"
+                },
+                "roles": {
+                  "type": "array",
+                  "example": [
+                    "dashboard"
+                  ],
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "status": {
+                  "type": "string",
+                  "example": "Y"
+                }
+              }
+            }
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/user_role/update/{id}": {
       "put": {
+        "tags": [
+          "User Roles"
+        ],
         "description": "",
         "parameters": [
           {
             "name": "id",
             "in": "path",
             "required": true,
-            "type": "uuid",
+            "schema": {
-            "description": "User ID."
+              "type": "string"
+            },
+            "description": "User role ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        },
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "id": {
+                    "example": "any"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/user_role/delete/{id}": {
+      "delete": {
+        "tags": [
+          "User Roles"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "User role ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/user_role/restore/{id}": {
+      "put": {
+        "tags": [
+          "User Roles"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "User role ID."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/user_activity": {
+      "get": {
+        "tags": [
+          "User Activity"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "filter",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "page",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "with_deleted",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "name": "order_field",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "order_direction",
+            "in": "query",
+            "required": true,
+            "enum": [
+              "ASC",
+              "DESC"
+            ],
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/user_activity/create": {
+      "post": {
+        "tags": [
+          "User Activity"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "description": "User Activity data",
+            "required": true,
+            "schema": {
+              "type": "object",
+              "properties": {
+                "id_user": {
+                  "type": "string",
+                  "example": "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8"
+                },
+                "refresh_token": {
+                  "type": "string",
+                  "example": "1a1221b6-78a0-4b3b-bf5c-fa0af5f69be8"
+                },
+                "module": {
+                  "type": "string",
+                  "example": "dashboard"
+                },
+                "description": {
+                  "type": "string",
+                  "example": "Main Dashboard"
+                },
+                "action": {
+                  "type": "string",
+                  "example": "V"
+                },
+                "url": {
+                  "type": "string",
+                  "example": "https://bri-dev.shiblysolution.id/"
+                },
+                "data_body": {
+                  "type": "string",
+                  "example": "{'from':'2024-11-01','to':'2024-11-26'}"
+                }
+              }
+            }
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/refresh_token/list": {
+      "get": {
+        "tags": [
+          "User Refresh Token"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "filter",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "limit",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "page",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "number"
+            }
+          },
+          {
+            "name": "order_field",
+            "in": "query",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "order_direction",
+            "in": "query",
+            "required": true,
+            "enum": [
+              "ASC",
+              "DESC"
+            ],
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/refresh_token/force_logout/{refresh_token}": {
+      "put": {
+        "tags": [
+          "User Refresh Token"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "refresh_token",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Refresh Token."
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/login": {
+      "post": {
+        "tags": [
+          "Auth"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "description": "Login data",
+            "required": true,
+            "schema": {
+              "type": "object",
+              "properties": {
+                "username": {
+                  "type": "string",
+                  "example": "admin"
+                },
+                "password": {
+                  "type": "string",
+                  "example": "123456"
+                }
+              }
+            }
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/logout/{refresh_token}": {
+      "put": {
+        "tags": [
+          "Auth"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "refresh_token",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Refresh Token"
+          }
+        ],
+        "responses": {
+          "default": {
+            "description": ""
+          }
+        }
+      }
+    },
+    "/api/renew_token/{refresh_token}": {
+      "put": {
+        "tags": [
+          "Auth"
+        ],
+        "description": "",
+        "parameters": [
+          {
+            "name": "refresh_token",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "Refresh Token"
           }
         ],
         "responses": {
@@ -209,5 +807,13 @@
         }
       }
     }
+  },
+  "components": {
+    "securitySchemes": {
+      "bearerAuth": {
+        "type": "http",
+        "scheme": "bearer"
+      }
+    }
   }
 }

src/types/action.ts

@@ -1,7 +1,7 @@
 export enum ActivityType {
     "Create" = "C",
-    "Read" = "R",
+    "View" = "V",
     "Update" = "U",
     "Delete" = "D",
-    "Restore" = "T",
+    "restore" = "T",
 };

src/types/role.ts

@@ -1 +1,23 @@
-export type Role = 'ADMINISTRATOR' | 'HR' | 'STAFF';
+export enum RoleList {
+    "Dashboard" = "dashboard",
+    "Kinerja UKLN" = "ukln",
+    "Dana Pihak Ketiga" = "dpk",
+    "Posisi Outstanding Pinjaman" = "outstanding_loan",
+    "Presentasi NPL" = "npl",
+    "PPAP Amount NPL" = "ppap_amount",
+    "Report Regulator Bulanan" = "regulator_bulanan",
+    "Report Regulator Triwulan" = "regulator_triwulan",
+    "Report Regulator Publikasi" = "regulator_publikasi",
+    "Perhitungan Simulasi Perpajakan Per Bulan" = "pajak_per_bulan",
+    "Perhitungan Simulasi Perpajakan Per Tahun" = "pajak_per_tahun",
+    "Data Nasabah Potensial" = "nasabah_potensial",
+    "Master Data User" = "master_user",
+    "Master Data Product" = "master_product",
+    "Master Data Tier" = "master_tier",
+    "Master Klasifikasi Ekonomi" = "master_klasifikasi_ekonomi",
+    "Master District" = "master_district",
+    "Master Munisipu" = "master_munisipu",
+    "Master Administrativu" = "master_administrativu",
+    "Master Suco" = "master_suco",
+    "Master Aldeia" = "master_aldeia",
+}