TIMOR-TELECOM/service-user-revenue
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update user, auth, token, roles, done

Browse Source
This commit is contained in:
Abdul Rahman Reza
2024-11-26 23:58:38 +07:00
parent 6e71588f91
commit 9608e96401
27 changed files with 1842 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
config/default.json
View File

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

6
package.json
View File

@ -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",

196
src/controllers/auth.ts Normal file
View File

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

422
src/controllers/user.ts Normal file
View File

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

152
src/controllers/user_activity.ts Normal file
View File

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

127
src/controllers/user_refresh_token.ts Normal file
View File

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

112
src/controllers/user/user.ts → src/controllers/user_roles.ts
View File

@ -1,18 +1,20 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../../helpers/express/return";
import { OrmHelper } from "../../helpers/orm";
import { User } from "../../entity/users";
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 { Language } from "../langs/lang";
import { Paging } from "../types/paging";
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 ';
whereVal['filter'] = param.filter
whereAttr = 'name like :filter_like';
// 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'),
status: Joi.string().required().label('Status'),
roles: Joi.array().required().label('Roles'),
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.password = param.password
data.email = param.email
data.role = param.role
data.roles = param.roles
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'),
status: Joi.string().required().label('Status'),
roles: Joi.array().required().label('Roles'),
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.password = param.password
data.email = param.email
data.role = param.role
data.roles = param.roles
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, {});

0
src/entity/users_activity.ts → src/entity/user_activity.ts
View File

19
src/entity/users_refresh_token.ts → src/entity/user_refresh_token.ts
View File

@ -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;

6
src/entity/users.ts
View File

@ -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,
length: 30,
type: 'uuid'
})
role: Role;
id_role: string;
@Column({
nullable: false,

41
src/entity/users_roles.ts Normal file
View File

@ -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;
}

2
src/helpers/express/return.ts
View File

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

2
src/helpers/express/swagger.ts
View File

@ -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));

7
src/helpers/express/trust_proxy.ts Normal file
View File

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

38
src/helpers/jwt.ts Normal file
View File

@ -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();
});
}
}

28
src/helpers/key/private.key Normal file
View File

@ -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-----

9
src/helpers/key/public.key Normal file
View File

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

7
src/helpers/orm.ts
View File

@ -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 { UserRefreshToken } from '../entity/users_refresh_token';
import { UserActivity } from '../entity/user_activity';
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: [],
})

6
src/langs/json/en.json
View File

@ -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"
}

2
src/langs/lang.ts
View File

@ -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;

27
src/routes/private.ts
View File

@ -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)
}
}

13
src/routes/public.ts
View File

@ -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)
}
}

6
src/server.ts
View File

@ -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);
RoutePublic.setup(app);
TrustProxyHelper.setup(app);
SwaggerHelper.setup(app);
RoutePublic.setup(app);
RoutePrivate.setup(app);
export { app };

10
src/swagger/builder.js
View File

@ -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';

724
src/swagger/swagger.json
View File

@ -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",
"basePath": "/",
"schemes": [
"http"
"servers": [
{
"url": "http://127.0.0.1:4001/"
}
],
"paths": {
"/api/user/list": {
"get": {
"tags": [
"User"
],
"description": "",
"parameters": [
{
"name": "filter",
"in": "query",
"type": "string"
"schema": {
"type": "string"
}
},
{
"name": "limit",
"in": "query",
"required": true,
"type": "number"
"schema": {
"type": "number"
}
},
{
"name": "page",
"in": "query",
"required": true,
"type": "number"
"schema": {
"type": "number"
}
},
{
"name": "with_deleted",
"in": "query",
"required": true,
"type": "boolean"
"schema": {
"type": "boolean"
}
},
{
"name": "order_field",
"in": "query",
"required": true,
"type": "string"
"schema": {
"type": "string"
}
},
{
"name": "order_direction",
@ -52,18 +65,28 @@
"ASC",
"DESC"
],
"type": "string"
"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",
"properties": {
"email": {
"type": "string",
"example": "admin@gmail.com"
},
"username": {
"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"
}
}
}
"type": "string"
},
"description": "User ID."
}
],
"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",
"description": "User ID."
"schema": {
"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"
}
}
}
}

4
src/types/action.ts
View File

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

24
src/types/role.ts
View File

@ -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",
}