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

update user, auth, token, roles, done

Browse Source
This commit is contained in:
Abdul Rahman Reza
2024-11-26 23:58:38 +07:00
parent 6e71588f91
commit 9608e96401
27 changed files with 1842 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
src/controllers/auth.ts Normal file
View File

@ -0,0 +1,196 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import { User } from "../entity/users";
import Joi from "joi";
import config from "config";
import { ILogObj, Logger } from "tslog";
import { Language } from "../langs/lang";
import { UserRefreshToken } from "../entity/user_refresh_token";
import { UAParser } from 'ua-parser-js';
import dayjs from 'dayjs'
import jwt from 'jsonwebtoken';
import fs from 'fs';
import { UserRole } from "../entity/users_roles";
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.parameters['body'] = {
in: 'body',
description: 'Login data',
required: true,
schema: {
username: "admin",
password: "123456"
}
}*/
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;
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,
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 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 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 });
} 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);
}
}
}

422
src/controllers/user.ts Normal file
View File

@ -0,0 +1,422 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import { User } from "../entity/users";
import Joi from "joi";
import { ILogObj, Logger } from "tslog";
import { Language } from "../langs/lang";
import { Paging } from "../types/paging";
import CommonHelper from "../helpers/common";
const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' });
export class UserController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['filter'] = {
in: 'query',
type: 'string'
}
#swagger.parameters['limit'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['page'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['with_deleted'] = {
in: 'query',
required: true,
type: 'boolean'
}
#swagger.parameters['order_field'] = {
in: 'query',
required: true,
type: 'string'
}
#swagger.parameters['order_direction'] = {
in: 'query',
required: true,
enum: [ "ASC", "DESC"]
}
*/
try {
const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'),
page: Joi.number().required().min(1).label('Page'),
limit: Joi.number().required().min(1).label('Limit'),
with_deleted: Joi.bool().required().label('With Deleted'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
});
const param: Paging = await schema.validateAsync(req.query);
const userRepository = OrmHelper.DB.getRepository(User);
const offset = (param.page - 1) * param.limit
let whereAttr = '';
let whereVal: any = {};
if (param.filter) {
whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
whereVal['filter'] = param.filter
whereVal['filter_like'] = '%' + param.filter + '%'
}
const res_count = userRepository.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = userRepository.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.skip(offset)
.limit(param.limit);
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
const current_page = param.page;
const total_count_data = await res_count.getCount();
const list_data = await res_list.getMany();
const count_data = CommonHelper.countObject(list_data);
return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
}
}
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
required: true,
schema: {
email: "admin@gmail.com",
username: "admin",
password: "123456",
retype_password: "123456",
name: "Administrator",
id_role: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
status:"Y"
}
}*/
try {
const schema = Joi.object().keys({
email: Joi.string().email().max(64).required().label('Email'),
username: Joi.string().max(64).required().label('Username'),
password: Joi.string().alphanum().min(6).required().label('Password'),
retype_password: Joi.ref('password'),
name: Joi.string().max(64).required().label('Name'),
id_role: Joi.string().uuid().required().label('Role'),
status: Joi.string().required().label('Status'),
});
const param: User = await schema.validateAsync(req.body);
const data = new User()
data.name = param.name
data.username = param.username
data.password = param.password
data.email = param.email
data.id_role = param.id_role
data.status = param.status
data.hashPassword();
await OrmHelper.DB.manager.save(data);
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
}
}
static async updateProfile(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
required: true,
type: 'string'
}
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
required: true,
schema: {
email: "admin@gmail.com",
username: "admin",
name: "Administrator"
}
}*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
email: Joi.string().email().max(64).required().label('Email'),
username: Joi.string().max(64).required().label('Username'),
name: Joi.string().max(64).required().label('Name'),
});
req.body.id = req.params['id'];
const param: User = await schema.validateAsync(req.body);
const userRepository = OrmHelper.DB.getRepository(User);
const data = await userRepository.findOneBy({ id: param.id });
if (data != null) {
data.name = param.name
data.username = param.username
data.email = param.email
await userRepository.save(data);
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
}
}
static async updatePassword(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
required: true,
type: 'string'
}
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
required: true,
schema: {
password: "123456",
retype_password: "123456",
}
}*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
password: Joi.string().required().label('Password'),
retype_password: Joi.ref('password'),
});
req.body.id = req.params['id'];
const param: User = await schema.validateAsync(req.body);
const userRepository = OrmHelper.DB.getRepository(User);
const data = await userRepository.findOneBy({ id: param.id });
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, data);
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
}
}
static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
required: true,
type: 'string'
}
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
required: true,
schema: {
email: "admin@gmail.com",
username: "admin",
password: "123456",
retype_password: "123456",
name: "Administrator",
id_role: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
status:"Y"
}
}*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
email: Joi.string().email().max(64).required().label('Email'),
username: Joi.string().max(64).required().label('Username'),
password: Joi.string().allow('').optional().label('Password'),
retype_password: Joi.ref('password'),
name: Joi.string().max(64).required().label('Name'),
id_role: Joi.string().uuid().required().label('Role'),
status: Joi.string().required().label('Status'),
});
req.body.id = req.params['id'];
const param: User = await schema.validateAsync(req.body);
const userRepository = OrmHelper.DB.getRepository(User);
const data = await userRepository.findOneBy({ id: param.id });
if (data != null) {
data.name = param.name
data.username = param.username
data.email = param.email
data.id_role = param.id_role
data.status = param.status
if (param.password) {
data.password = param.password
data.hashPassword();
}
await userRepository.save(data);
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_update, err.message);
}
}
static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
required: true,
type: 'string'
}
*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID')
});
const param: User = await schema.validateAsync(req.params);
const userRepository = OrmHelper.DB.getRepository(User);
const affected = (await userRepository.softDelete({ id: param.id })).affected;
if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {});
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message);
}
}
static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User']
#swagger.security = [{
"bearerAuth": []
}]
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
required: true,
type: 'string'
}
*/
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID')
});
const param: User = await schema.validateAsync(req.params);
const userRepository = OrmHelper.DB.getRepository(User);
const affected = (await userRepository.restore({ id: param.id })).affected;
if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {});
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_restore, err.message);
}
}
}

152
src/controllers/user_activity.ts Normal file
View File

@ -0,0 +1,152 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import { User } from "../entity/users";
import Joi from "joi";
import { ILogObj, Logger } from "tslog";
import { Language } from "../langs/lang";
import { Paging } from "../types/paging";
import CommonHelper from "../helpers/common";
import { ActivityType } from "../types/action";
import { UserActivity } from "../entity/user_activity";
const log: Logger<ILogObj> = new Logger({ name: '[UserActivityController]', type: 'pretty' });
export class UserActivityController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Activity']
#swagger.parameters['filter'] = {
in: 'query',
type: 'string'
}
#swagger.parameters['limit'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['page'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['with_deleted'] = {
in: 'query',
required: true,
type: 'boolean'
}
#swagger.parameters['order_field'] = {
in: 'query',
required: true,
type: 'string'
}
#swagger.parameters['order_direction'] = {
in: 'query',
required: true,
enum: [ "ASC", "DESC"]
}
*/
try {
const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'),
page: Joi.number().required().min(1).label('Page'),
limit: Joi.number().required().min(1).label('Limit'),
with_deleted: Joi.bool().required().label('With Deleted'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
});
const param: Paging = await schema.validateAsync(req.query);
const userRepository = OrmHelper.DB.getRepository(User);
const offset = (param.page - 1) * param.limit
let whereAttr = '';
let whereVal: any = {};
if (param.filter) {
whereAttr = 'module like :filter_like or username like :filter_like or email = :filter ';
whereVal['filter'] = param.filter
whereVal['filter_like'] = '%' + param.filter + '%'
}
const res_count = userRepository.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = userRepository.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.skip(offset)
.limit(param.limit);
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
const current_page = param.page;
const total_count_data = await res_count.getCount();
const list_data = await res_list.getMany();
const count_data = CommonHelper.countObject(list_data);
return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
}
}
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Activity']
#swagger.parameters['body'] = {
in: 'body',
description: 'User Activity data',
required: true,
schema: {
id_user: "4a6991b6-78a0-4b3b-bf5c-fa0af5f69be8",
refresh_token: "1a1221b6-78a0-4b3b-bf5c-fa0af5f69be8",
module: "dashboard",
description: "Main Dashboard",
action: "V",
url: "https://bri-dev.shiblysolution.id/",
data_body:"{\"from\":\"2024-11-01\",\"to\":\"2024-11-26\"}"
}
}*/
try {
const schema = Joi.object().keys({
id_user: Joi.string().uuid().required().label('ID User'),
refresh_token: Joi.string().uuid().required().label('Refresh Token'),
module: Joi.string().required().label('Module'),
description: Joi.string().required().label('Description'),
action: Joi.string().allow(...Object.values(ActivityType)).required().label('Action'),
url: Joi.string().optional().allow('').label('URL'),
data_body: Joi.string().optional().allow('').label('data_body'),
});
const param: UserActivity = await schema.validateAsync(req.body);
const data = new UserActivity()
data.id_user = param.id_user
data.refresh_token = param.refresh_token
data.module = param.module
data.description = param.description
data.action = param.action
data.url = param.url
data.data_body = param.data_body
await OrmHelper.DB.manager.save(data);
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_insert, data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 401, Language.lang.failed_insert, err.message);
}
}
}

127
src/controllers/user_refresh_token.ts Normal file
View File

@ -0,0 +1,127 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import Joi from "joi";
import { ILogObj, Logger } from "tslog";
import { Language } from "../langs/lang";
import { Paging } from "../types/paging";
import CommonHelper from "../helpers/common";
import { UserRefreshToken } from "../entity/user_refresh_token";
const log: Logger<ILogObj> = new Logger({ name: '[UserRefreshTokenController]', type: 'pretty' });
export class UserRefreshTokenController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Refresh Token']
#swagger.parameters['filter'] = {
in: 'query',
type: 'string'
}
#swagger.parameters['limit'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['page'] = {
in: 'query',
required: true,
type: 'number'
}
#swagger.parameters['order_field'] = {
in: 'query',
required: true,
type: 'string'
}
#swagger.parameters['order_direction'] = {
in: 'query',
required: true,
enum: [ "ASC", "DESC"]
}
*/
try {
const schema = Joi.object().keys({
filter: Joi.string().allow('').optional().label('Filter'),
page: Joi.number().required().min(1).label('Page'),
limit: Joi.number().required().min(1).label('Limit'),
order_field: Joi.string().required().label('Order Field'),
order_direction: Joi.string().allow('asc', 'desc').required().label('Order Direction'),
});
const param: Paging = await schema.validateAsync(req.query);
const repo = OrmHelper.DB.getRepository(UserRefreshToken);
const offset = (param.page - 1) * param.limit
let whereAttr = '';
let whereVal: any = {};
if (param.filter) {
whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
whereVal['filter'] = param.filter
whereVal['filter_like'] = '%' + param.filter + '%'
}
const res_count = repo.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.skip(offset)
.limit(param.limit);
if (param.with_deleted) {
res_count.withDeleted();
res_list.withDeleted();
}
const current_page = param.page;
const total_count_data = await res_count.getCount();
const list_data = await res_list.getMany();
const count_data = CommonHelper.countObject(list_data);
return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 400, 401, Language.lang.failed_view, err.message);
}
}
static async forceLogout(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Refresh Token']
#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_delete, {});
} else {
return ReturnHelper.errorResponse(res, 404, 401, Language.lang.failed_not_found, "");
}
} catch (e: unknown) {
log.error(e);
const err = e as Error;
return ReturnHelper.errorResponse(res, 500, 402, Language.lang.failed_delete, err.message);
}
}
}

112
src/controllers/user/user.ts → src/controllers/user_roles.ts
View File

@ -1,18 +1,20 @@
import { Request, Response, NextFunction, Application } from "express";
import { ReturnHelper } from "../../helpers/express/return";
import { OrmHelper } from "../../helpers/orm";
import { User } from "../../entity/users";
import { ReturnHelper } from "../helpers/express/return";
import { OrmHelper } from "../helpers/orm";
import Joi from "joi";
import { ILogObj, Logger } from "tslog";
import { Language } from "../../langs/lang";
import { Paging } from "../../types/paging";
import CommonHelper from "../../helpers/common";
import { Language } from "../langs/lang";
import { Paging } from "../types/paging";
import CommonHelper from "../helpers/common";
import { Status } from "../types/status";
import { UserRole } from "../entity/users_roles";
const log: Logger<ILogObj> = new Logger({ name: '[UserController]', type: 'pretty' });
const log: Logger<ILogObj> = new Logger({ name: '[UserRoleController]', type: 'pretty' });
export class UserController {
export class UserRoleController {
static async list(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['filter'] = {
in: 'query',
type: 'string'
@ -56,7 +58,7 @@ export class UserController {
const param: Paging = await schema.validateAsync(req.query);
const userRepository = OrmHelper.DB.getRepository(User);
const repo = OrmHelper.DB.getRepository(UserRole);
const offset = (param.page - 1) * param.limit
@ -64,14 +66,14 @@ export class UserController {
let whereVal: any = {};
if (param.filter) {
whereAttr = 'name like :filter_like or username like :filter_like or email = :filter ';
whereVal['filter'] = param.filter
whereAttr = 'name like :filter_like';
// whereVal['filter'] = param.filter
whereVal['filter_like'] = '%' + param.filter + '%'
}
const res_count = userRepository.createQueryBuilder()
const res_count = repo.createQueryBuilder()
.where(whereAttr, whereVal);
const res_list = userRepository.createQueryBuilder()
const res_list = repo.createQueryBuilder()
.where(whereAttr, whereVal)
.orderBy(param.order_field, param.order_direction)
.skip(offset)
@ -87,7 +89,7 @@ export class UserController {
const list_data = await res_list.getMany();
const count_data = CommonHelper.countObject(list_data);
return ReturnHelper.successResponseList(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
return ReturnHelper.successResponselist(res, 200, Language.lang.success_view, count_data, current_page, total_count_data, list_data);
} catch (e: unknown) {
log.error(e);
const err = e as Error;
@ -98,40 +100,30 @@ export class UserController {
static async create(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
description: 'User role data',
required: true,
schema: {
email: "admin@gmail.com",
username: "admin",
password: "123456",
retype_password: "123456",
name: "Administrator",
role: "ADMINISTRATOR",
roles: ["dashboard"],
status:"Y"
}
}*/
try {
const schema = Joi.object().keys({
email: Joi.string().email().max(64).required().label('Email'),
username: Joi.string().max(64).required().label('Username'),
password: Joi.string().alphanum().min(6).required().label('Password'),
retype_password: Joi.ref('password'),
name: Joi.string().max(64).required().label('Name'),
role: Joi.string().required().label('Role'),
status: Joi.string().required().label('Status'),
roles: Joi.array().required().label('Roles'),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
});
const param: User = await schema.validateAsync(req.body);
const param: UserRole = await schema.validateAsync(req.body);
const data = new User()
const data = new UserRole()
data.name = param.name
data.username = param.username
data.password = param.password
data.email = param.email
data.role = param.role
data.roles = param.roles
data.status = param.status
await OrmHelper.DB.manager.save(data);
@ -147,24 +139,21 @@ export class UserController {
static async update(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
description: 'User role ID.',
required: true,
type: 'uuid'
type: 'string'
}
#swagger.parameters['body'] = {
in: 'body',
description: 'User data',
description: 'User role data',
required: true,
schema: {
email: "admin@gmail.com",
username: "admin",
password: "123456",
retype_password: "123456",
name: "Administrator",
role: "ADMINISTRATOR",
roles: ["dashboard"],
status:"Y"
}
}*/
@ -172,32 +161,25 @@ export class UserController {
try {
const schema = Joi.object().keys({
id: Joi.string().uuid().required().label('ID'),
email: Joi.string().email().max(64).required().label('Email'),
username: Joi.string().max(64).required().label('Username'),
password: Joi.string().allow('').optional().label('Password'),
retype_password: Joi.ref('password'),
name: Joi.string().max(64).required().label('Name'),
role: Joi.string().required().label('Role'),
status: Joi.string().required().label('Status'),
roles: Joi.array().required().label('Roles'),
status: Joi.string().allow(...Object.values(Status)).required().label('Status'),
});
req.body.id = req.params['id'];
const param: User = await schema.validateAsync(req.body);
const param: UserRole = await schema.validateAsync(req.body);
const userRepository = OrmHelper.DB.getRepository(User);
const repo = OrmHelper.DB.getRepository(UserRole);
const data = await userRepository.findOneBy({ id: param.id });
const data = await repo.findOneBy({ id: param.id });
if (data != null) {
data.name = param.name
data.username = param.username
data.password = param.password
data.email = param.email
data.role = param.role
data.roles = param.roles
data.status = param.status
await userRepository.save(data);
await repo.save(data);
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_update, data);
} else {
@ -213,11 +195,12 @@ export class UserController {
static async delete(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
description: 'User role ID.',
required: true,
type: 'uuid'
type: 'string'
}
*/
try {
@ -225,11 +208,11 @@ export class UserController {
id: Joi.string().uuid().required().label('ID')
});
const param: User = await schema.validateAsync(req.params);
const param: UserRole = await schema.validateAsync(req.params);
const userRepository = OrmHelper.DB.getRepository(User);
const repo = OrmHelper.DB.getRepository(UserRole);
const affected = (await userRepository.softDelete({ id: param.id })).affected;
const affected = (await repo.softDelete({ id: param.id })).affected;
if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_delete, {});
@ -246,11 +229,12 @@ export class UserController {
static async restore(req: Request, res: Response, next: NextFunction): Promise<Response> {
/*
#swagger.tags = ['User Roles']
#swagger.parameters['id'] = {
in: 'path',
description: 'User ID.',
description: 'User role ID.',
required: true,
type: 'uuid'
type: 'string'
}
*/
try {
@ -258,11 +242,11 @@ export class UserController {
id: Joi.string().uuid().required().label('ID')
});
const param: User = await schema.validateAsync(req.params);
const param: UserRole = await schema.validateAsync(req.params);
const userRepository = OrmHelper.DB.getRepository(User);
const repo = OrmHelper.DB.getRepository(UserRole);
const affected = (await userRepository.restore({ id: param.id })).affected;
const affected = (await repo.restore({ id: param.id })).affected;
if (affected > 0) {
return ReturnHelper.successResponseAny(res, 200, Language.lang.success_restore, {});