backend-service/src/core/service/user.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from '../entity/user.entity';
import { Repository } from 'typeorm';
import * as bcrypt from 'bcryptjs';
import { SearchUserFilter } from '../dto/search-user.filter';
import { JwtPayload } from 'jsonwebtoken';
import { CreateUserRequest } from '../dto/create-user.request';
import { UpdateUserRequest } from '../dto/update-user.request';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User) private readonly userRepository: Repository<User>,
  ) {}

  private currentUser: User;

  setCurrentUser(user: User) {
    this.currentUser = user;
  }

  getCurrentUser() {
    return this.currentUser;
  }

  async setCurrentUserByJwtPayload(payload: JwtPayload) {
    const user = await this.userRepository.findOneBy({ id: payload.sub });
    this.setCurrentUser(user);
  }

  async findById(id: string) {
    return this.userRepository.findOne({
      where: {
        id,
      },
    });
  }

  async findByUserName(username: string) {
    return this.userRepository.findOne({
      where: {
        username,
      },
    });
  }

  async createInitialUser() {
    try {
      const existingUser = await this.userRepository.findOne({
        where: { username: 'admin' },
      });
      if (!existingUser) {
        const salt = await bcrypt.genSalt();
        const encryptedPassword = await bcrypt.hash('admin123', salt);

        const user = this.userRepository.create({
          username: 'admin',
          encryptedPassword,
          locked: false,
          enabled: true,
        });

        await this.userRepository.save(user);
        console.log('Initial admin user created');
      } else {
        console.log('Admin user already exists');
      }
    } catch (error) {
      console.log('Error creating initial user', error);
    }
  }

  async search(searchUserFilter: SearchUserFilter) {
    return this.userRepository.findAndCount({
      where: searchUserFilter.getConditions(),
      skip: searchUserFilter.getSkip(),
      take: searchUserFilter.getSize(),
    });
  }

  async create(createUserRequest: CreateUserRequest) {
    const user = new User();
    user.username = createUserRequest.username;
    const salt = await bcrypt.genSalt();
    user.encryptedPassword = await bcrypt.hash('admin123', salt);
    return this.userRepository.save(user);
  }

  async update(id: string, updateUserRequest: UpdateUserRequest) {
    const user = await this.findById(id);
    user.trueName = updateUserRequest.trueName;
    user.age = updateUserRequest.age;
    user.gender = updateUserRequest.gender;
    user.avatar = updateUserRequest.avatar;
    user.occupation = updateUserRequest.occupation;
    user.address = updateUserRequest.address;
    return this.userRepository.save(user);
  }

  async updateCurrentUser(updateUserRequest: UpdateUserRequest) {
    return this.update(this.currentUser.id, updateUserRequest);
  }
}