api_directorio/src/Profesor/profesor.service.ts

import { HttpException, Injectable } from '@nestjs/common';
import { Profesor } from './entities/profesor.entity';
import { DatosAcademicosService } from '../datos_academicos/datos_academicos.service';
import { LineasInvestigacionService } from '../lineas_investigacion/lineas_investigacion.service';
import { ProyectosAcademicosService } from '../proyectos_academicos/proyectos_academicos.service';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { profesorDto } from './dto/profesorDto.dto';

@Injectable()
export class ProfesorService {
  constructor(
    @InjectRepository(Profesor) private profesorRepository: Repository<Profesor>,
    private datosAcademicosService: DatosAcademicosService,
    private lineasInvestigacionService: LineasInvestigacionService,
    private proyectosAcademicosService: ProyectosAcademicosService,
  ) {}

  //register teacher
  async register(data: profesorDto) {
    const {num_trabajador,rfc } = data;

    const existrfc = await this.profesorRepository.findOne({where:{rfc}});
    if(existrfc){
      throw new HttpException('rfc already exist', 403);
    }

    const existnumber = await this.profesorRepository.findOne({where:{num_trabajador}});
    if(existnumber){
      throw new HttpException('number of worker already exist', 403);
    }

    const newProfesor = this.profesorRepository.create(data);
    return this.profesorRepository.save(newProfesor);
  }

  //brings all teachers
  async findAll(): Promise<Profesor[]> {
    return this.profesorRepository.find({
      order: {
        nombre: 'ASC',
      },
    });
  }

  //modify teacher
  async modify(id_profesor: number, data: profesorDto) {
    const profesor = await this.profesorRepository.findOne({ where: { id_profesor } });
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    Object.assign(profesor, data);
    return this.profesorRepository.save(profesor);
  }

  //remove teacher
  async remove(id_profesor: number) {
    const profesor = await this.profesorRepository.findOne({ where: { id_profesor }, relations: ['datosAcademicos'] });
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    // Delete related records in datos_academicos
    await this.datosAcademicosService.removeByProfesorId(id_profesor);
    await this.lineasInvestigacionService.removeByProfesorId(id_profesor);
    await this.proyectosAcademicosService.removeByProfesorId(id_profesor);

    await this.profesorRepository.remove(profesor);
    return { message: 'Profesor removed successfully' };
  }

  //brings teachers by id
  async profile(id_profesor: number) {
    const profesor = await this.profesorRepository.findOne({ where: { id_profesor } });
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    return profesor;
  }

  //brings teachers by filter
  async filter(filterDto: profesorDto): Promise<Profesor[]> {
    const query = this.profesorRepository.createQueryBuilder('profesor');

    if (filterDto.nombre) {
      query.andWhere('profesor.nombre like :nombre', { nombre: `%${filterDto.nombre}%` });
    }

    if (filterDto.id_categoria !== undefined) {
      query.andWhere('profesor.id_categoria = :id_categoria', { id_categoria: filterDto.id_categoria });
    }

    if (filterDto.extension) {
      query.andWhere('profesor.extension like :extension', { extension: `%${filterDto.extension}%` });
    }

    if (filterDto.id_adscripcion !== undefined) {
      query.andWhere('profesor.id_adscripcion = :id_adscripcion', { id_adscripcion: filterDto.id_adscripcion });
    }

    if (filterDto.id_edificio !== undefined) {
      query.andWhere('profesor.id_edificio = :id_edificio', { id_edificio: filterDto.id_edificio });
    }

    if (filterDto.activo !== undefined) {
      query.andWhere('profesor.activo = :activo', { activo: filterDto.activo });
    }

    return query.getMany();
  }

  async findAllPaginated(page: number, limit: number, filters: any): Promise<{ profesores: Profesor[], total: number, totalPages: number }> {
    const query = this.profesorRepository.createQueryBuilder('profesor');

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

    if (filters.adscripcion) {
      query.andWhere('profesor.adscripcion = :adscripcion', { adscripcion: filters.adscripcion });
    }

    if (filters.categoria) {
      query.andWhere('profesor.categoria = :categoria', { categoria: filters.categoria });
    }

    if (filters.edificio) {
      query.andWhere('profesor.edificio = :edificio', { edificio: filters.edificio });
    }

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

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

    return { profesores, total, totalPages };
  }
}