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:
fro1991
2025-10-22 14:03:50 +07:00
parent 9f6e0df135
commit eed438e27c
1 changed files with 339 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

678
src/controllers/auth.ts
View File

@ -1,26 +1,26 @@
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 config from "config"; import config from "config"
import { ILogObj, Logger } from "tslog"; import { ILogObj, Logger } from "tslog"
import { Language } from "../langs/lang"; import { Language } from "../langs/lang"
import { UAParser } from 'ua-parser-js'; import { UAParser } from "ua-parser-js"
import dayjs from 'dayjs' import dayjs from "dayjs"
import jwt from 'jsonwebtoken'; import jwt from "jsonwebtoken"
import fs from 'fs'; import fs from "fs"
import { v4 as uuidv4 } from 'uuid'; import { v4 as uuidv4 } from "uuid"
import { Application, EmailBody, Menu, User, UserRefreshToken, UserRole } from "entity"; import { Application, EmailBody, Menu, User, UserRefreshToken, UserRole } from "entity"
import axios from 'axios'; import axios from "axios"
import CommonHelper from "../helpers/common"; import CommonHelper from "../helpers/common"
import { MoreThan } from "typeorm"; import { MoreThan } from "typeorm"
const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' }); const log: Logger<ILogObj> = new Logger({ name: "[UserController]", type: "pretty" })
export class AuthController { export class AuthController {
static async login(req: Request, res: Response, next: NextFunction): Promise<Response> { static async login(req: Request, res: Response, next: NextFunction): Promise<Response> {
/* /*
#swagger.tags = ['Auth'] #swagger.tags = ['Auth']
#swagger.requestBody = { #swagger.requestBody = {
required: true, required: true,
@ -34,213 +34,215 @@ export class AuthController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
username: Joi.string().max(64).required().label('Username'), username: Joi.string().max(64).required().label("Username"),
password: Joi.string().min(8).required().label('Password'), password: Joi.string().min(8).required().label("Password"),
application: Joi.string().required().label('Application'), application: Joi.string().required().label("Application"),
}); })
const param: User & { application: string } = await schema.validateAsync(req.body); const param: User & { application: string } = await schema.validateAsync(req.body)
const userRepository = OrmHelper.DB.getRepository(User); const userRepository = OrmHelper.DB.getRepository(User)
const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken); const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken)
const user = await userRepository.findOne({ const user = await userRepository.findOne({
relations: ['roles', 'roles.application'], relations: ["roles", "roles.application"],
select: ['id', 'email', 'name', 'nik', 'password', 'username', 'roles'], select: ["id", "email", "name", "nik", "password", "username", "roles"],
where: { username: param.username }, where: { username: param.username },
}) })
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')); const refresh_token = new UserRefreshToken()
refresh_token.id_user = user.id
refresh_token.user_agent = req.get("User-Agent")
refresh_token.remote_addr = req.ip.split(":").pop()
refresh_token.browser = browser.name + " " + browser.version
refresh_token.os = os.name + " " + os.version
refresh_token.device = (device.model ?? "") + " " + (device.vendor ?? "")
refresh_token.platform = device.type ?? "desktop"
refresh_token.expired_at = dayjs().add(config.get("auth.refresh_token_lifetime_day"), "day").toDate()
const refresh_token = new UserRefreshToken(); await userRefreshTokenRepository.save(refresh_token)
refresh_token.id_user = user.id;
refresh_token.user_agent = req.get('User-Agent');
refresh_token.remote_addr = req.ip.split(':').pop();
refresh_token.browser = browser.name + " " + browser.version;
refresh_token.os = os.name + " " + os.version;
refresh_token.device = (device.model ?? '') + " " + (device.vendor ?? '');
refresh_token.platform = device.type ?? 'desktop';
refresh_token.expired_at = dayjs().add(config.get('auth.refresh_token_lifetime_day'), 'day').toDate();
await userRefreshTokenRepository.save(refresh_token); // const userRoleRepository = OrmHelper.DB.getRepository(UserRole);
// const userRoleRepository = OrmHelper.DB.getRepository(UserRole); let role_id = ""
let roles: UserRole
let role_id = ''; if (user.roles) {
let roles: UserRole; for (let r of user.roles) {
if (r.application.id == param.application) {
role_id = r.id
roles = r
}
}
}
if (user.roles) { if (role_id == "") {
for (let r of user.roles) { return ReturnHelper.errorResponse(res, 403, 403, Language.lang.failed_access + ", you don't have any roles in this application")
if (r.application.id == param.application) { } else {
role_id = r.id; // const userRole = await userRoleRepository.findOneBy({ id: role_id })
roles = r; var hrms = {
} department_id: null,
} department_name: null,
} level_id: null,
level_name: null,
}
if (role_id == '') { if (user.nik) {
return ReturnHelper.errorResponse(res, 403, 403, Language.lang.failed_access + ', you don\'t have any roles in this application'); const url = config.get("service.hrms") + "api/get-employee?nik=" + user.nik
} else { const { data: dataHrms } = await axios.get(url)
// const userRole = await userRoleRepository.findOneBy({ id: role_id }) if (dataHrms && dataHrms.status && dataHrms.data.count == 1) {
var hrms = { hrms = {
department_id: null, department_id: dataHrms.data.list[0].idxdept,
department_name: null, department_name: dataHrms.data.list[0].departement,
level_id: null, level_id: dataHrms.data.list[0].idxlevel,
level_name: null level_name: dataHrms.data.list[0].level,
} }
}
}
if (user.nik) { var privateKey = fs.readFileSync("src/helpers/key/private.key")
const url = config.get("service.hrms") + "api/get-employee?nik=" + user.nik;
const { data: dataHrms } = await axios.get(url);
if (dataHrms && dataHrms.status && dataHrms.data.count == 1) {
hrms = {
department_id: dataHrms.data.list[0].idxdept,
department_name: dataHrms.data.list[0].departement,
level_id: dataHrms.data.list[0].idxlevel,
level_name: dataHrms.data.list[0].level
}
}
}
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,
nik: user.nik,
hrms: hrms,
},
},
privateKey,
{ algorithm: "RS256" }
)
var privateKey = fs.readFileSync('src/helpers/key/private.key'); delete user.password
var token = jwt.sign( const data = {
{ user: { ...user, ...hrms },
exp: Math.floor(Date.now() / 1000) + (Number(config.get('auth.access_token_lifetime'))), role_name: roles.name,
data: { roles_list: await AuthController.getListRole(roles.roles),
id: user.id, token: {
username: user.username, access_token: token,
name: user.name, refresh_token: refresh_token.refresh_token,
id_role: role_id, },
roles: roles.roles }
}
},
privateKey,
{ algorithm: 'RS256' }
);
delete user.password; return ReturnHelper.successResponseAny(res, 200, Language.lang.success_login, data)
}
}
const data = { if (user.roles == null || user.roles.length == 0) {
user: { ...user, ...hrms }, return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access + ", you don\t have any roles in this application")
role_name: roles.name, } else {
roles_list: await AuthController.getListRole(roles.roles), return ReturnHelper.errorResponse(res, 403, 402, Language.lang.failed_access)
token: { }
access_token: token, } catch (e: unknown) {
refresh_token: refresh_token.refresh_token log.error(e)
} const err = e as Error
}
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_login, data); return ReturnHelper.errorResponse(res, 500, 403, Language.lang.failed_access, err.message)
} }
} }
if (user.roles == null || user.roles.length == 0) { static async getListRole(roles: any): Promise<any> {
return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access + ', you don\t have any roles in this application'); const repoMenu = OrmHelper.DB.getRepository(Menu)
} else {
return ReturnHelper.errorResponse(res, 403, 402, Language.lang.failed_access);
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 403, Language.lang.failed_access, err.message); const whereAttr = []
} const whereVal = {}
}
static async getListRole(roles: any): Promise<any> { for (let k in roles) {
const repoMenu = OrmHelper.DB.getRepository(Menu); let p = roles[k]
const whereAttr = []; whereAttr.push("id = :id" + k)
const whereVal = {}; whereVal["id" + k] = p
}
for (let k in roles) { const res_list = repoMenu
let p = roles[k]; .createQueryBuilder()
.where("(" + whereAttr.join(" or ") + ") and id_parent is null", whereVal)
.orderBy("order_number", "ASC")
whereAttr.push('id = :id' + k); let list_data_final = await res_list.getMany()
whereVal['id' + k] = p;
}
const res_list = repoMenu.createQueryBuilder() if (list_data_final.length > 0) {
.where('(' + whereAttr.join(' or ') + ') and id_parent is null', whereVal) const res_list_all = await repoMenu
.orderBy('order_number', 'ASC'); .createQueryBuilder()
.where("(" + whereAttr.join(" or ") + ") and id_parent is not null", whereVal)
.orderBy("order_number", "ASC")
.getMany()
let list_data_final = await res_list.getMany(); let list_child: any = {}
for (let p of res_list_all) {
if (!list_child[p.id_parent]) {
list_child[p.id_parent] = []
}
if (list_data_final.length > 0) { delete p.status
const res_list_all = await repoMenu.createQueryBuilder() delete p.created_at
.where('(' + whereAttr.join(' or ') + ') and id_parent is not null', whereVal) delete p.updated_at
.orderBy('order_number', 'ASC').getMany(); delete p.deleted_at
let list_child: any = {}; list_child[p.id_parent].push(p)
for (let p of res_list_all) { }
if (!list_child[p.id_parent]) {
list_child[p.id_parent] = [];
}
delete p.status for (let f of list_data_final) {
delete p.created_at delete f.status
delete p.updated_at delete f.created_at
delete p.deleted_at delete f.updated_at
delete f.deleted_at
list_child[p.id_parent].push(p); if (list_child[f.id]) {
} f.children = list_child[f.id]
for (let f of list_data_final) { for (let g of f.children) {
delete f.status if (list_child[g.id]) {
delete f.created_at g.children = list_child[g.id]
delete f.updated_at
delete f.deleted_at
if (list_child[f.id]) { for (let h of g.children) {
f.children = list_child[f.id]; if (list_child[h.id]) {
h.children = list_child[h.id]
for (let g of f.children) { for (let i of h.children) {
if (list_child[g.id]) { if (list_child[i.id]) {
g.children = list_child[g.id]; i.children = list_child[i.id]
for (let h of g.children) { for (let j of i.children) {
if (list_child[h.id]) { if (list_child[j.id]) {
h.children = list_child[h.id]; j.children = list_child[j.id]
for (let i of h.children) { for (let k of j.children) {
if (list_child[i.id]) { if (list_child[k.id]) {
i.children = list_child[i.id]; k.children = list_child[k.id]
}
}
}
}
}
}
}
}
}
}
}
}
for (let j of i.children) { return list_data_final
if (list_child[j.id]) { }
j.children = list_child[j.id];
for (let k of j.children) { return {}
if (list_child[k.id]) { }
k.children = list_child[k.id];
}
}
}
}
}
}
}
}
}
}
}
}
return list_data_final; static async logout(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
}
return {};
}
static async logout(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['Auth'] #swagger.tags = ['Auth']
#swagger.parameters['refresh_token'] = { #swagger.parameters['refresh_token'] = {
in: 'path', in: 'path',
@ -250,32 +252,32 @@ export class AuthController {
} }
*/ */
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_logout); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_logout)
} else { } else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_logout, ""); return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_logout, "")
} }
} 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_logout, err.message); return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_logout, err.message)
} }
} }
static async resetPassword(req: Request, res: Response, next: NextFunction): Promise<Response> { static async resetPassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
/* /*
#swagger.tags = ['Auth'] #swagger.tags = ['Auth']
#swagger.parameters['email'] = { #swagger.parameters['email'] = {
in: 'path', in: 'path',
@ -291,67 +293,65 @@ export class AuthController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
email: Joi.string().email().required().label('Email'), email: Joi.string().email().required().label("Email"),
application: Joi.string().required().label('Application'), application: Joi.string().required().label("Application"),
}); })
const param: { email: string, application: string } = await schema.validateAsync(req.params); const param: { email: string; application: string } = await schema.validateAsync(req.params)
const userRepository = OrmHelper.DB.getRepository(User); const userRepository = OrmHelper.DB.getRepository(User)
const user = await userRepository.findOne({ const user = await userRepository.findOne({
where: { email: param.email }, where: { email: param.email },
}) })
user.reset_token = uuidv4(); user.reset_token = uuidv4()
await userRepository.save(user); await userRepository.save(user)
//send email reset password //send email reset password
const url = config.get("service.notification") + "api/email/send"; const url = config.get("service.notification") + "api/email/send"
// console.log(url, 'url') // console.log(url, 'url')
const template_raw = fs.readFileSync('assets/reset_password.html').toString(); const template_raw = fs.readFileSync("assets/reset_password.html").toString()
const appRepository = OrmHelper.DB.getRepository(Application); const appRepository = OrmHelper.DB.getRepository(Application)
const app = await appRepository.findOneBy({ id: param.application }) const app = await appRepository.findOneBy({ id: param.application })
const pairMap = {
// 'LINK': config.get('auth.reset_password_url') + user.reset_token,
LINK: app.reset_password_url + user.reset_token,
NAME: user.name,
}
const pairMap = { const template = CommonHelper.generateTemplate(template_raw, pairMap)
// 'LINK': config.get('auth.reset_password_url') + user.reset_token,
'LINK': app.reset_password_url + user.reset_token,
'NAME': user.name
}
const template = CommonHelper.generateTemplate(template_raw, pairMap); const email: EmailBody = {
subject: "Reset Password",
to: [user.email],
cc: [],
bcc: [],
html: template,
}
const email: EmailBody = { const { data } = await axios.post(url, email)
subject: "Reset Password",
to: [user.email],
cc: [],
bcc: [],
html: template
}
const { data } = await axios.post(url, email); return ReturnHelper.successResponseAny(res, 200, Language.lang.success, data)
return ReturnHelper.successResponseAny(res, 200, Language.lang.success, data); // return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access);
} catch (e: unknown) {
log.error(e)
const err = e as Error
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed, err.message)
}
}
// return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access); static async renewToken(req: Request, res: Response, next: NextFunction): Promise<Response> {
} catch (e: unknown) { /*
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed, err.message);
}
}
static async renewToken(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['Auth'] #swagger.tags = ['Auth']
#swagger.parameters['refresh_token'] = { #swagger.parameters['refresh_token'] = {
in: 'path', in: 'path',
@ -366,80 +366,80 @@ export class AuthController {
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"),
application: Joi.string().required().label('Application'), application: Joi.string().required().label("Application"),
}); })
const param: UserRefreshToken & { application: string } = await schema.validateAsync(req.params); const param: UserRefreshToken & { application: string } = await schema.validateAsync(req.params)
const userRefreshTokenRepo = OrmHelper.DB.getRepository(UserRefreshToken); const userRefreshTokenRepo = OrmHelper.DB.getRepository(UserRefreshToken)
const refresh_token = await userRefreshTokenRepo.findOneBy({ refresh_token: param.refresh_token, expired_at: MoreThan(new Date()) }); const refresh_token = await userRefreshTokenRepo.findOneBy({ refresh_token: param.refresh_token, expired_at: MoreThan(new Date()) })
if (refresh_token != null) { if (refresh_token != null) {
const userRepo = OrmHelper.DB.getRepository(User); const userRepo = OrmHelper.DB.getRepository(User)
const user = await userRepo.findOne({ relations: ['roles', 'roles.application'], where: { id: refresh_token.id_user } }); const user = await userRepo.findOne({ relations: ["roles", "roles.application"], where: { id: refresh_token.id_user } })
let role_id = ''; let role_id = ""
let roles: UserRole; let roles: UserRole
if (user.roles != null && user.roles.length > 0) { if (user.roles != null && user.roles.length > 0) {
for (let r of user.roles) { for (let r of user.roles) {
if (r.application.id == param.application) { if (r.application.id == param.application) {
role_id = r.id; role_id = r.id
roles = r; roles = r
} }
} }
} else { } else {
return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access + ', you don\'t have any roles in this application'); return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access + ", you don't have any roles in this application")
} }
// const userRoleRepository = OrmHelper.DB.getRepository(UserRole); // const userRoleRepository = OrmHelper.DB.getRepository(UserRole);
// const userRole = await userRoleRepository.findOneBy({ id: role_id }); // const userRole = await userRoleRepository.findOneBy({ id: role_id });
if (roles) { if (roles) {
var privateKey = fs.readFileSync('src/helpers/key/private.key'); var privateKey = fs.readFileSync("src/helpers/key/private.key")
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")),
data: { data: {
id: user.id, id: user.id,
username: user.username, username: user.username,
name: user.name, name: user.name,
id_role: role_id, id_role: role_id,
roles: roles.roles roles: roles.roles,
} },
}, },
privateKey, privateKey,
{ algorithm: 'RS256' } { algorithm: "RS256" }
); )
return ReturnHelper.successResponseAny(res, 200, Language.lang.success, { return ReturnHelper.successResponseAny(res, 200, Language.lang.success, {
token, token,
role_name: roles.name, role_name: roles.name,
roles_list: await AuthController.getListRole(roles.roles) roles_list: await AuthController.getListRole(roles.roles),
}); })
} else { } else {
return ReturnHelper.errorResponse(res, 403, 402, Language.lang.failed_access + ', you don\'t have any roles in this application'); return ReturnHelper.errorResponse(res, 403, 402, Language.lang.failed_access + ", you don't have any roles in this application")
} }
} else { } else {
return ReturnHelper.errorResponse(res, 404, 403, Language.lang.failed, ""); return ReturnHelper.errorResponse(res, 404, 403, Language.lang.failed, "")
} }
} 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, 404, Language.lang.failed, err.message); return ReturnHelper.errorResponse(res, 500, 404, Language.lang.failed, err.message)
} }
} }
static async updatePassword(req: Request, res: Response, next: NextFunction): Promise<Response> { static async updatePassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
/* /*
#swagger.tags = ['Auth'] #swagger.tags = ['Auth']
#swagger.parameters['token'] = { #swagger.parameters['token'] = {
@ -462,37 +462,37 @@ export class AuthController {
} }
*/ */
try { try {
const schema = Joi.object().keys({ const schema = Joi.object().keys({
reset_token: Joi.string().uuid().required().label('Token'), reset_token: Joi.string().uuid().required().label("Token"),
password: Joi.string().required().label('Password'), password: Joi.string().required().label("Password"),
retype_password: Joi.ref('password'), retype_password: Joi.ref("password"),
}); })
req.body.reset_token = req.params.token ?? ''; req.body.reset_token = req.params.token ?? ""
const param: User = await schema.validateAsync(req.body); const param: User = await schema.validateAsync(req.body)
const userRepository = OrmHelper.DB.getRepository(User); const userRepository = OrmHelper.DB.getRepository(User)
const data = await userRepository.findOneBy({ reset_token: param.reset_token }); const data = await userRepository.findOneBy({ reset_token: param.reset_token })
if (data != null) { if (data != null) {
data.password = param.password; data.password = param.password
data.reset_token = null; data.reset_token = null
data.hashPassword(); data.hashPassword()
await userRepository.save(data); await userRepository.save(data)
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update); return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update)
} 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)
} }
} }
} }