api_directorio/src/auth/auth.service.ts

import {
  HttpException,
  Inject,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
import { UsersService } from '../users/users.service';
import { JwtService } from '@nestjs/jwt';
import { registerDto } from './dto/registerDto.dto';
import { User } from 'src/users/entities/user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { hash } from 'bcrypt';
import { compare } from 'bcryptjs';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService,
    private configService: ConfigService,
    @InjectRepository(User) private userRepository: Repository<User>,
  ) {}

  //register users
  async register(data: registerDto) {
    const { usuario, contraseña} = data;

    if (await this.usersService.findOne(usuario)) {
      throw new HttpException('User already exist', 403);
    }

    const hashedpassword = await hash(contraseña, 10);

    data = { ...data, contraseña: hashedpassword };
    return this.userRepository.save(this.userRepository.create(data));
  }

  //singin
  async signIn(data: registerDto) {
    const { usuario, contraseña } = data;
    const user = await this.usersService.findOne(usuario);
    if (!user) {
      throw new UnauthorizedException('Invalid name');
    }

    const checkPassword = await compare(contraseña, user.contraseña);
    if (!checkPassword) {
      throw new UnauthorizedException('Invalid password');
    }

    const payload = {
      id_usuario: user.id_usuario,
      usuario: user.usuario,
      id_tipo_usuario: user.id_tipo_usuario,
    };
    const token = this.jwtService.sign(payload);

    await this.usersService.updateTokenAndDates(
      user.id_usuario,
      token,
      new Date(),
      new Date(Date.now() + 3600 * 1000),
    );

    return { token: token };
  }

  //update user
  async update(userId, data:registerDto) {

    const{contraseña}=data;

    if(contraseña){
      const hashedpassword = await hash(contraseña, 10);
      data = {...data,contraseña:hashedpassword};
    }

    return await this.userRepository.update(userId, data);
  }

  async remove(userId: number): Promise<void> {
    await this.userRepository.delete(userId);
  }

  //validate tojen of users
  async validateToken(token: string): Promise<User> {
    try {
      const decoded = this.jwtService.verify(token, {
        secret: this.configService.get<string>('JWT_SECRET'),
      });

      //verify JWT's username with DB's username
      const user = await this.usersService.findOne(decoded.username);
      if (!user) {
        throw new UnauthorizedException('Invalid token');
      }

      //verify JWT hasn't expired
      const currentTime = Math.floor(Date.now() / 1000);
      if (decoded.exp < currentTime) {
        throw new UnauthorizedException('Token has expired');
      }

      return user;
    } catch (error) {
      throw new UnauthorizedException('validation token failed');
    }
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async findAllPaginated(
    page: number,
    limit: number,
    filters: any
  ): Promise<{ usuarios: User[], total: number, totalPages: number }> {
    const query = this.userRepository.createQueryBuilder('usuario');

    if (filters.nombre) {
      query.andWhere('usuario.nombre LIKE :nombre', { nombre: `%${filters.nombre}%` });
    }

    if (filters.id_tipo_usuario) {
      query.andWhere('usuario.id_tipo_usuario = :id_tipo_usuario', { id_tipo_usuario: filters.id_tipo_usuario });
    }

    const [usuarios, total] = await query
      .skip((page - 1) * limit)
      .take(limit)
      .orderBy('usuario.nombre', 'ASC')
      .getManyAndCount();

    const totalPages = Math.ceil(total / limit);

    return { usuarios, total, totalPages };
  }

  async profile(id_usuario: number) {
    const user = await this.userRepository.findOne({
      where: { id_usuario },
    });
    
    if (!user) {
      throw new HttpException('user not found', 404);
    }

    return user;
  }
}