pcpuma_unam_api/src/modulo/modulo.service.ts

import {
  ConflictException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Institucion } from '../institucion/entity/institucion.entity';
import { Modulo } from './entity/modulo.entity';
import { InformacionModuloView } from './entity/views/informacion-modulo.view';
import { Operador } from '../operador/entity/operador.entity';
import { InstitucionService } from '../institucion/institucion.service';

@Injectable()
export class ModuloService {
  constructor(
    @InjectRepository(Modulo) private repository: Repository<Modulo>,
    @InjectRepository(InformacionModuloView)
    private informacionModuloView: Repository<InformacionModuloView>,
    private institucionService: InstitucionService,
  ) {}

  async create(admin: Operador, modulo: string) {
    return this.existeModulo(admin.institucion, modulo)
      .then(() =>
        this.repository.save(
          this.repository.create({
            institucion: admin.institucion,
            modulo,
          }),
        ),
      )
      .then((_) => ({
        message: 'Se creó correctamente un nuevo módulo.',
      }));
  }

  async existeModulo(id_institucion: number | Institucion, modulo: string) {
    const institucion =
      typeof id_institucion === 'number'
        ? await this.institucionService.findInfoInstitucionById(id_institucion)
        : id_institucion;

    return this.informacionModuloView
      .findOne({
        where: { id_institucion: institucion.id_institucion, modulo },
      })
      .then((existeModulo) => {
        if (existeModulo)
          throw new ConflictException(
            'Ya existe un módulo en esta institución con este nombre, intente con otro nombre.',
          );
        return;
      });
  }

  findById(id_modulo: number) {
    return this.repository.findOne({ where: { id_modulo } }).then((modulo) => {
      if (!modulo) throw new NotFoundException('No existe este id módulo.');
      return modulo;
    });
  }

  async findModulo(
    id_institucion: number | Institucion,
    modulo: string,
    validarNoExiste = true,
  ) {
    const institucion =
      typeof id_institucion === 'number'
        ? await this.institucionService.findInfoInstitucionById(id_institucion)
        : id_institucion;

    return this.repository
      .findOne({ where: { institucion, modulo } })
      .then((modulo) => {
        if (validarNoExiste && !modulo)
          throw new ConflictException('No existe este módulo.');
        return modulo;
      });
  }

  findInfoModuloById(id_modulo: number) {
    return this.informacionModuloView
      .findOne({ where: { id_modulo } })
      .then((infoModulo) => {
        if (!infoModulo)
          throw new NotFoundException('No existe este id módulo.');
        return this.repository.create({
          id_modulo: infoModulo.id_modulo,
          activo: infoModulo.activo === 1,
          modulo: infoModulo.modulo,
          institucion: {
            id_institucion: infoModulo.id_institucion,
            institucion: infoModulo.institucion,
          },
        });
      });
  }

  async findInfoModuloAll(id_institucion: number, activo = 0) {
    return this.institucionService
      .findInfoInstitucionById(id_institucion)
      .then((institucion) => {
        const busqueda: { id_institucion: number; activo?: number } = {
          id_institucion: institucion.id_institucion,
        };

        if (activo) busqueda.activo = activo;
        return this.informacionModuloView.find({
          where: busqueda,
          order: { modulo: 'ASC' },
        });
      })
      .then((infoModulos) => {
        const modulos: Modulo[] = [];

        for (let i = 0; i < infoModulos.length; i++)
          modulos.push(
            this.repository.create({
              id_modulo: infoModulos[i].id_modulo,
              activo: infoModulos[i].activo === 1,
              modulo: infoModulos[i].modulo,
              institucion: {
                id_institucion: infoModulos[i].id_institucion,
                institucion: infoModulos[i].institucion,
              },
            }),
          );
        return modulos;
      });
  }

  update(admin: Operador, attrs: Partial<Modulo>) {
    return this.findInfoModuloById(attrs.id_modulo)
      .then(async (modulo) => {
        if (
          admin.institucion.id_institucion != modulo.institucion.id_institucion
        )
          throw new ConflictException(
            'No puedes actualizar la información de este módulo porque no le pertenece a tu institución.',
          );
        if (attrs.modulo)
          await this.existeModulo(modulo.institucion, attrs.modulo);
        Object.assign(modulo, attrs);
        return this.repository.save(modulo);
      })
      .then((_) => ({
        message: 'Se guardaron los cambios correctamente.',
      }));
  }
}