460 lines
14 KiB
TypeScript
460 lines
14 KiB
TypeScript
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 config from "config"
|
|
import { ILogObj, Logger } from "tslog"
|
|
import { Language } from "../langs/lang"
|
|
import { UAParser } from "ua-parser-js"
|
|
import dayjs from "dayjs"
|
|
import jwt from "jsonwebtoken"
|
|
import fs from "fs"
|
|
import { v4 as uuidv4 } from "uuid"
|
|
import { User, UserRefreshToken, UserRole } from "entity"
|
|
import axios from "axios"
|
|
import CommonHelper from "../helpers/common"
|
|
import { MoreThan } from "typeorm"
|
|
|
|
const log: Logger<ILogObj> = new Logger({ name: "[UserController]", type: "pretty" })
|
|
|
|
export class AuthController {
|
|
static async login(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
#swagger.requestBody = {
|
|
required: true,
|
|
content: {
|
|
"application/json": {
|
|
schema: {
|
|
$ref: "#/components/schemas/login"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
username: Joi.string().max(64).required().label("Username"),
|
|
password: Joi.string().min(8).required().label("Password"),
|
|
// application: Joi.string().required().label("Application"),
|
|
})
|
|
|
|
const param: User & { application: string } = await schema.validateAsync(req.body)
|
|
|
|
const userRepository = OrmHelper.DB.getRepository(User)
|
|
const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken)
|
|
|
|
const user = await userRepository.findOne({
|
|
// relations: ["roles", "roles.application", "employee", "employee.department", "employee.position", "employee.shift"],
|
|
select: ["id", "email", "name", "password", "username", "roles"],
|
|
where: { username: param.username },
|
|
})
|
|
|
|
if (!user) {
|
|
return ReturnHelper.errorResponse(res, 401, 401, Language.lang.failed_access, "Username or password is incorrect")
|
|
}
|
|
|
|
if (
|
|
// user != null && user.roles != null && user.roles.length > 0 &&
|
|
user.checkIfPasswordMatch(param.password)) {
|
|
const { browser, device, os } = UAParser(req.get("User-Agent"))
|
|
|
|
const refresh_token = new UserRefreshToken()
|
|
refresh_token.id_user = user.id
|
|
refresh_token.user_agent = req.get("User-Agent")
|
|
refresh_token.remote_addr = req.ip.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);
|
|
|
|
// let role_id = ""
|
|
// let roles: UserRole
|
|
|
|
// if (user.roles) {
|
|
// for (let r of user.roles) {
|
|
// if (r.application.id == param.application) {
|
|
// role_id = r.id
|
|
// roles = r
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// if (role_id == "") {
|
|
// 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,
|
|
// }
|
|
|
|
// If user has employee, populate hrms data
|
|
// if (user.employee && user.employee.id) {
|
|
// hrms.uuid = user.employee.id
|
|
// hrms.employee_id = user.employee.employee_id || null
|
|
// hrms.employeename = user.employee.name || null
|
|
// hrms.title = user.employee.position?.name || null
|
|
// hrms.department_id = user.employee.department?.id || null
|
|
// hrms.departement_uuid = user.employee.department?.id || null
|
|
// hrms.department_name = user.employee.department?.name || null
|
|
// hrms.level_id = user.employee.position?.id || null
|
|
// hrms.level_name = user.employee.position?.name || null
|
|
// }
|
|
|
|
// const roomQuery = `SELECT r.id, r.room, r.code
|
|
// FROM rooms r
|
|
// INNER JOIN user_to_room utr ON utr.room_id = r.id
|
|
// WHERE utr.user_id = $1 AND r.deleted_at IS NULL AND utr.deleted_at IS NULL`
|
|
// const rooms = await OrmHelper.DB.query(roomQuery, [user.id])
|
|
|
|
// const facility = await OrmHelper.DB.getRepository(HospitalInformation).findOne({
|
|
// select: {
|
|
// id: true,
|
|
// facility_id: true,
|
|
// name: true,
|
|
// address: true,
|
|
// phone: true,
|
|
// code: true,
|
|
// },
|
|
// where: {},
|
|
// })
|
|
|
|
var privateKey = fs.readFileSync("src/helpers/key/private.key")
|
|
|
|
var token = jwt.sign(
|
|
{
|
|
exp: Math.floor(Date.now() / 1000) + Number(config.get("auth.access_token_lifetime")),
|
|
data: {
|
|
id: user.id,
|
|
username: user.username,
|
|
name: user.name,
|
|
// id_role: role_id,
|
|
// roles: roles.roles,
|
|
// // hrms: hrms,
|
|
},
|
|
},
|
|
privateKey,
|
|
{ algorithm: "RS256" }
|
|
)
|
|
|
|
delete user.password
|
|
|
|
const data = {
|
|
// user: { ...user, ...hrms, rooms },
|
|
// role_name: roles.name,
|
|
// default_page: roles.default_page ?? null,
|
|
// facility: facility ?? null,
|
|
// roles_list: await AuthController.getListRole(roles.roles),
|
|
token: {
|
|
access_token: token,
|
|
refresh_token: refresh_token.refresh_token,
|
|
},
|
|
user: user,
|
|
}
|
|
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_login, data)
|
|
}
|
|
// }
|
|
|
|
// if (user.roles == null || user.roles.length == 0) {
|
|
// return ReturnHelper.errorResponse(res, 401, 401, Language.lang.failed_access, "You don't have any roles in this application")
|
|
// } else {
|
|
// return ReturnHelper.errorResponse(res, 401, 401, Language.lang.failed_access, "Username or password is incorrect")
|
|
// }
|
|
|
|
return ReturnHelper.errorResponse(res, 401, 401, Language.lang.failed_access, "Username or password is incorrect")
|
|
} catch (e: unknown) {
|
|
log.error(e)
|
|
const err = e as Error
|
|
|
|
return ReturnHelper.errorResponse(res, 500, 403, Language.lang.failed_access, err.message)
|
|
}
|
|
}
|
|
|
|
// static async getListRole(roles: any): Promise<any> {
|
|
// // const repoMenu = OrmHelper.DB.getRepository(Menu)
|
|
|
|
// const whereAttr = []
|
|
// const whereVal = {}
|
|
|
|
// for (let k in roles) {
|
|
// let p = roles[k]
|
|
|
|
// whereAttr.push("id = :id" + k)
|
|
// whereVal["id" + k] = p
|
|
// }
|
|
|
|
// // const res_list = repoMenu
|
|
// // .createQueryBuilder()
|
|
// // .where("(" + whereAttr.join(" or ") + ") and id_parent is null", whereVal)
|
|
// // .orderBy("order_number", "ASC")
|
|
|
|
// // let list_data_final = await res_list.getMany()
|
|
|
|
// // if (list_data_final.length > 0) {
|
|
// // const res_list_all = await repoMenu
|
|
// // .createQueryBuilder()
|
|
// // .where("(" + whereAttr.join(" or ") + ") and id_parent is not null", whereVal)
|
|
// // .orderBy("order_number", "ASC")
|
|
// // .getMany()
|
|
|
|
// // let list_child: any = {}
|
|
// // for (let p of res_list_all) {
|
|
// // if (!list_child[p.id_parent]) {
|
|
// // list_child[p.id_parent] = []
|
|
// // }
|
|
|
|
// // delete p.status
|
|
// // delete p.created_at
|
|
// // delete p.updated_at
|
|
// // delete p.deleted_at
|
|
|
|
// // list_child[p.id_parent].push(p)
|
|
// // }
|
|
|
|
// // for (let f of list_data_final) {
|
|
// // delete f.status
|
|
// // delete f.created_at
|
|
// // delete f.updated_at
|
|
// // delete f.deleted_at
|
|
|
|
// // if (list_child[f.id]) {
|
|
// // f.children = list_child[f.id]
|
|
|
|
// // for (let g of f.children) {
|
|
// // if (list_child[g.id]) {
|
|
// // g.children = list_child[g.id]
|
|
|
|
// // for (let h of g.children) {
|
|
// // if (list_child[h.id]) {
|
|
// // h.children = list_child[h.id]
|
|
|
|
// // for (let i of h.children) {
|
|
// // if (list_child[i.id]) {
|
|
// // i.children = list_child[i.id]
|
|
|
|
// // for (let j of i.children) {
|
|
// // if (list_child[j.id]) {
|
|
// // j.children = list_child[j.id]
|
|
|
|
// // for (let k of j.children) {
|
|
// // if (list_child[k.id]) {
|
|
// // k.children = list_child[k.id]
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// // }
|
|
|
|
// // return list_data_final
|
|
// // }
|
|
|
|
// return {}
|
|
// }
|
|
|
|
static async logout(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
#swagger.parameters['refresh_token'] = {
|
|
in: 'path',
|
|
description: 'Refresh Token',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
*/
|
|
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
refresh_token: Joi.string().uuid().required().label("Refresh Token"),
|
|
})
|
|
|
|
const param: UserRefreshToken = await schema.validateAsync(req.params)
|
|
|
|
const repo = OrmHelper.DB.getRepository(UserRefreshToken)
|
|
|
|
const affected = (await repo.delete({ refresh_token: param.refresh_token })).affected ?? 0
|
|
|
|
if (affected > 0) {
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_logout)
|
|
} else {
|
|
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_logout, "")
|
|
}
|
|
} catch (e: unknown) {
|
|
log.error(e)
|
|
const err = e as Error
|
|
|
|
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_logout, err.message)
|
|
}
|
|
}
|
|
|
|
|
|
static async renewToken(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
#swagger.parameters['refresh_token'] = {
|
|
in: 'path',
|
|
description: 'Refresh Token',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
#swagger.parameters['application'] = {
|
|
in: 'path',
|
|
description: 'Application',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
*/
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
refresh_token: Joi.string().uuid().required().label("Refresh Token"),
|
|
application: Joi.string().required().label("Application"),
|
|
})
|
|
|
|
const param: UserRefreshToken & { application: string } = await schema.validateAsync(req.params)
|
|
|
|
const userRefreshTokenRepo = OrmHelper.DB.getRepository(UserRefreshToken)
|
|
|
|
const refresh_token = await userRefreshTokenRepo.findOneBy({ refresh_token: param.refresh_token, expired_at: MoreThan(new Date()) })
|
|
|
|
if (refresh_token != null) {
|
|
const userRepo = OrmHelper.DB.getRepository(User)
|
|
|
|
const user = await userRepo.findOne({ relations: ["roles", "roles.application"], where: { id: refresh_token.id_user } })
|
|
|
|
let role_id = ""
|
|
let roles: UserRole
|
|
|
|
// if (user.roles != null && user.roles.length > 0) {
|
|
// for (let r of user.roles) {
|
|
// if (r.application.id == param.application) {
|
|
// role_id = r.id
|
|
|
|
// roles = r
|
|
// }
|
|
// }
|
|
// } else {
|
|
// 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 userRole = await userRoleRepository.findOneBy({ id: role_id });
|
|
|
|
if (roles) {
|
|
var privateKey = fs.readFileSync("src/helpers/key/private.key")
|
|
|
|
var token = jwt.sign(
|
|
{
|
|
exp: Math.floor(Date.now() / 1000) + Number(config.get("auth.access_token_lifetime")),
|
|
data: {
|
|
id: user.id,
|
|
username: user.username,
|
|
name: user.name,
|
|
id_role: role_id,
|
|
roles: roles.roles,
|
|
},
|
|
},
|
|
privateKey,
|
|
{ algorithm: "RS256" }
|
|
)
|
|
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success, {
|
|
token,
|
|
role_name: roles.name,
|
|
// roles_list: await AuthController.getListRole(roles.roles),
|
|
})
|
|
} else {
|
|
return ReturnHelper.errorResponse(res, 403, 402, Language.lang.failed_access + ", you don't have any roles in this application")
|
|
}
|
|
} else {
|
|
return ReturnHelper.errorResponse(res, 404, 403, Language.lang.failed, "")
|
|
}
|
|
} catch (e: unknown) {
|
|
log.error(e)
|
|
const err = e as Error
|
|
|
|
return ReturnHelper.errorResponse(res, 500, 404, Language.lang.failed, err.message)
|
|
}
|
|
}
|
|
|
|
static async updatePassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
|
|
#swagger.parameters['token'] = {
|
|
in: 'path',
|
|
description: 'Token',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
|
|
#swagger.requestBody = {
|
|
required: true,
|
|
description: "This action will effect to user related token",
|
|
content: {
|
|
"application/json": {
|
|
schema: {
|
|
$ref: "#/components/schemas/user_password"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
reset_token: Joi.string().uuid().required().label("Token"),
|
|
password: Joi.string().required().label("Password"),
|
|
retype_password: Joi.ref("password"),
|
|
})
|
|
|
|
req.body.reset_token = req.params.token ?? ""
|
|
|
|
const param: User = await schema.validateAsync(req.body)
|
|
|
|
const userRepository = OrmHelper.DB.getRepository(User)
|
|
|
|
const data = await userRepository.findOneBy({ reset_token: param.reset_token })
|
|
|
|
if (data != null) {
|
|
data.password = param.password
|
|
data.reset_token = null
|
|
data.hashPassword()
|
|
|
|
await userRepository.save(data)
|
|
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update)
|
|
} 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)
|
|
}
|
|
}
|
|
}
|