416 lines
14 KiB
TypeScript
416 lines
14 KiB
TypeScript
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 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 { EmailBody, Menu, User, UserRefreshToken, UserRole } from "entity";
|
|
import axios from 'axios';
|
|
import CommonHelper from "../helpers/common";
|
|
|
|
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().alphanum().min(6).required().label('Password')
|
|
});
|
|
|
|
const param: User = await schema.validateAsync(req.body);
|
|
|
|
const userRepository = OrmHelper.DB.getRepository(User);
|
|
const userRefreshTokenRepository = OrmHelper.DB.getRepository(UserRefreshToken);
|
|
|
|
const user = await userRepository.findOne({
|
|
select: ['id', 'email', 'password', 'username'],
|
|
where: { username: param.username },
|
|
})
|
|
|
|
if (user != null && user.checkIfPasswordMatch(param.password)) {
|
|
|
|
const { browser, device, os } = UAParser(req.get('User-Agent'));
|
|
|
|
const refresh_token = new UserRefreshToken();
|
|
refresh_token.id_user = user.id;
|
|
refresh_token.user_agent = req.get('User-Agent');
|
|
refresh_token.remote_addr = req.ip.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 userRole = await userRoleRepository.findOneBy({ id: user.id_role })
|
|
|
|
var privateKey = fs.readFileSync('src/helpers/key/private.key');
|
|
|
|
var token = jwt.sign(
|
|
{
|
|
exp: Math.floor(Date.now() / 1000) + (Number(config.get('auth.access_token_lifetime'))),
|
|
data: {
|
|
id: user.id,
|
|
username: user.username,
|
|
id_role: user.id_role,
|
|
roles: userRole.roles
|
|
}
|
|
},
|
|
privateKey,
|
|
{ algorithm: 'RS256' }
|
|
);
|
|
|
|
delete user.password;
|
|
|
|
|
|
|
|
const data = {
|
|
user,
|
|
roles_list: await AuthController.getListRole(userRole.roles),
|
|
token: {
|
|
access_token: token,
|
|
refresh_token: refresh_token.refresh_token
|
|
}
|
|
}
|
|
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_login, data);
|
|
}
|
|
|
|
return ReturnHelper.errorResponse(res, 403, 401, Language.lang.failed_access);
|
|
} catch (e: unknown) {
|
|
log.error(e);
|
|
const err = e as Error;
|
|
|
|
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_insert, err.message);
|
|
}
|
|
}
|
|
|
|
static async 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 '), whereVal)
|
|
.andWhere('id_parent is null')
|
|
.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 '), whereVal)
|
|
.andWhere('id_parent is not null').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;
|
|
|
|
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 resetPassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
#swagger.parameters['email'] = {
|
|
in: 'path',
|
|
description: 'Email',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
*/
|
|
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
email: Joi.string().email().required().label('Email'),
|
|
});
|
|
|
|
const param: User = await schema.validateAsync(req.params);
|
|
|
|
const userRepository = OrmHelper.DB.getRepository(User);
|
|
|
|
const user = await userRepository.findOne({
|
|
where: { email: param.email },
|
|
})
|
|
|
|
user.reset_token = uuidv4();
|
|
|
|
await userRepository.save(user);
|
|
|
|
//send email reset password
|
|
const url = config.get("service.notification") + "api/email/send";
|
|
|
|
console.log(url, 'url')
|
|
|
|
const template_raw = fs.readFileSync('assets/reset_password.html').toString();
|
|
|
|
const pairMap = {
|
|
'LINK': config.get('auth.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 { data } = await axios.post(url, email);
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
static async renewToken(req: Request, res: Response, next: NextFunction): Promise<Response> {
|
|
/*
|
|
#swagger.tags = ['Auth']
|
|
#swagger.parameters['refresh_token'] = {
|
|
in: 'path',
|
|
description: 'Refresh Token',
|
|
required: true,
|
|
type: 'string'
|
|
}
|
|
*/
|
|
try {
|
|
const schema = Joi.object().keys({
|
|
refresh_token: Joi.string().uuid().required().label('Refresh Token'),
|
|
});
|
|
|
|
const param: UserRefreshToken = await schema.validateAsync(req.params);
|
|
|
|
const userRefreshTokenRepo = OrmHelper.DB.getRepository(UserRefreshToken);
|
|
|
|
const refresh_token = await userRefreshTokenRepo.findOneBy({ refresh_token: param.refresh_token });
|
|
|
|
if (refresh_token != null) {
|
|
const userRepo = OrmHelper.DB.getRepository(User);
|
|
|
|
const user = await userRepo.findOneBy({ id: refresh_token.id_user });
|
|
|
|
const userRoleRepository = OrmHelper.DB.getRepository(UserRole);
|
|
const userRole = await userRoleRepository.findOneBy({ id: user.id_role })
|
|
|
|
var privateKey = fs.readFileSync('src/helpers/key/private.key');
|
|
|
|
var token = jwt.sign(
|
|
{
|
|
exp: Math.floor(Date.now() / 1000) + (Number(config.get('auth.access_token_lifetime'))),
|
|
data: {
|
|
id: user.id,
|
|
username: user.username,
|
|
id_role: user.id_role,
|
|
roles: userRole.roles
|
|
}
|
|
},
|
|
privateKey,
|
|
{ algorithm: 'RS256' }
|
|
);
|
|
|
|
return ReturnHelper.successResponseAny(res, 200, Language.lang.success, {
|
|
token,
|
|
roles_list: await AuthController.getListRole(userRole.roles)
|
|
});
|
|
} else {
|
|
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed, "");
|
|
}
|
|
} catch (e: unknown) {
|
|
log.error(e);
|
|
const err = e as Error;
|
|
|
|
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed, err.message);
|
|
}
|
|
}
|
|
|
|
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) {
|
|
if (param.password) {
|
|
data.password = param.password
|
|
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);
|
|
}
|
|
}
|
|
} |