| System: Linux srv913213 5.15.0-190-generic #200-Ubuntu SMP Fri Aug 7 15:06:04 UTC 2026 x86_64 Current Path : /var/www/talentgenesis_admin_backend/src/admin/user/ |
| Current File : /var/www/talentgenesis_admin_backend/src/admin/user/user.service.ts |
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { CreateUserDto, UpdateStatusUserDto, UpdateUserDto } from './dto/user.dto';
import { Users } from './entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Brackets, MoreThan, Not, Repository } from 'typeorm';
import * as bcrypt from 'bcryptjs'
import { Role } from '../role/entities/role.entity';
import { LoggerService } from 'src/logger/logger.service';
import { MailerService } from 'src/shared/mailer/mailer.service';
import { JwtService } from '@nestjs/jwt';
import * as jwt from 'jsonwebtoken';
import { CryptoService } from 'src/aesEncrypt/aes-service';
import { ConfigService } from '@nestjs/config';
@Injectable()
export class UserService {
constructor(
@InjectRepository(Users) private readonly userRepository: Repository<Users>,
@InjectRepository(Role) private roleRepository: Repository<Role>,
private loggerService: LoggerService,
private readonly mailerService: MailerService,
private readonly jwtService: JwtService,
private cryptoService: CryptoService,
private configService: ConfigService,
) { }
async create({ email, password, name, phone, roleId }: CreateUserDto, req: Request) {
const emailDec = await this.cryptoService.newdecrypt(email)
const phoneDec = await this.cryptoService.newdecrypt(phone)
const passwordDec = await this.cryptoService.newdecrypt(password)
if (phoneDec.length) {
const checkMobile = /^(?:(?:\+|0{0,2})91(\s*[\-]\s*)?|[0]?)?[7896]\d{9}$/.test(phoneDec)
if (!checkMobile) {
return ({
status: false,
statusCode: 409,
message: "Please provide the valid mobile number"
})
}
}
if (emailDec.length) {
const checkEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(emailDec);
if (!checkEmail) {
return ({
status: false,
statusCode: 409,
message: "Please provide the valid email id"
})
}
}
try {
const userExists = await this.userRepository.find({
where: {
email,
isDeleted: false
}
});
const mobileExists = await this.userRepository.find({
where: {
mobileNo: phone,
isDeleted: false
}
});
if (mobileExists.length) {
return ({
status: false,
statusCode: 409,
message: "Mobile No already exists"
})
}
if (userExists.length) {
return ({
status: false,
statusCode: 409,
message: "Email id already exists"
})
}
let user = new Users();
user.name = name;
user.password = password;
user.email = email;
user.mobileNo = phone;
if (roleId) {
user.role = await this.roleRepository.findOne({
where: { id: roleId, }
});
}
const createUser = await this.userRepository.save(user)
if (createUser) {
const token = jwt.sign(
{
email: emailDec,
},
process.env.JSON_TOKEN_KEY,
{
expiresIn: '15m',
},
);
var link = "https://admin.truefee.in/reset-password/" + encodeURIComponent(token);
return await this.userCreate(name, emailDec, passwordDec, link, req);
}
} catch (error) {
throw new HttpException(error, HttpStatus.BAD_REQUEST);
}
}
private async userCreate(name, email, password, link, req) {
try {
const afterSend = await this.mailerService.sendMail({
mailto: 'User Onboarded in True Fee',
to: email,
from: this.configService.get<string>('EMAIL_AUTH_USER'),
subject: 'User Onboarded in True Fee ✔',
text: 'User Onboarded in True Fee !',
template: 'userRegister',
context: {
title: 'User Onboarded in True Fee!',
name: name.charAt(0).toUpperCase() + name.slice(1),
siteUrl: "https://admin.truefee.in",
click: link,
LoginId: email,
Password: password,
websiteurl: "https://admin.truefee.in"
},
});
if (afterSend.response) {
const data = {
module: 'User',
data: this.cryptoService.newencrypt(req['user'].user_email),
activityType: 2,
message: 'User onboarded in True Fee successfully',
request: req,
createdBy: req['user'].role_name
};
const logger = await this.loggerService.success(data);
return {
status: true,
message: 'User details created successfully',
data: [],
};
}
} catch (err) {
return {
status: false,
message: 'User details created Failed',
data: [],
};
}
}
async findAllUsers(offset, limit, sortByKey, sortByType, searchWith, request) {
const validSortOrders = ['ASC', 'DESC'];
const sortOrderToUse = validSortOrders.includes(sortByType) ? sortByType : "DESC" as "ASC" | "DESC";
var queryBuilder = this.userRepository.createQueryBuilder('users')
.leftJoinAndSelect("users.role", "r")
.where("users.status != :status", { status: 2 })
.andWhere("users.role_id > :id", { id: 1 })
.andWhere("users.isDeleted = :isDeleted", { isDeleted: 0 })
const dataRes = await queryBuilder.getMany();
let sortedUsers = [];
let decryptedValue = '';
if (['email', 'name', 'role_name'].includes(sortByKey)) {
sortedUsers = dataRes.map(item => {
if (sortByKey === "name") {
decryptedValue = item.name ? this.cryptoService.newdecrypt(item.name) : '';
} else if (sortByKey === "role_name") {
decryptedValue = item.role.name ? this.cryptoService.newdecrypt(item.role.name) : '';
} else if (sortByKey === "email") {
decryptedValue = sortOrderToUse === "DESC" || "ASC" ? this.cryptoService.newdecrypt(item.email) : "";
}
return {
...item,
[sortByKey]: decryptedValue,
};
});
sortByKey = sortByKey;
} else {
sortedUsers = [...dataRes];
sortByKey = 'id';
}
sortedUsers.sort((a, b) => {
const valueA = a[sortByKey];
const valueB = b[sortByKey];
if (valueA === undefined || valueB === undefined) {
return 0;
}
if (valueA < valueB) {
return sortOrderToUse === "ASC" ? -1 : 1;
}
if (valueA > valueB) {
return sortOrderToUse === "ASC" ? 1 : -1;
}
return 0;
});
const transfers = sortedUsers.filter((data) => {
const decryptedName = data.name ? this.cryptoService.newdecrypt(data.name) : '';
const decryptedEmail = data.email ? this.cryptoService.newdecrypt(data.email) : '';
const decryptedMobile = data.mobileNo ? this.cryptoService.newdecrypt(data.mobileNo) : '';
const decryptedRole = data.role.name ? this.cryptoService.newdecrypt(data.role.name) : '';
const nameMatches = decryptedName.toLowerCase().includes(searchWith.toLowerCase());
const emailMatches = decryptedEmail.toLowerCase().includes(searchWith.toLowerCase());
const roleMatches = decryptedRole.toLowerCase().includes(searchWith.toLowerCase());
const mobileMatches = decryptedMobile.toLowerCase().includes(searchWith.toLowerCase());
return nameMatches || emailMatches || roleMatches || mobileMatches;
})
const pagenationData = transfers.slice((offset - 1) * limit, offset * limit);
const count = pagenationData.length
const totalPages = Math.ceil(transfers.length / limit);
if (pagenationData.length) {
const jsonString = JSON.stringify(transfers)
const result = this.cryptoService.newencrypt(jsonString)
return {
status: true,
data: pagenationData,
count: count,
totalPages: totalPages
};
}
return {
status: false,
message: "Data not found",
data: [],
};
}
async findOne(id: number, req: Request) {
const users = await this.userRepository.find({
where: { id: id, isDeleted: false },
relations: ['role'],
});
if (!users.length) {
const data = {
module: 'User',
data: 'not found',
activityType: 2,
message: 'User Not Found',
request: req,
createdBy: req['user'].role_name
};
const logger = await this.loggerService.warning(data);
return {
status: false,
message: 'User Not Found',
data: [],
};
}
const emailDec = await this.cryptoService.newdecrypt(users[0].email)
return {
status: true,
message: 'User details viewed successfully',
data: users,
};
}
async update(
{ id, name, email, roleId, phone }: UpdateUserDto,
req: Request,
) {
const emailDec = await this.cryptoService.newdecrypt(email)
const phoneDec = await this.cryptoService.newdecrypt(phone)
try {
if (emailDec.length) {
const checkEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(emailDec);
if (!checkEmail) {
return ({
status: false,
statusCode: 409,
message: "Please provide the valid email id"
})
}
}
if (phoneDec.length) {
const checkMobile = /^(?:(?:\+|0{0,2})91(\s*[\-]\s*)?|[0]?)?[7896]\d{9}$/.test(phoneDec)
if (!checkMobile) {
return ({
status: false,
statusCode: 409,
message: "Please provide the valid mobile number"
})
}
}
const user = await this.userRepository.findOneBy({
id: id,
isDeleted: false,
});
if (!user) {
const data = {
module: 'User',
data: 'not found',
activityType: 2,
message: 'User Not Found',
createdBy: req['user'].role_name
};
const logger = await this.loggerService.warning(data);
return {
status: false,
message: 'User Not Found',
data: [],
};
}
const emailCheck = await this.userRepository.findOne({
where: { email: emailDec, isDeleted: false, id: Not(id) },
});
const mobileCheck = await this.userRepository.findOne({
where: { mobileNo: phoneDec, isDeleted: false, id: Not(id) },
});
if (mobileCheck) {
const data = {
module: 'User',
data: name,
activityType: 2,
message: 'Mobile Number already exists',
request: req,
createdBy: req['user'].role_name
};
const logger = await this.loggerService.warning(data);
return {
status: false,
message: 'Mobile Number already exists',
data: [],
};
}
if (emailCheck) {
const data = {
module: 'User',
data: name,
activityType: 2,
message: 'Email already exists',
request: req,
createdBy: req['user'].role_name
};
const logger = await this.loggerService.warning(data);
return {
status: false,
message: 'Email id already exists',
data: [],
};
}
user.name = name;
user.email = email;
user.mobileNo = phone;
user.role = await this.roleRepository.findOne({
where: { id: roleId },
});
const result = await this.userRepository.save(user);
if (result) {
const updateToken = await this.userRepository.update(
{ id: +result.id },
{
refreshToken: null,
accessToken: null
},
);
const data = {
module: 'User',
data: this.cryptoService.newencrypt(req['user'].user_email),
activityType: 2,
message: 'User details updated successfully',
request: req,
createdBy: req['user'].role_name
};
const logger = await this.loggerService.success(data);
return {
status: true,
message: 'User details updated successfully',
data: [],
};
}
} catch (error) {
throw new HttpException(error, HttpStatus.BAD_REQUEST);
}
}
async updateStatus({ status, id }: UpdateStatusUserDto, req: Request) {
try {
const existingUser = await this.userRepository.find({
where: {
id: id,
},
});
if (!existingUser.length) {
const data = {
module: "User",
data: "not found",
activityType: 2,
message: "User Not Found",
request: req,
createdBy: req['user'].role_name
}
const logger = await this.loggerService.warning(data);
return ({
status: false,
message: "User Not Found",
data: []
})
}
if (status == 1) {
const updatedUser = await this.userRepository.update({ id: id }, { status: status });
if (updatedUser.affected) {
const data = {
module: "User",
data: this.cryptoService.newencrypt(req['user'].user_email),
activityType: 2,
message: existingUser[0].name + " " + "This user Activated Successfully",
request: req,
createdBy: req['user'].role_name
}
const logger = await this.loggerService.success(data);
return ({
status: true,
successCode: 200,
message: "User Activated Successfully",
data: []
})
}
} else {
const updatedUser = await this.userRepository.update({ id: id }, { status: status, accessToken: null, refreshToken: null });
if (updatedUser.affected) {
const data = {
module: "User",
data: this.cryptoService.newencrypt(req['user'].user_email),
activityType: 2,
message: existingUser[0].name + " " + "This user Inactivated Successfully",
request: req,
createdBy: req['user'].role_name
}
const logger = await this.loggerService.success(data);
return ({
status: true,
successCode: 200,
message: "User Inactivated Successfully",
data: []
})
}
}
} catch (error) {
const data = {
module: "User",
data: "update call ",
activityType: 2,
message: "Something Wrong",
error: error,
request: req
}
const logger = await this.loggerService.errorMsg(data);
throw new HttpException(error, HttpStatus.BAD_REQUEST);
}
}
async remove(id: number, req: Request) {
try {
const existinguser = await this.userRepository.find({
where: {
id: id, isDeleted: false
},
});
if (!existinguser.length) {
const data = {
module: "user",
data: "not found",
activityType: 2,
message: "user Not Found",
request: req,
createdBy: req['user'].role_name
}
const logger = await this.loggerService.warning(data);
return ({
status: false,
message: "user Not Found",
data: []
})
}
const deleteuser = await this.userRepository.update({ id: id }, { isDeleted: true, accessToken: null, refreshToken: null });
if (deleteuser.affected) {
const data = {
module: "User",
data: this.cryptoService.newencrypt(req['user'].user_email),
activityType: 2,
message: existinguser[0].name + " " + "This user Deleted successfully",
request: req,
createdBy: req['user'].role_name
}
const logger = await this.loggerService.success(data);
return ({
status: true,
message: "User Deleted Successfully",
data: []
})
}
} catch (error) {
const data = {
module: "user",
data: "list call ",
activityType: 2,
message: "Something Wrong",
error: error
}
const logger = await this.loggerService.errorMsg(data);
throw new HttpException(error, HttpStatus.BAD_REQUEST);
}
}
}