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

1
.gitignore vendored
View File

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

21
src/controllers/user.ts
View File

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

376
src/controllers/user_activity.ts
View File

@ -1,27 +1,27 @@
import { Response, NextFunction } from "express"; import { Response, NextFunction } from "express"
import { Request } from "express-jwt"; import { Request } from "express-jwt"
import { ReturnHelper } from "../helpers/express/return"; import { ReturnHelper } from "../helpers/express/return"
import { OrmHelper } from "../helpers/orm"; import { OrmHelper } from "../helpers/orm"
import Joi from "joi"; import Joi from "joi"
import { ILogObj, Logger } from "tslog"; import { ILogObj, Logger } from "tslog"
import { Language } from "../langs/lang"; import { Language } from "../langs/lang"
import { ActivityTypeReverse, Application, Paging, User } from "entity"; import { ActivityTypeReverse, Application, Paging, User } from "entity"
import CommonHelper from "../helpers/common"; import CommonHelper from "../helpers/common"
import { ActivityType } from "entity"; import { ActivityType } from "entity"
import * as fastcsv from 'fast-csv'; import * as fastcsv from "fast-csv"
import dayjs from "dayjs"; import dayjs from "dayjs"
import { UserActivity } from "entity"; import { UserActivity } from "entity"
import exceljs from "exceljs"; 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 { interface PagingActivity extends Paging {
all_user: boolean all_user: boolean
} }
export class UserActivityController { 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.tags = ['User Activity']
#swagger.parameters['filter'] = { #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>', 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 { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'), filter: Joi.string().allow("").optional().label("Filter"),
page: Joi.number().required().min(1).label('Page'), page: Joi.number().required().min(1).label("Page"),
limit: Joi.number().required().min(1).label('Limit'), limit: Joi.number().required().min(1).label("Limit"),
with_deleted: Joi.bool().required().label('With Deleted'), with_deleted: Joi.bool().required().label("With Deleted"),
all_user: Joi.bool().optional().allow('').label('All User'), all_user: Joi.bool().optional().allow("").label("All User"),
order_field: Joi.string().required().label('Order Field'), order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'), order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().required().label('Token'), 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({ const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter, filter: param.filter,
col_any_eq: [], col_any_eq: [],
col_any_like: ['u.username', 'module', 'description'], col_any_like: ["u.username", "module", "description"],
additional_where: !param.all_user ? 'id_user = :id_user' : '' additional_where: !param.all_user ? "id_user = :id_user" : "",
}); })
if (!param.all_user) { if (!param.all_user) {
whereVal['id_user'] = req.auth.data.id; whereVal["id_user"] = req.auth.data.id
} }
const res_count = userRepository.createQueryBuilder('user_activity') const res_count = userRepository.createQueryBuilder("user_activity").leftJoinAndSelect("user_activity.application", "application").leftJoinAndSelect("user_activity.user", "user").where(whereAttr, whereVal)
.leftJoinAndSelect("user_activity.application", "application") 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)
.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) { if (param.with_deleted) {
res_count.withDeleted(); res_count.withDeleted()
res_list.withDeleted(); res_list.withDeleted()
} }
const current_page = param.page; const current_page = param.page
const total_count_data = await res_count.getCount(); const total_count_data = await res_count.getCount()
const list_data = await res_list.getMany() const list_data = await res_list.getMany()
const count_data = CommonHelper.countObject(list_data); 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) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Activity']
#swagger.parameters['filter'] = { #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>', 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 { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'), filter: Joi.string().allow("").optional().label("Filter"),
all_user: Joi.bool().required().label('All User'), all_user: Joi.bool().required().label("All User"),
order_field: Joi.string().required().label('Order Field'), order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'), order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().required().label('Token'), 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({ const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter, filter: param.filter,
col_any_eq: [], col_any_eq: [],
col_any_like: ['module', 'description'], col_any_like: ["module", "description"],
additional_where: !param.all_user ? 'id_user = :id_user' : '' additional_where: !param.all_user ? "id_user = :id_user" : "",
}); })
if (!param.all_user) { if (!param.all_user) {
whereVal['id_user'] = req.auth.data.id; whereVal["id_user"] = req.auth.data.id
} }
const filename = "user_activity.xlsx"; const filename = "user_activity.xlsx"
res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
res.setHeader('Content-Disposition', 'attachment; filename=' + filename); res.setHeader("Content-Disposition", "attachment; filename=" + filename)
const workbook = new exceljs.stream.xlsx.WorkbookWriter({ stream: res }); const workbook = new exceljs.stream.xlsx.WorkbookWriter({ stream: res })
const sheet = workbook.addWorksheet('Data'); const sheet = workbook.addWorksheet("Data")
sheet.columns = [ sheet.columns = [
{ header: "Module", key: "module", width: 15 }, { header: "Module", key: "module", width: 15 },
{ header: "Description", key: "description", width: 25 }, { header: "Description", key: "description", width: 25 },
{ header: "Action", key: "action", width: 10 }, { header: "Action", key: "action", width: 10 },
{ header: "Url", key: "url", width: 25 }, { header: "Url", key: "url", width: 25 },
{ header: "Created At", key: "created_at", width: 15 }, { header: "Created At", key: "created_at", width: 15 },
{ header: "By", key: "by", width: 20 } { header: "By", key: "by", width: 20 },
]; ]
const limit = 50; const limit = 50
const fetchAndWrite = async (page: number) => { const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit const offset = (page - 1) * limit
// const data = await repo.createQueryBuilder() // const data = await repo.createQueryBuilder()
// .where(whereAttr, whereVal) // .where(whereAttr, whereVal)
// .select([ // .select([
// 'module', // 'module',
// 'description', // 'description',
// 'action', // 'action',
// 'url', // 'url',
// 'created_at']) // 'created_at'])
// .addSelect('(SELECT u.username FROM users u WHERE u.id = id_user)', 'username') // .addSelect('(SELECT u.username FROM users u WHERE u.id = id_user)', 'username')
// .orderBy(param.order_field, param.order_direction) // .orderBy(param.order_field, param.order_direction)
// .offset(offset) // .offset(offset)
// .limit(limit).getRawMany(); // .limit(limit).getRawMany();
const data = await repo.createQueryBuilder('user_activity') 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()
.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) { if (CommonHelper.countObject(data) === 0) {
sheet.commit(); sheet.commit()
workbook.commit(); workbook.commit()
} else { } else {
interface ds { interface ds {
module: string, module: string
description: string description: string
action: string action: string
url: any url: any
created_at: Date created_at: Date
by: string by: string
} }
data.forEach((item: UserActivity) => { data.forEach((item: UserActivity) => {
const di: ds = { const di: ds = {
module: item.module, module: item.module,
description: item.description, description: item.description,
action: ActivityTypeReverse[item.action], action: ActivityTypeReverse[item.action],
created_at: item.created_at, created_at: item.created_at,
by: item.user.username, by: item.user.username,
url: item.url url: item.url,
} }
sheet.addRow(di).commit() sheet.addRow(di).commit()
}); })
if (CommonHelper.countObject(data) == limit) { if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1); fetchAndWrite(page + 1)
} else { } else {
sheet.commit(); sheet.commit()
workbook.commit(); workbook.commit()
} }
} }
}; }
fetchAndWrite(1); fetchAndWrite(1)
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Activity']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -293,41 +278,44 @@ export class UserActivityController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
id_user: Joi.string().uuid().required().label('ID User'), id_user: Joi.string().uuid().required().label("ID User"),
refresh_token: Joi.string().uuid().required().label('Refresh Token'), refresh_token: Joi.string().uuid().required().label("Refresh Token"),
module: Joi.string().required().label('Module'), module: Joi.string().required().label("Module"),
description: Joi.string().required().label('Description'), description: Joi.string().required().label("Description"),
action: Joi.string().allow(...Object.values(ActivityType)).required().label('Action'), action: Joi.string()
url: Joi.string().optional().allow('').label('URL'), .allow(...Object.values(ActivityType))
data_body: Joi.string().optional().allow('').label('data_body'), .required()
application: Joi.string().required().label('Application'), .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_app = OrmHelper.DB.getRepository(Application)
const repo_user = OrmHelper.DB.getRepository(User); const repo_user = OrmHelper.DB.getRepository(User)
const data = new UserActivity() const data = new UserActivity()
data.user = await repo_user.findOneBy({ id: param.id_user }) data.user = await repo_user.findOneBy({ id: param.id_user })
data.refresh_token = param.refresh_token data.refresh_token = param.refresh_token
data.module = param.module data.module = param.module
data.description = param.description data.description = param.description
data.action = param.action data.action = param.action
data.url = param.url data.url = param.url
data.data_body = param.data_body data.data_body = param.data_body
data.application = await repo_app.findOneBy({ id: param.application }); 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, {}); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, {})
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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)
} }
} }
} }

143
src/controllers/user_refresh_token.ts
View File

@ -1,19 +1,19 @@
import { Response, NextFunction, Application } from "express"; import { Response, NextFunction, Application } from "express"
import { Request } from "express-jwt"; import { Request } from "express-jwt"
import { ReturnHelper } from "../helpers/express/return"; import { ReturnHelper } from "../helpers/express/return"
import { OrmHelper } from "../helpers/orm"; import { OrmHelper } from "../helpers/orm"
import Joi from "joi"; import Joi from "joi"
import { ILogObj, Logger } from "tslog"; import { ILogObj, Logger } from "tslog"
import { Language } from "../langs/lang"; import { Language } from "../langs/lang"
import { Paging } from "entity"; import { Paging } from "entity"
import CommonHelper from "../helpers/common"; import CommonHelper from "../helpers/common"
import { UserRefreshToken } from "entity"; 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 { 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.tags = ['User Refresh Token']
#swagger.parameters['filter'] = { #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>', 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 { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'), filter: Joi.string().allow("").optional().label("Filter"),
page: Joi.number().required().min(1).label('Page'), page: Joi.number().required().min(1).label("Page"),
limit: Joi.number().required().min(1).label('Limit'), limit: Joi.number().required().min(1).label("Limit"),
order_field: Joi.string().required().label('Order Field'), order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'), order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().required().label('Token'), 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({ const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter, filter: param.filter,
col_any_eq: [], col_any_eq: [],
col_any_like: ['device', 'platform'], col_any_like: ["device", "platform"],
additional_where: 'id_user = :id_user' 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() const res_count = repo.createQueryBuilder().where(whereAttr, whereVal)
.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_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit);
if (param.with_deleted) { if (param.with_deleted) {
res_count.withDeleted(); res_count.withDeleted()
res_list.withDeleted(); res_list.withDeleted()
} }
const current_page = param.page; const current_page = param.page
const total_count_data = await res_count.getCount(); const total_count_data = await res_count.getCount()
const list_data = await res_list.getMany(); const list_data = await res_list.getMany()
const count_data = CommonHelper.countObject(list_data); 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) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Refresh Token']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -114,27 +109,27 @@ export class UserRefreshTokenController {
type: 'string' type: 'string'
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
refresh_token: Joi.string().uuid().required().label('Refresh Token') 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) { if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {})
} else { } else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, ""); return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "")
} }
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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)
} }
} }
} }

452
src/controllers/user_roles.ts
View File

@ -1,21 +1,21 @@
import { Request, Response, NextFunction } from "express"; import { Request, Response, NextFunction } from "express"
import { ReturnHelper } from "../helpers/express/return"; import { ReturnHelper } from "../helpers/express/return"
import { OrmHelper } from "../helpers/orm"; import { OrmHelper } from "../helpers/orm"
import Joi from "joi"; import Joi from "joi"
import { ILogObj, Logger } from "tslog"; import { ILogObj, Logger } from "tslog"
import { Language } from "../langs/lang"; import { Language } from "../langs/lang"
import { Application, Paging, User, UserRole } from "entity"; import { Application, Paging, User, UserRole } from "entity"
import CommonHelper from "../helpers/common"; import CommonHelper from "../helpers/common"
import { Status } from "entity"; import { Status } from "entity"
import { RoleList } from "entity"; import { RoleList } from "entity"
import * as fastcsv from 'fast-csv'; import * as fastcsv from "fast-csv"
import dayjs from "dayjs"; 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 { 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.tags = ['User Roles']
#swagger.parameters['filter'] = { #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>', 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 { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'), filter: Joi.string().allow("").optional().label("Filter"),
page: Joi.number().required().min(1).label('Page'), page: Joi.number().required().min(1).label("Page"),
limit: Joi.number().required().min(1).label('Limit'), limit: Joi.number().required().min(1).label("Limit"),
with_deleted: Joi.bool().required().label('With Deleted'), with_deleted: Joi.bool().required().label("With Deleted"),
order_field: Joi.string().required().label('Order Field'), order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'), order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().required().label('Token'), 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({ const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter, filter: param.filter,
col_any_eq: ['name'], col_any_eq: ["name"],
col_any_like: ['name'] col_any_like: ["name"],
}); })
const res_count = repo.createQueryBuilder() const res_count = repo.createQueryBuilder().where(whereAttr, whereVal)
.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_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.offset(offset)
.limit(param.limit);
if (param.with_deleted) { if (param.with_deleted) {
res_count.withDeleted(); res_count.withDeleted()
res_list.withDeleted(); res_list.withDeleted()
} }
const current_page = param.page; const current_page = param.page
const total_count_data = await res_count.getCount(); const total_count_data = await res_count.getCount()
const list_data = await res_list.getMany(); const list_data = await res_list.getMany()
const count_data = CommonHelper.countObject(list_data); 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) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.parameters['filter'] = { #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>', 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 { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'), filter: Joi.string().allow("").optional().label("Filter"),
order_field: Joi.string().required().label('Order Field'), order_field: Joi.string().required().label("Order Field"),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'), order_direction: Joi.string().allow("asc", "desc").required().label("Order Direction"),
token: Joi.string().required().label('Token'), 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({ const { whereAttr, whereVal } = CommonHelper.handleFilter({
filter: param.filter, filter: param.filter,
col_any_eq: [], col_any_eq: [],
col_any_like: ['name'] col_any_like: ["name"],
}); })
const filename = "user_role.csv"; const filename = "user_role.csv"
res.setHeader('Content-Type', 'text/csv'); res.setHeader("Content-Type", "text/csv")
res.setHeader('Content-Disposition', 'attachment; filename=' + filename); res.setHeader("Content-Disposition", "attachment; filename=" + filename)
const csvStream = fastcsv.format({ const csvStream = fastcsv.format({
headers: true, headers: true,
writeHeaders: true, writeHeaders: true,
transform: (row: UserRole): any => ({ transform: (row: UserRole): any => ({
...row, ...row,
created_at: dayjs(row.created_at).format('DD-MM-YYYY HH:MM:ss'), created_at: dayjs(row.created_at).format("DD-MM-YYYY HH:MM:ss"),
}) }),
}); })
csvStream.pipe(res); csvStream.pipe(res)
const limit = 50; const limit = 50
const fetchAndWrite = async (page: number) => { const fetchAndWrite = async (page: number) => {
const offset = (page - 1) * limit const offset = (page - 1) * limit
const data = await repo.createQueryBuilder() 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()
.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) { if (CommonHelper.countObject(data) === 0) {
csvStream.end(); csvStream.end()
} else { } else {
data.forEach((item: any) => csvStream.write(item)); data.forEach((item: any) => csvStream.write(item))
if (CommonHelper.countObject(data) == limit) { if (CommonHelper.countObject(data) == limit) {
fetchAndWrite(page + 1); fetchAndWrite(page + 1)
} else { } else {
csvStream.end(); csvStream.end()
} }
} }
}; }
fetchAndWrite(1); fetchAndWrite(1)
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.parameters['token'] = { #swagger.parameters['token'] = {
in: 'query', in: 'query',
@ -218,23 +204,23 @@ export class UserRoleController {
} }
*/ */
try { try {
const current_page = 1; const current_page = 1
const total_count_data = CommonHelper.countObject(RoleList); const total_count_data = CommonHelper.countObject(RoleList)
const list_data = CommonHelper.objectFlip(RoleList); const list_data = CommonHelper.objectFlip(RoleList)
const count_data = CommonHelper.countObject(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); return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data)
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -252,37 +238,40 @@ export class UserRoleController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
name: Joi.string().max(64).required().label('Name'), name: Joi.string().max(64).required().label("Name"),
roles: Joi.array().required().label('Roles'), roles: Joi.array().required().label("Roles"),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'), status: Joi.string()
application: Joi.string().required().label('Application'), .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() const data = new UserRole()
data.name = param.name data.name = param.name
data.roles = param.roles data.roles = param.roles
data.status = param.status data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application }); 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); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data)
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -307,47 +296,50 @@ export class UserRoleController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'), id: Joi.string().uuid().required().label("ID"),
name: Joi.string().max(64).required().label('Name'), name: Joi.string().max(64).required().label("Name"),
roles: Joi.array().required().label('Roles'), roles: Joi.array().required().label("Roles"),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'), status: Joi.string()
application: Joi.string().required().label('Application'), .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) { if (data != null) {
const repo_app = OrmHelper.DB.getRepository(Application); const repo_app = OrmHelper.DB.getRepository(Application)
data.name = param.name data.name = param.name
data.roles = param.roles data.roles = param.roles
data.status = param.status data.status = param.status
data.application = await repo_app.findOneBy({ id: param.application }); 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); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data)
} else { } else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, ""); return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "")
} }
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -365,40 +357,40 @@ export class UserRoleController {
type: 'boolean' type: 'boolean'
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'), id: Joi.string().uuid().required().label("ID"),
hard: Joi.bool().optional().allow('').label('Is hard delete?') 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_role = OrmHelper.DB.getRepository(UserRole)
// const repo_user = OrmHelper.DB.getRepository(User); // 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) { // if (check_used == null) {
const affected = (!param.hard ? await repo_role.softDelete({ id: param.id }) : await repo_role.delete({ id: param.id })).affected; const affected = (!param.hard ? await repo_role.softDelete({ id: param.id }) : await repo_role.delete({ id: param.id })).affected
if (affected > 0) { if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {}); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {})
} else { } else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, ""); return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "")
} }
// } else { // } else {
// return ReturnHelper.errorResponse(res, 404, 402, Language.lang.failed_related, ""); // return ReturnHelper.errorResponse(res, 404, 402, Language.lang.failed_related, "");
// } // }
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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.tags = ['User Roles']
#swagger.security = [{ #swagger.security = [{
"bearerAuth": [] "bearerAuth": []
@ -410,27 +402,27 @@ export class UserRoleController {
type: 'string' type: 'string'
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID') 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) { if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {}); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {})
} else { } else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, ""); return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "")
} }
} catch (e: unknown) { } catch (e: unknown) {
log.error(e); log.error(e)
const err = e as Error; 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)
} }
} }
} }

89
src/helpers/orm.ts
View File

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