import { pool } from '../config/database.js';
import { User, CreateUserRequest, UpdateUserRequest, UserResponse } from '../models/User.js';
import { $log } from '@tsed/logger';
import bcrypt from 'bcryptjs';
import { randomUUID } from 'crypto';
export class UserService {
async createUser(userData: CreateUserRequest): Promise<UserResponse> {
const connection = await pool.getConnection();
try {
// Check if user already exists
const [existingUsers] = await connection.execute(
'SELECT id FROM users WHERE email = ? AND deleted_at IS NULL',
[userData.email]
);
if (Array.isArray(existingUsers) && existingUsers.length > 0) {
throw new Error('User with this email already exists');
}
// Hash password
const password_hash = await bcrypt.hash(userData.password, 10);
// Generate UUID for user ID
const userId = randomUUID();
// Insert user
const [result] = await connection.execute(
`INSERT INTO users (id, email, password_hash, first_name, last_name, role, company_name, is_active, email_verified_at, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, NOW(), NOW(), NOW())`,
[
userId,
userData.email,
password_hash,
userData.first_name,
userData.last_name,
userData.role || 'recruiter',
userData.company_name || null,
true
]
);
// Get the created user
const user = await this.getUserById(userId);
if (!user) {
throw new Error('Failed to create user');
}
return this.mapUserToResponse(user);
} catch (error) {
$log.error('Error creating user:', error);
throw error;
} finally {
connection.release();
}
}
async getUserByEmail(email: string): Promise<User | null> {
const connection = await pool.getConnection();
try {
const [rows] = await connection.execute(
'SELECT * FROM users WHERE email = ? AND deleted_at IS NULL',
[email]
);
if (Array.isArray(rows) && rows.length > 0) {
return rows[0] as User;
}
return null;
} catch (error) {
$log.error('Error getting user by email:', error);
throw error;
} finally {
connection.release();
}
}
async getUserById(id: string): Promise<User | null> {
const connection = await pool.getConnection();
try {
const [rows] = await connection.execute(
'SELECT * FROM users WHERE id = ? AND deleted_at IS NULL',
[id]
);
if (Array.isArray(rows) && rows.length > 0) {
return rows[0] as User;
}
return null;
} catch (error) {
$log.error('Error getting user by ID:', error);
throw error;
} finally {
connection.release();
}
}
async updateUser(id: string, userData: UpdateUserRequest): Promise<UserResponse | null> {
const connection = await pool.getConnection();
try {
const updateFields = [];
const values = [];
if (userData.first_name) {
updateFields.push('first_name = ?');
values.push(userData.first_name);
}
if (userData.last_name) {
updateFields.push('last_name = ?');
values.push(userData.last_name);
}
if (userData.company_name !== undefined) {
updateFields.push('company_name = ?');
values.push(userData.company_name);
}
if (userData.avatar_url !== undefined) {
updateFields.push('avatar_url = ?');
values.push(userData.avatar_url);
}
if (userData.is_active !== undefined) {
updateFields.push('is_active = ?');
values.push(userData.is_active);
}
if (updateFields.length === 0) {
throw new Error('No fields to update');
}
updateFields.push('updated_at = NOW()');
values.push(id);
await connection.execute(
`UPDATE users SET ${updateFields.join(', ')} WHERE id = ? AND deleted_at IS NULL`,
values
);
const user = await this.getUserById(id);
return user ? this.mapUserToResponse(user) : null;
} catch (error) {
$log.error('Error updating user:', error);
throw error;
} finally {
connection.release();
}
}
async updateLastLogin(id: string): Promise<void> {
const connection = await pool.getConnection();
try {
await connection.execute(
'UPDATE users SET last_login_at = NOW(), updated_at = NOW() WHERE id = ? AND deleted_at IS NULL',
[id]
);
} catch (error) {
$log.error('Error updating last login:', error);
throw error;
} finally {
connection.release();
}
}
async verifyPassword(user: User, password: string): Promise<boolean> {
return await bcrypt.compare(password, user.password_hash);
}
async changePassword(id: string, newPassword: string): Promise<void> {
const connection = await pool.getConnection();
try {
const password_hash = await bcrypt.hash(newPassword, 10);
await connection.execute(
'UPDATE users SET password_hash = ?, updated_at = NOW() WHERE id = ? AND deleted_at IS NULL',
[password_hash, id]
);
} catch (error) {
$log.error('Error changing password:', error);
throw error;
} finally {
connection.release();
}
}
async softDeleteUser(id: string): Promise<void> {
const connection = await pool.getConnection();
try {
await connection.execute(
'UPDATE users SET deleted_at = NOW(), is_active = FALSE, updated_at = NOW() WHERE id = ? AND deleted_at IS NULL',
[id]
);
} catch (error) {
$log.error('Error soft deleting user:', error);
throw error;
} finally {
connection.release();
}
}
/**
* Get user payment history
*/
async getUserPaymentHistory(userId: string): Promise<any[]> {
const connection = await pool.getConnection();
try {
const [rows] = await connection.execute(`
SELECT
pr.*,
tp.name as package_name
FROM payment_records pr
LEFT JOIN token_packages tp ON pr.token_package_id = tp.id
WHERE pr.user_id = ?
ORDER BY pr.created_at DESC
`, [userId]);
return Array.isArray(rows) ? rows : [];
} catch (error) {
$log.error('Error getting user payment history:', error);
throw error;
} finally {
connection.release();
}
}
/**
* Get user by Stripe customer ID
*/
async getUserByStripeCustomerId(stripeCustomerId: string): Promise<User | null> {
const connection = await pool.getConnection();
try {
const [rows] = await connection.execute(
'SELECT * FROM users WHERE stripe_customer_id = ? AND deleted_at IS NULL',
[stripeCustomerId]
);
if (Array.isArray(rows) && rows.length > 0) {
return rows[0] as User;
}
return null;
} catch (error) {
$log.error('Error getting user by Stripe customer ID:', error);
throw error;
} finally {
connection.release();
}
}
/**
* Update user's Stripe customer ID
*/
async updateUserStripeCustomerId(userId: string, stripeCustomerId: string): Promise<void> {
const connection = await pool.getConnection();
try {
await connection.execute(
'UPDATE users SET stripe_customer_id = ?, updated_at = NOW() WHERE id = ?',
[stripeCustomerId, userId]
);
$log.info(`Updated Stripe customer ID for user: ${userId}`);
} catch (error) {
$log.error('Error updating user Stripe customer ID:', error);
throw error;
} finally {
connection.release();
}
}
/**
* Get user payment statistics
*/
async getUserPaymentStatistics(userId: string): Promise<{
totalSpent: number;
totalPayments: number;
averagePaymentValue: number;
lastPaymentDate: string | null;
}> {
const connection = await pool.getConnection();
try {
const [rows] = await connection.execute(`
SELECT
COUNT(*) as total_payments,
SUM(CASE WHEN status = 'paid' THEN amount ELSE 0 END) as total_spent,
AVG(CASE WHEN status = 'paid' THEN amount ELSE NULL END) as avg_payment_value,
MAX(CASE WHEN status = 'paid' THEN paid_at ELSE NULL END) as last_payment_date
FROM payment_records
WHERE user_id = ?
`, [userId]);
const stats = Array.isArray(rows) ? rows[0] as any : {};
return {
totalSpent: stats.total_spent || 0,
totalPayments: stats.total_payments || 0,
averagePaymentValue: stats.avg_payment_value || 0,
lastPaymentDate: stats.last_payment_date || null,
};
} catch (error) {
$log.error('Error getting user payment statistics:', error);
throw error;
} finally {
connection.release();
}
}
private mapUserToResponse(user: User): UserResponse {
return {
id: user.id,
email: user.email,
first_name: user.first_name,
last_name: user.last_name,
role: user.role,
company_name: user.company_name,
avatar_url: user.avatar_url,
is_active: user.is_active,
last_login_at: user.last_login_at,
email_verified_at: user.email_verified_at,
created_at: user.created_at,
updated_at: user.updated_at
};
}
}
Reference in New Issue View Git Blame Copy Permalink