mini-starter/src/server/modules/users/user.service.ts

import { HTTPException } from 'hono/http-exception'
import { DataSource } from 'typeorm';
import { UserEntity as User } from './user.entity';
import * as bcrypt from 'bcrypt';
import { Repository } from 'typeorm';
import { Role } from './role.entity';

const SALT_ROUNDS = 10;

export class UserService {
  private userRepository: Repository<User>;
  private roleRepository: Repository<Role>;
  private readonly dataSource: DataSource;

  constructor(dataSource: DataSource) {
    this.dataSource = dataSource;
    this.userRepository = this.dataSource.getRepository(User);
    this.roleRepository = this.dataSource.getRepository(Role);
  }

  async createUser(userData: Partial<User>): Promise<User> {
    try {
      if (userData.password) {
        userData.password = await bcrypt.hash(userData.password, SALT_ROUNDS);
      }
      const user = this.userRepository.create(userData);
      return await this.userRepository.save(user);
    } catch (error) {
      console.error('Error creating user:', error);
      throw new HTTPException(400,{ message: 'Failed to create user', cause: error})
    }
  }

  async getUserById(id: number): Promise<User | null> {
    try {
      return await this.userRepository.findOne({ 
        where: { id },
        relations: ['roles']
      });
    } catch (error) {
      console.error('Error getting user:', error);
      throw new Error('Failed to get user');
    }
  }

  async getUserByUsername(username: string): Promise<User | null> {
    try {
      return await this.userRepository.findOne({
        where: { username },
        relations: ['roles']
      });
    } catch (error) {
      console.error('Error getting user:', error);
      throw new Error('Failed to get user');
    }
  }

  async getUserByPhone(phone: string): Promise<User | null> {
    try {
      return await this.userRepository.findOne({
        where: { phone: phone },
        relations: ['roles']
      });
    } catch (error) {
      console.error('Error getting user by phone:', error);
      throw new Error('Failed to get user by phone');
    }
  }

  async updateUser(id: number, updateData: Partial<User>): Promise<User | null> {
    try {
      if (updateData.password) {
        updateData.password = await bcrypt.hash(updateData.password, SALT_ROUNDS);
      }
      await this.userRepository.update(id, updateData);
      return this.getUserById(id);
    } catch (error) {
      console.error('Error updating user:', error);
      throw new Error('Failed to update user');
    }
  }

  async deleteUser(id: number): Promise<void> {
    try {
      await this.userRepository.delete(id);
    } catch (error) {
      console.error('Error deleting user:', error);
      throw new Error('Failed to delete user');
    }
  }

  async getUsersWithPagination(params: {
    page: number;
    pageSize: number;
    keyword?: string;
  }): Promise<[User[], number]> {
    try {
      const { page, pageSize, keyword } = params;
      const skip = (page - 1) * pageSize;
      
      const queryBuilder = this.userRepository
        .createQueryBuilder('user')
        .leftJoinAndSelect('user.roles', 'roles')
        .skip(skip)
        .take(pageSize);

      if (keyword) {
        queryBuilder.where(
          'user.username LIKE :keyword OR user.nickname LIKE :keyword OR user.phone LIKE :keyword',
          { keyword: `%${keyword}%` }
        );
      }

      return await queryBuilder.getManyAndCount();
    } catch (error) {
      console.error('Error getting users with pagination:', error);
      throw new Error('Failed to get users');
    }
  }

  async verifyPassword(user: User, password: string): Promise<boolean> {
    return password === user.password || bcrypt.compare(password, user.password)
  }

  async assignRoles(userId: number, roleIds: number[]): Promise<User | null> {
    try {
      const user = await this.getUserById(userId);
      if (!user) return null;

      const roles = await this.roleRepository.findByIds(roleIds);
      user.roles = roles;
      return await this.userRepository.save(user);
    } catch (error) {
      console.error('Error assigning roles:', error);
      throw new Error('Failed to assign roles');
    }
  }

  async getUsers(): Promise<User[]> {
    try {
      const users = await this.userRepository.find({
        relations: ['roles']
      });
      return users;
    } catch (error) {
      console.error('Error getting users:', error);
      throw new HTTPException(500, { message: 'Failed to get users', cause: error })
    }
  }


  getUserRepository(): Repository<User> {
    return this.userRepository;
  }

  async getUserByAccount(account: string): Promise<User | null> {
    try {
      return await this.userRepository.findOne({
        where: [{ username: account }, { email: account }],
        relations: ['roles']
      });
    } catch (error) {
      console.error('Error getting user by account:', error);
      throw new Error('Failed to get user by account');
    }
  }
}