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

update

Browse Source
This commit is contained in:
Narul Hidayah
2026-01-02 23:26:20 +07:00
parent a578dc5c66 f562ccf38b
commit c150725e3f
7 changed files with 590 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -7,4 +7,5 @@ dist/
temp/
package-lock.json
src/swagger/swagger.json
swagger.json
swagger.json
config/ferro.json

55
src/controllers/auth.ts
View File

@ -46,11 +46,19 @@ export class AuthController {
const userRepository = OrmHelper.DB.getRepository(User)
const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken)
<<<<<<< HEAD
const user = await userRepository.findOne({
relations: ["roles", "roles.application", "employee"],
select: ["id", "email", "name", "password", "username", "roles"],
where: { username: param.username },
})
=======
const user = await userRepository.findOne({
relations: ["roles", "roles.application"],
select: ["id", "email", "name", "password", "username", "roles"],
where: { username: param.username },
})
>>>>>>> f562ccf38baffaa1cb6caf8a196127fe2512c7e4
if (user != null && user.roles != null && user.roles.length > 0 && user.checkIfPasswordMatch(param.password)) {
const { browser, device, os } = UAParser(req.get("User-Agent"))
@ -85,21 +93,22 @@ export class AuthController {
return ReturnHelper.errorResponse(res, 403, 403, Language.lang.failed_access + ", you don't have any roles in this application")
} else {
// const userRole = await userRoleRepository.findOneBy({ id: role_id })
var hrms = {
uuid: null,
idx: null,
employee_id: null,
employeename: null,
title: null,
department_id: null,
departement_uuid: null,
department_name: null,
level_id: null,
level_name: null,
}
var hrms = {
uuid: null,
idx: null,
employee_id: null,
employeename: null,
title: null,
department_id: null,
departement_uuid: null,
department_name: null,
level_id: null,
level_name: null,
}
var privateKey = fs.readFileSync("src/helpers/key/private.key")
var privateKey = fs.readFileSync("src/helpers/key/private.key")
<<<<<<< HEAD
var token = jwt.sign(
{
exp: Math.floor(Date.now() / 1000) + Number(config.get("auth.access_token_lifetime")),
@ -111,11 +120,23 @@ export class AuthController {
roles: roles.roles,
employee_id: user.employee?.id || null,
hrms: hrms,
=======
var token = jwt.sign(
{
exp: Math.floor(Date.now() / 1000) + Number(config.get("auth.access_token_lifetime")),
data: {
id: user.id,
username: user.username,
name: user.name,
id_role: role_id,
roles: roles.roles,
hrms: hrms,
},
>>>>>>> f562ccf38baffaa1cb6caf8a196127fe2512c7e4
},
},
privateKey,
{ algorithm: "RS256" }
)
privateKey,
{ algorithm: "RS256" }
)
delete user.password

21
src/controllers/user.ts
View File

@ -1,6 +1,10 @@
import axios from "axios"
import config from "config"
<<<<<<< HEAD
import { Paging, User, UserRefreshToken, UserRole, HrmsEmployee } from "entity"
=======
import { HrmsEmployee, Paging, User, UserRefreshToken, UserRole } from "entity"
>>>>>>> f562ccf38baffaa1cb6caf8a196127fe2512c7e4
import exceljs from "exceljs"
import { NextFunction, Response } from "express"
import { Request } from "express-jwt"
@ -247,7 +251,7 @@ export class UserController {
password: Joi.string().pattern(new RegExp("^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$")).min(8).required().label("Password"),
retype_password: Joi.ref("password"),
name: Joi.string().max(64).required().label("Name"),
employee_id: Joi.string().max(64).optional().allow("").label("Employee ID"),
employee_id: Joi.string().uuid().optional().allow("").label("Employee ID"),
status: Joi.string().required().label("Status"),
})
@ -260,9 +264,8 @@ export class UserController {
data.email = param.email
data.status = param.status
if (param.employee_id && param.employee_id != "") {
const employee = await OrmHelper.DB.manager.getRepository(HrmsEmployee).findOneByOrFail({ id: param.employee_id })
data.employee = employee
if (param.employee && param.employee.id! + "") {
data.employee = param.employee
}
data.hashPassword()
@ -572,7 +575,7 @@ export class UserController {
password: Joi.string().allow("").optional().label("Password"),
retype_password: Joi.ref("password"),
name: Joi.string().max(64).required().label("Name"),
employee_id: Joi.string().max(64).optional().allow("").label("Employee ID"),
employee_id: Joi.string().uuid().optional().allow("").label("Employee ID"),
status: Joi.string().required().label("Status"),
})
@ -586,15 +589,13 @@ export class UserController {
if (data != null) {
data.name = param.name
data.employee = param.employee
data.username = param.username
data.email = param.email
data.status = param.status
if (param.employee_id && param.employee_id != "") {
const employee = await OrmHelper.DB.manager.getRepository(HrmsEmployee).findOneByOrFail({ id: param.employee_id })
data.employee = employee
} else {
data.employee = null
if (param.employee && param.employee.id != "") {
data.employee = param.employee
}
if (param.password) {

378
src/controllers/user_activity.ts
View File

@ -1,27 +1,27 @@
import { Response, NextFunction } from "express";
import { Request } from "express-jwt";
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 { ActivityTypeReverse, Application, Paging, User } from "entity";
import CommonHelper from "../helpers/common";
import { ActivityType } from "entity";
import * as fastcsv from 'fast-csv';
import dayjs from "dayjs";
import { UserActivity } from "entity";
import exceljs from "exceljs";
import { Response, NextFunction } from "express"
import { Request } from "express-jwt"
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 { ActivityTypeReverse, Application, Paging, User } from "entity"
import CommonHelper from "../helpers/common"
import { ActivityType } from "entity"
import * as fastcsv from "fast-csv"
import dayjs from "dayjs"
import { UserActivity } from "entity"
import exceljs from "exceljs"
const log: Logger<ILogObj> = new Logger({ name: '[UserActivityController]', type: 'pretty' });
const log: Logger<ILogObj> = new Logger({ name: "[UserActivityController]", type: "pretty" })
interface PagingActivity extends Paging {
all_user: boolean
all_user: boolean
}
export class UserActivityController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Activity']
#swagger.parameters['filter'] = {
description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter like %module% or like %description%</li><li>Advance format using field existing {action:\'C\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
@ -67,68 +67,59 @@ export class UserActivityController {
}
*/
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'),
all_user: Joi.bool().optional().allow('').label('All User'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
token: Joi.string().required().label('Token'),
});
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"),
all_user: Joi.bool().optional().allow("").label("All User"),
order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().optional().label("Token"),
})
const param: PagingActivity = await schema.validateAsync(req.query);
const param: PagingActivity = await schema.validateAsync(req.query)
const userRepository = OrmHelper.DB.getRepository(UserActivity);
const userRepository = OrmHelper.DB.getRepository(UserActivity)
const offset = (param.page - 1) * param.limit
const offset = (param.page - 1) * param.limit
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ['u.username', 'module', 'description'],
additional_where: !param.all_user ? 'id_user = :id_user' : ''
});
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ["u.username", "module", "description"],
additional_where: !param.all_user ? "id_user = :id_user" : "",
})
if (!param.all_user) {
whereVal['id_user'] = req.auth.data.id;
}
if (!param.all_user) {
whereVal["id_user"] = req.auth.data.id
}
const res_count = userRepository.createQueryBuilder('user_activity')
.leftJoinAndSelect("user_activity.application", "application")
.leftJoinAndSelect("user_activity.user", "user")
.where(whereAttr, whereVal);
const res_list = userRepository.createQueryBuilder('user_activity')
.leftJoinAndSelect("user_activity.application", "application")
.leftJoinAndSelect("user_activity.user", "user")
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit);
const res_count = userRepository.createQueryBuilder("user_activity").leftJoinAndSelect("user_activity.application", "application").leftJoinAndSelect("user_activity.user", "user").where(whereAttr, whereVal)
const res_list = userRepository.createQueryBuilder("user_activity").leftJoinAndSelect("user_activity.application", "application").leftJoinAndSelect("user_activity.user", "user").where(whereAttr, whereVal).orderBy(param.order_field, param.order_direction).offset(offset).limit(param.limit)
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
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);
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.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);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async export(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
/*
static async export(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
/*
#swagger.tags = ['User Activity']
#swagger.parameters['filter'] = {
description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter like %module% or like %description%</li><li>Advance format using field existing {action:\'C\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
@ -163,118 +154,112 @@ export class UserActivityController {
}
*/
try {
const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'),
all_user: Joi.bool().required().label('All User'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
token: Joi.string().required().label('Token'),
});
try {
const schema = Joi.object().keys({
filter: Joi.string().allow("").optional().label("Filter"),
all_user: Joi.bool().required().label("All User"),
order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().optional().label("Token"),
})
const param: PagingActivity = await schema.validateAsync(req.query);
const param: PagingActivity = await schema.validateAsync(req.query)
const repo = OrmHelper.DB.getRepository(UserActivity);
const repo = OrmHelper.DB.getRepository(UserActivity)
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ['module', 'description'],
additional_where: !param.all_user ? 'id_user = :id_user' : ''
});
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ["module", "description"],
additional_where: !param.all_user ? "id_user = :id_user" : "",
})
if (!param.all_user) {
whereVal['id_user'] = req.auth.data.id;
}
if (!param.all_user) {
whereVal["id_user"] = req.auth.data.id
}
const filename = "user_activity.xlsx";
res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
res.setHeader('Content-Disposition', 'attachment; filename=' + filename);
const filename = "user_activity.xlsx"
res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
res.setHeader("Content-Disposition", "attachment; filename=" + filename)
const workbook = new exceljs.stream.xlsx.WorkbookWriter({ stream: res });
const sheet = workbook.addWorksheet('Data');
const workbook = new exceljs.stream.xlsx.WorkbookWriter({ stream: res })
const sheet = workbook.addWorksheet("Data")
sheet.columns = [
{ header: "Module", key: "module", width: 15 },
{ header: "Description", key: "description", width: 25 },
{ header: "Action", key: "action", width: 10 },
{ header: "Url", key: "url", width: 25 },
{ header: "Created At", key: "created_at", width: 15 },
{ header: "By", key: "by", width: 20 }
];
sheet.columns = [
{ header: "Module", key: "module", width: 15 },
{ header: "Description", key: "description", width: 25 },
{ header: "Action", key: "action", width: 10 },
{ header: "Url", key: "url", width: 25 },
{ header: "Created At", key: "created_at", width: 15 },
{ header: "By", key: "by", width: 20 },
]
const limit = 50;
const limit = 50
const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit
const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit
// const data = await repo.createQueryBuilder()
// .where(whereAttr, whereVal)
// .select([
// 'module',
// 'description',
// 'action',
// 'url',
// 'created_at'])
// .addSelect('(SELECT u.username FROM users u WHERE u.id = id_user)', 'username')
// .orderBy(param.order_field, param.order_direction)
// .offset(offset)
// .limit(limit).getRawMany();
// const data = await repo.createQueryBuilder()
// .where(whereAttr, whereVal)
// .select([
// 'module',
// 'description',
// 'action',
// 'url',
// 'created_at'])
// .addSelect('(SELECT u.username FROM users u WHERE u.id = id_user)', 'username')
// .orderBy(param.order_field, param.order_direction)
// .offset(offset)
// .limit(limit).getRawMany();
const data = await repo.createQueryBuilder('user_activity')
.leftJoinAndSelect("user_activity.application", "application")
.leftJoinAndSelect("user_activity.user", "user")
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit).getMany();
const data = await repo.createQueryBuilder("user_activity").leftJoinAndSelect("user_activity.application", "application").leftJoinAndSelect("user_activity.user", "user").where(whereAttr, whereVal).orderBy(param.order_field, param.order_direction).offset(offset).limit(param.limit).getMany()
if (CommonHelper.countObject(data) === 0) {
sheet.commit();
workbook.commit();
} else {
interface ds {
module: string,
description: string
action: string
url: any
created_at: Date
by: string
}
if (CommonHelper.countObject(data) === 0) {
sheet.commit()
workbook.commit()
} else {
interface ds {
module: string
description: string
action: string
url: any
created_at: Date
by: string
}
data.forEach((item: UserActivity) => {
const di: ds = {
module: item.module,
description: item.description,
action: ActivityTypeReverse[item.action],
created_at: item.created_at,
by: item.user.username,
url: item.url
}
data.forEach((item: UserActivity) => {
const di: ds = {
module: item.module,
description: item.description,
action: ActivityTypeReverse[item.action],
created_at: item.created_at,
by: item.user.username,
url: item.url,
}
sheet.addRow(di).commit()
});
sheet.addRow(di).commit()
})
if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1);
} else {
sheet.commit();
workbook.commit();
}
}
};
if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1)
} else {
sheet.commit()
workbook.commit()
}
}
}
fetchAndWrite(1);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
fetchAndWrite(1)
} catch (e: unknown) {
log.error(e)
const err = e as Error
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Activity']
#swagger.security = [{
"bearerAuth": []
@ -293,41 +278,44 @@ export class UserActivityController {
}
*/
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'),
application: Joi.string().required().label('Application'),
});
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"),
application: Joi.string().required().label("Application"),
})
const param: UserActivity & { application: string, id_user: string } = await schema.validateAsync(req.body);
const param: UserActivity & { application: string; id_user: string } = await schema.validateAsync(req.body)
const repo_app = OrmHelper.DB.getRepository(Application);
const repo_user = OrmHelper.DB.getRepository(User);
const repo_app = OrmHelper.DB.getRepository(Application)
const repo_user = OrmHelper.DB.getRepository(User)
const data = new UserActivity()
data.user = await repo_user.findOneBy({ id: 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
data.application = await repo_app.findOneBy({ id: param.application });
const data = new UserActivity()
data.user = await repo_user.findOneBy({ id: 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
data.application = await repo_app.findOneBy({ id: param.application })
await OrmHelper.DB.manager.save(data);
await OrmHelper.DB.manager.save(data)
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, {});
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, {})
} catch (e: unknown) {
log.error(e)
const err = e as Error
return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
}
}
}
return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message)
}
}
}

145
src/controllers/user_refresh_token.ts
View File

@ -1,19 +1,19 @@
import { Response, NextFunction, Application } from "express";
import { Request } from "express-jwt";
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 "entity";
import CommonHelper from "../helpers/common";
import { UserRefreshToken } from "entity";
import { Response, NextFunction, Application } from "express"
import { Request } from "express-jwt"
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 "entity"
import CommonHelper from "../helpers/common"
import { UserRefreshToken } from "entity"
const log: Logger<ILogObj> = new Logger({ name: '[UserRefreshTokenController]', type: 'pretty' });
const log: Logger<ILogObj> = new Logger({ name: "[UserRefreshTokenController]", type: "pretty" })
export class UserRefreshTokenController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Refresh Token']
#swagger.parameters['filter'] = {
description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter like %name%</li><li>Advance format using field existing {name:\'admin\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
@ -49,60 +49,55 @@ export class UserRefreshTokenController {
}
*/
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'),
token: Joi.string().required().label('Token'),
});
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"),
token: Joi.string().optional().label("Token"),
})
const param: Paging = await schema.validateAsync(req.query);
const param: Paging = await schema.validateAsync(req.query)
const repo = OrmHelper.DB.getRepository(UserRefreshToken);
const repo = OrmHelper.DB.getRepository(UserRefreshToken)
const offset = (param.page - 1) * param.limit
const offset = (param.page - 1) * param.limit
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ['device', 'platform'],
additional_where: 'id_user = :id_user'
});
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ["device", "platform"],
additional_where: "id_user = :id_user",
})
whereVal['id_user'] = req.auth.data.id;
whereVal["id_user"] = req.auth.data.id
const res_count = repo.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit);
const res_count = repo.createQueryBuilder().where(whereAttr, whereVal)
const res_list = repo.createQueryBuilder().where(whereAttr, whereVal).orderBy(param.order_field, param.order_direction).offset(offset).limit(param.limit)
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
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);
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.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);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async forceLogout(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async forceLogout(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Refresh Token']
#swagger.security = [{
"bearerAuth": []
@ -114,27 +109,27 @@ export class UserRefreshTokenController {
type: 'string'
}
*/
try {
const schema = Joi.object().keys({
refresh_token: Joi.string().uuid().required().label('Refresh Token')
});
try {
const schema = Joi.object().keys({
refresh_token: Joi.string().uuid().required().label("Refresh Token"),
})
const param: UserRefreshToken = await schema.validateAsync(req.params);
const param: UserRefreshToken = await schema.validateAsync(req.params)
const repo = OrmHelper.DB.getRepository(UserRefreshToken);
const repo = OrmHelper.DB.getRepository(UserRefreshToken)
const affected = (await repo.delete({ refresh_token: param.refresh_token })).affected;
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;
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);
}
}
}
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message)
}
}
}

454
src/controllers/user_roles.ts
View File

@ -1,21 +1,21 @@
import { Request, Response, NextFunction } 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 { Application, Paging, User, UserRole } from "entity";
import CommonHelper from "../helpers/common";
import { Status } from "entity";
import { RoleList } from "entity";
import * as fastcsv from 'fast-csv';
import dayjs from "dayjs";
import { Request, Response, NextFunction } 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 { Application, Paging, User, UserRole } from "entity"
import CommonHelper from "../helpers/common"
import { Status } from "entity"
import { RoleList } from "entity"
import * as fastcsv from "fast-csv"
import dayjs from "dayjs"
const log: Logger<ILogObj> = new Logger({ name: '[UserRoleController]', type: 'pretty' });
const log: Logger<ILogObj> = new Logger({ name: "[UserRoleController]", type: "pretty" })
export class UserRoleController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['filter'] = {
description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter like %name%</li><li>Advance format using field existing {status:\'Y\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
@ -56,58 +56,53 @@ export class UserRoleController {
}
*/
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'),
token: Joi.string().required().label('Token'),
});
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"),
token: Joi.string().optional().label("Token"),
})
const param: Paging = await schema.validateAsync(req.query);
const param: Paging = await schema.validateAsync(req.query)
const repo = OrmHelper.DB.getRepository(UserRole);
const repo = OrmHelper.DB.getRepository(UserRole)
const offset = (param.page - 1) * param.limit
const offset = (param.page - 1) * param.limit
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: ['name'],
col_any_like: ['name']
});
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: ["name"],
col_any_like: ["name"],
})
const res_count = repo.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit);
const res_count = repo.createQueryBuilder().where(whereAttr, whereVal)
const res_list = repo.createQueryBuilder().where(whereAttr, whereVal).orderBy(param.order_field, param.order_direction).offset(offset).limit(param.limit)
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
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);
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.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);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async export(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
/*
static async export(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['filter'] = {
description: 'Filter with 2 format : <ul><li>Simple format use text plaint will filter like %name%</li><li>Advance format using field existing {status:\'Y\', any:\'SAME AS PLAINT LOGIC\', etc...}</li></ul>',
@ -137,79 +132,70 @@ export class UserRoleController {
}
*/
try {
const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
token: Joi.string().required().label('Token'),
});
try {
const schema = Joi.object().keys({
filter: Joi.string().allow("").optional().label("Filter"),
order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().optional().label("Token"),
})
const param: Paging = await schema.validateAsync(req.query);
const param: Paging = await schema.validateAsync(req.query)
const repo = OrmHelper.DB.getRepository(UserRole);
const repo = OrmHelper.DB.getRepository(UserRole)
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ['name']
});
const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter,
col_any_eq: [],
col_any_like: ["name"],
})
const filename = "user_role.csv";
const filename = "user_role.csv"
res.setHeader('Content-Type', 'text/csv');
res.setHeader('Content-Disposition', 'attachment; filename=' + filename);
res.setHeader("Content-Type", "text/csv")
res.setHeader("Content-Disposition", "attachment; filename=" + filename)
const csvStream = fastcsv.format({
headers: true,
writeHeaders: true,
transform: (row: UserRole): any => ({
...row,
created_at: dayjs(row.created_at).format('DD-MM-YYYY HH:MM:ss'),
})
});
csvStream.pipe(res);
const csvStream = fastcsv.format({
headers: true,
writeHeaders: true,
transform: (row: UserRole): any => ({
...row,
created_at: dayjs(row.created_at).format("DD-MM-YYYY HH:MM:ss"),
}),
})
csvStream.pipe(res)
const limit = 50;
const limit = 50
const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit
const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit
const data = await repo.createQueryBuilder()
.where(whereAttr, whereVal)
.select([
'name',
'roles',
'status',
'created_at'])
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(limit).getRawMany();
const data = await repo.createQueryBuilder().where(whereAttr, whereVal).select(["name", "roles", "status", "created_at"]).orderBy(param.order_field, param.order_direction).offset(offset).limit(limit).getRawMany()
if (CommonHelper.countObject(data) === 0) {
csvStream.end();
} else {
data.forEach((item: any) => csvStream.write(item));
if (CommonHelper.countObject(data) === 0) {
csvStream.end()
} else {
data.forEach((item: any) => csvStream.write(item))
if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1);
} else {
csvStream.end();
}
}
};
if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1)
} else {
csvStream.end()
}
}
}
fetchAndWrite(1);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
fetchAndWrite(1)
} catch (e: unknown) {
log.error(e)
const err = e as Error
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async role(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async role(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['token'] = {
in: 'query',
@ -218,23 +204,23 @@ export class UserRoleController {
}
*/
try {
const current_page = 1;
const total_count_data = CommonHelper.countObject(RoleList);
const list_data = CommonHelper.objectFlip(RoleList);
const count_data = CommonHelper.countObject(RoleList);
try {
const current_page = 1
const total_count_data = CommonHelper.countObject(RoleList)
const list_data = CommonHelper.objectFlip(RoleList)
const count_data = CommonHelper.countObject(RoleList)
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.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);
}
}
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message)
}
}
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.security = [{
"bearerAuth": []
@ -252,37 +238,40 @@ export class UserRoleController {
}
*/
try {
const schema = Joi.object().keys({
name: Joi.string().max(64).required().label('Name'),
roles: Joi.array().required().label('Roles'),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
application: Joi.string().required().label('Application'),
});
try {
const schema = Joi.object().keys({
name: Joi.string().max(64).required().label("Name"),
roles: Joi.array().required().label("Roles"),
status: Joi.string()
.allow(...Object.values(Status))
.required()
.label("Status"),
application: Joi.string().required().label("Application"),
})
const param: UserRole & { application: string } = await schema.validateAsync(req.body);
const param: UserRole & { application: string } = await schema.validateAsync(req.body)
const repo_app = OrmHelper.DB.getRepository(Application);
const repo_app = OrmHelper.DB.getRepository(Application)
const data = new UserRole()
data.name = param.name
data.roles = param.roles
data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application });
const data = new UserRole()
data.name = param.name
data.roles = param.roles
data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application })
await OrmHelper.DB.manager.save(data);
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.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);
}
}
return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message)
}
}
static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.security = [{
"bearerAuth": []
@ -307,47 +296,50 @@ export class UserRoleController {
}
*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
name: Joi.string().max(64).required().label('Name'),
roles: Joi.array().required().label('Roles'),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
application: Joi.string().required().label('Application'),
});
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label("ID"),
name: Joi.string().max(64).required().label("Name"),
roles: Joi.array().required().label("Roles"),
status: Joi.string()
.allow(...Object.values(Status))
.required()
.label("Status"),
application: Joi.string().required().label("Application"),
})
req.body.id = req.params['id'];
req.body.id = req.params["id"]
const param: UserRole & { application: string } = await schema.validateAsync(req.body);
const param: UserRole & { application: string } = await schema.validateAsync(req.body)
const repo = OrmHelper.DB.getRepository(UserRole);
const repo = OrmHelper.DB.getRepository(UserRole)
const data = await repo.findOneBy({ id: param.id });
const data = await repo.findOneBy({ id: param.id })
if (data != null) {
const repo_app = OrmHelper.DB.getRepository(Application);
if (data != null) {
const repo_app = OrmHelper.DB.getRepository(Application)
data.name = param.name
data.roles = param.roles
data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application });
data.name = param.name
data.roles = param.roles
data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application })
await repo.save(data);
await repo.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.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);
}
}
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message)
}
}
static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.security = [{
"bearerAuth": []
@ -365,40 +357,40 @@ export class UserRoleController {
type: 'boolean'
}
*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
hard: Joi.bool().optional().allow('').label('Is hard delete?')
});
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label("ID"),
hard: Joi.bool().optional().allow("").label("Is hard delete?"),
})
const param: { id: string, hard: boolean } = await schema.validateAsync(req.params);
const param: { id: string; hard: boolean } = await schema.validateAsync(req.params)
const repo_role = OrmHelper.DB.getRepository(UserRole);
// const repo_user = OrmHelper.DB.getRepository(User);
const repo_role = OrmHelper.DB.getRepository(UserRole)
// const repo_user = OrmHelper.DB.getRepository(User);
// const check_used = await repo_user.findOneBy({ id_role: param.id })
// const check_used = await repo_user.findOneBy({ id_role: param.id })
// if (check_used == null) {
const affected = (!param.hard ? await repo_role.softDelete({ id: param.id }) : await repo_role.delete({ id: param.id })).affected;
// if (check_used == null) {
const affected = (!param.hard ? await repo_role.softDelete({ id: param.id }) : await repo_role.delete({ 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, "");
}
// } else {
// return ReturnHelper.errorResponse(res, 404, 402, Language.lang.failed_related, "");
// }
} catch (e: unknown) {
log.error(e);
const err = e as Error;
if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {})
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "")
}
// } else {
// return ReturnHelper.errorResponse(res, 404, 402, Language.lang.failed_related, "");
// }
} catch (e: unknown) {
log.error(e)
const err = e as Error
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message);
}
}
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message)
}
}
static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.security = [{
"bearerAuth": []
@ -410,27 +402,27 @@ export class UserRoleController {
type: 'string'
}
*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID')
});
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label("ID"),
})
const param: UserRole = await schema.validateAsync(req.params);
const param: UserRole = await schema.validateAsync(req.params)
const repo = OrmHelper.DB.getRepository(UserRole);
const repo = OrmHelper.DB.getRepository(UserRole)
const affected = (await repo.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, {});
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
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);
}
}
}
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_restore, err.message)
}
}
}

91
src/helpers/orm.ts
View File

@ -1,34 +1,69 @@
import config from 'config';
import { DataSource } from "typeorm";
import { Application, Menu, User, UserActivity, UserRefreshToken, UserRole, HrmsEmployee, Nationality, Aldeia, Suco, Administrativu, Munisipo, HrmsAirport, HrmsDepartment, HrmsPosition, HrmsShift } from "entity";
import { ILogObj, Logger } from 'tslog';
import config from "config"
import { DataSource } from "typeorm"
import {
Aldeia,
Suco,
Munisipo,
Administrativu,
Nationality,
Application, //
Menu,
User,
UserActivity,
UserRefreshToken,
UserRole,
HrmsAirport,
HrmsPosition,
HrmsEmployee,
HrmsDepartment,
HrmsShift,
} from "entity"
import { ILogObj, Logger } from "tslog"
export class OrmHelper {
static DB: DataSource = null
static DB: DataSource = null
static setup() {
const log: Logger<ILogObj> = new Logger({ name: '[OrmHelper]', type: 'pretty' });
static setup() {
const log: Logger<ILogObj> = new Logger({ name: "[OrmHelper]", type: "pretty" })
const engine: 'mysql' | 'postgres' = config.get("database.engine")
const engine: "mysql" | "postgres" = config.get("database.engine")
OrmHelper.DB = new DataSource({
type: engine,
host: config.get("database.host"),
port: Number(config.get("database.port")),
username: String(config.get("database.username")),
password: String(config.get("database.password")),
database: String(config.get("database.database")),
synchronize: true,
logging: config.get('database.logging'),
entities: [User, UserRole, UserActivity, UserRefreshToken, Menu, Application, HrmsEmployee, Nationality, Aldeia, Suco, Administrativu, Munisipo, HrmsAirport, HrmsDepartment, HrmsPosition, HrmsShift ],
subscribers: [],
migrations: [],
})
OrmHelper.DB = new DataSource({
type: engine,
host: config.get("database.host"),
port: Number(config.get("database.port")),
username: String(config.get("database.username")),
password: String(config.get("database.password")),
database: String(config.get("database.database")),
synchronize: true,
logging: config.get("database.logging"),
entities: [
Aldeia,
Suco,
Munisipo,
Administrativu,
Nationality,
User, //
UserRole,
UserActivity,
UserRefreshToken,
Menu,
Application,
Nationality,
HrmsDepartment, //
HrmsAirport,
HrmsPosition,
HrmsShift,
HrmsEmployee,
],
subscribers: [],
migrations: [],
})
OrmHelper.DB.initialize()
.then(() => {
// here you can start to work with your database
})
.catch((error: any) => log.error(error))
}
}
OrmHelper.DB.initialize()
.then(() => {
// here you can start to work with your database
})
.catch((error: any) => log.error(error))
}
}