pcpuma_unam_api/src/auth/auth.service.ts

import {
  BadRequestException,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Operador } from '../operador/entity/operador.entity';
import { Usuario } from '../usuario/entity/usuario.entity';
import { BcryptService } from '../bcrypt/bcrypt.service';
import { ModuloService } from '../modulo/modulo.service';
import { OperadorService } from '../operador/operador.service';
import { UsuarioService } from '../usuario/usuario.service';
import { JwtPayloadAdmin } from './dto/jwt-payload-admin';
import { JwtPayloadOperador } from './dto/jwt-payload-operador';
import { JwtPayloadUsuario } from './dto/jwt-payload-usuario';

@Injectable()
export class AuthService {
  constructor(
    private bcryptService: BcryptService,
    private jwtService: JwtService,
    private moduloService: ModuloService,
    private operadorService: OperadorService,
    private usuarioService: UsuarioService,
  ) {}

  loginAdmin(admin: string, password: string): Promise<{ token: string }> {
    return this.operadorService.findAdmin(admin).then((admin) => {
      this.validacionBasica(admin, password);
      this.validacionOperador(admin);

      // Creamos payload apartir de la interface que le corresponde a este tipo de usaurio
      const JwtPayload: JwtPayloadAdmin = {
        Operador: {
          id_operador: admin.id_operador,
          operador: admin.operador,
          nombre: admin.nombre,
          tipoUsuario: { id_tipo_usuario: admin.tipoUsuario.id_tipo_usuario },
        },
      };

      // Los super admin y sistema no tienen institución
      if (JwtPayload.Operador.tipoUsuario.id_tipo_usuario === 3)
        JwtPayload.Operador.institucion = {
          id_institucion: admin.institucion.id_institucion,
          logo: admin.institucion.logo,
        };
      return { token: this.jwtService.sign(JwtPayload) }; // "Firmamos"/creamos el token
    });
  }

  async loginOperador(
    id_modulo: number,
    operador: string,
    password: string,
  ): Promise<{ token: string }> {
    const modulo = await this.moduloService.findById(id_modulo);

    return this.operadorService
      .findOperador(modulo.institucion, operador)
      .then((operador) => {
        this.validacionBasica(operador, password);
        this.validacionOperador(operador);

        // Creamos payload apartir de la interface que le corresponde a este tipo de usaurio
        const JwtPayload: JwtPayloadOperador = {
          Operador: {
            id_operador: operador.id_operador,
            operador: operador.operador,
            nombre: operador.nombre,
            institucion: {
              id_institucion: operador.institucion.id_institucion,
              logo: operador.institucion.logo,
            },
            tipoUsuario: {
              id_tipo_usuario: operador.tipoUsuario.id_tipo_usuario,
            },
          },
          Modulo: { id_modulo: modulo.id_modulo },
        };

        return { token: this.jwtService.sign(JwtPayload) }; // "Firmamos"/creamos el token
      });
  }

  loginUsuario(usuario: string, password: string): Promise<{ token: string }> {
    return this.usuarioService.findByUsuario(usuario).then((usuario) => {
      // Validamos que este registrado. Sin password = no registrado
      if (usuario && !usuario.password)
        throw new BadRequestException('Este usuario no ha sido registrado.');
      this.validacionBasica(usuario, password);

      // Creamos payload apartir de la interface que le corresponde a este tipo de usaurio
      const JwtPayload: JwtPayloadUsuario = {
        Usuario: {
          id_usuario: usuario.id_usuario,
          usuario: usuario.usuario,
          nombre: usuario.nombre,
          tipoUsuario: {
            id_tipo_usuario: usuario.tipoUsuario.id_tipo_usuario,
          },
        },
      };

      return { token: this.jwtService.sign(JwtPayload) }; // "Firmamos"/creamos el token
    });
  }

  private validacionBasica(
    operadorUsuario: Operador | Usuario,
    password: string,
  ): void {
    // Validamos que el operador o usuario existan y que el password que se envió coincida con el de la db
    if (
      !operadorUsuario ||
      !this.bcryptService.comparar(password, operadorUsuario.password)
    )
      throw new BadRequestException(
        'Usuario y/o password incorrectos, ingresa unas credenciales válidas.',
      );
    return;
  }

  private validacionOperador(operador: Operador): void {
    // Validamos que la cuenta del operador esta activa
    if (!operador.activo)
      throw new UnauthorizedException('Esta cuenta se encuentra desactivada.');
    return;
  }
}