pcpuma_unam_api/src/multa/multa.service.ts

import * as moment from 'moment';
import { ConflictException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { InstitucionInfraccion } from '../institucion-infraccion/entity/institucion-infraccion.entity';
import { Multa } from './entity/multa.entity';
import { Operador } from '../operador/entity/operador.entity';
import { Prestamo } from '../prestamo/entity/prestamo.entity';
import { EquipoService } from '../equipo/equipo.service';
import { InstitucionService } from '../institucion/institucion.service';
import { InstitucionInfraccionService } from '../institucion-infraccion/institucion-infraccion.service';
import { InstitucionUsuarioService } from '../institucion-usuario/institucion-usuario.service';
import { OperadorService } from '../operador/operador.service';
import { PrestamoService } from '../prestamo/prestamo.service';
import { UsuarioService } from '../usuario/usuario.service';

@Injectable()
export class MultaService {
  constructor(
    @InjectRepository(Multa) private repository: Repository<Multa>,
    private equipoService: EquipoService,
    private institucionService: InstitucionService,
    private institucionInfraccionService: InstitucionInfraccionService,
    private institucionUsuarioService: InstitucionUsuarioService,
    private operadorService: OperadorService,
    private prestamoService: PrestamoService,
    private usuarioService: UsuarioService,
  ) {}

  async create(
    id_prestamo: number | Prestamo,
    id_operador: number | Operador,
    descripcion: string,
    retraso?: number,
    id_institucion_infraccion?: number,
  ) {
    const ahora = moment();
    const prestamo =
      typeof id_prestamo === 'number'
        ? await this.prestamoService.findById(id_prestamo)
        : id_prestamo;
    const operador =
      typeof id_operador === 'number'
        ? await this.operadorService.findById(id_operador)
        : id_operador;
    const data: {
      descripcion: string;
      fecha_inicio: Date;
      operadorMulta: Operador;
      prestamo: Prestamo;
      fecha_fin?: Date;
      institucionInfraccion?: InstitucionInfraccion;
      retraso?: boolean;
    } = {
      descripcion,
      fecha_inicio: ahora.toDate(),
      operadorMulta: operador,
      prestamo,
    };
    const institucionInfraccion = id_institucion_infraccion
      ? await this.institucionInfraccionService.findById(
          id_institucion_infraccion,
        )
      : null;

    if (prestamo.cancelado_operador || prestamo.cancelado_usuario)
      throw new ConflictException(
        'No se puede multar a un usuario con un préstamo que fue cancelado.',
      );
    if (!retraso && !institucionInfraccion)
      throw new ConflictException(
        'No se mandó ningún motivo para multar a este alumno.',
      );
    return this.repository
      .findOne({ where: { prestamo } })
      .then((existeMulta) => {
        if (existeMulta)
          throw new ConflictException(
            'Ya existe una multa asignada a este préstamo.',
          );
        if (retraso) {
          data.retraso = true;
          ahora.add(retraso * operador.institucion.dias_multa_retraso, 'd');
        }
        if (institucionInfraccion) {
          data.institucionInfraccion = institucionInfraccion;
          ahora.add(institucionInfraccion.dias_multa, 'd');
        }
        data.fecha_fin = ahora.toDate();
        return this.repository.save(this.repository.create(data));
      })
      .then((_) => {
        for (let i = 0; prestamo.usuario.instituciones.length; i++) {
          const institucionUsuario = prestamo.usuario.instituciones[i];

          if (
            institucionUsuario.institucionCarrera.institucion.id_institucion ===
            operador.institucion.id_institucion
          ) {
            institucionUsuario.multa = true;
            return this.institucionUsuarioService.update(institucionUsuario);
          }
        }
      });
  }

  desactivarMultas() {
    const ahora = moment();

    return this.repository
      .find({ where: { activo: true } })
      .then(async (multas) => {
        for (let i = 0; i < multas.length; i++)
          if (ahora.diff(moment(multas[i].fecha_fin)) > 0) {
            const instituciones = multas[i].prestamo.usuario.instituciones;

            multas[i].activo = false;
            await this.repository.save(multas[i]);
            for (let j = 0; j < instituciones.length; j++) {
              const institucionUsuario = instituciones[j];

              if (
                institucionUsuario.institucionCarrera.institucion
                  .id_institucion ===
                multas[i].operadorMulta.institucion.id_institucion
              ) {
                institucionUsuario.multa = false;
                await this.institucionUsuarioService.update(institucionUsuario);
              }
            }
          }
      });
  }

  async findAll(filtros: {
    pagina: string;
    id_institucion?: string;
    usuario?: string;
  }) {
    const institucion = filtros.id_institucion
      ? await this.institucionService.findInfoInstitucionById(
          parseInt(filtros.id_institucion),
        )
      : null;
    const query = this.repository
      .createQueryBuilder('mu')
      .innerJoinAndSelect('mu.institucionInfraccion', 'ii')
      .innerJoinAndSelect('mu.operadorMulta', 'om')
      .innerJoinAndSelect('mu.prestamo', 'p')
      .innerJoinAndSelect('ii.infraccion', 'inf')
      .innerJoinAndSelect('om.tipoUsuario', 'tu')
      .innerJoinAndSelect('p.equipo', 'e')
      .innerJoinAndSelect('p.usuario', 'u')
      .innerJoinAndSelect('e.carrito', 'c')
      .innerJoinAndSelect('u.instituciones', 'is')
      .innerJoinAndSelect('c.modulo', 'm')
      .innerJoinAndSelect('c.tipoCarrito', 'tc')
      .innerJoinAndSelect('is.institucionCarrera', 'ic')
      .innerJoinAndSelect('m.institucion', 'i')
      .innerJoinAndSelect('ic.carrera', 'ca')
      .innerJoinAndSelect('ic.institucion', 'in')
      .orderBy('i.institucion')
      .addOrderBy('mu.activo', 'DESC')
      .addOrderBy('mu.id_multa', 'DESC')
      .addOrderBy('u.usuario')
      .skip((parseInt(filtros.pagina) - 1) * 25)
      .take(25);

    if (filtros.usuario)
      query.andWhere('u.usuario LIKE :usuario', {
        usuario: `%${filtros.usuario}%`,
      });
    if (institucion)
      query.andWhere('i.id_institucion = :id_institucion', {
        id_institucion: institucion.id_institucion,
      });
    return query.getManyAndCount();
  }

  findAllByIdEquipo(id_equipo: number, pagina: number) {
    return this.equipoService.findInfoEquipoById(id_equipo).then((equipo) =>
      this.repository
        .createQueryBuilder('mu')
        .innerJoinAndSelect('mu.institucionInfraccion', 'ii')
        .innerJoinAndSelect('mu.operadorMulta', 'om')
        .innerJoinAndSelect('mu.prestamo', 'p')
        .innerJoinAndSelect('ii.infraccion', 'inf')
        .innerJoinAndSelect('ii.institucion', 'i')
        .innerJoinAndSelect('om.tipoUsuario', 'tu')
        .innerJoinAndSelect('p.equipo', 'e', 'e.id_equipo = :id_equipo', {
          id_equipo: equipo.id_equipo,
        })
        .innerJoinAndSelect('p.usuario', 'u')
        .innerJoinAndSelect('u.instituciones', 'is')
        .innerJoinAndSelect('is.institucionCarrera', 'ic')
        .innerJoinAndSelect('ic.carrera', 'ca')
        .innerJoinAndSelect('ic.institucion', 'in')
        .orderBy('mu.id_multa', 'DESC')
        .skip((pagina - 1) * 25)
        .take(25)
        .getManyAndCount(),
    );
  }

  findAllByIdUsuario(id_usuario: number, pagina: number) {
    return this.usuarioService.findById(id_usuario).then((usuario) =>
      this.repository
        .createQueryBuilder('mu')
        .innerJoinAndSelect('mu.institucionInfraccion', 'ii')
        .innerJoinAndSelect('mu.operadorMulta', 'om')
        .innerJoinAndSelect('mu.prestamo', 'p')
        .innerJoinAndSelect('ii.infraccion', 'inf')
        .innerJoinAndSelect('ii.institucion', 'i')
        .innerJoinAndSelect('om.tipoUsuario', 'tu')
        .innerJoinAndSelect('p.equipo', 'e')
        .innerJoinAndSelect('p.usuario', 'u', 'u.id_usuario = :id_usuario', {
          id_usuario: usuario.id_usuario,
        })
        .innerJoinAndSelect('e.carrito', 'c')
        .innerJoinAndSelect('c.modulo', 'm')
        .innerJoinAndSelect('c.tipoCarrito', 'tc')
        .innerJoinAndSelect('m.institucion', 'in')
        .orderBy('mu.id_multa', 'DESC')
        .skip((pagina - 1) * 25)
        .take(25)
        .getManyAndCount(),
    );
  }

  findMultasActivas(id_usuario: number) {
    return this.usuarioService.findById(id_usuario).then((usuario) =>
      this.repository
        .createQueryBuilder('mu')
        .innerJoin('mu.prestamo', 'p')
        .innerJoin('p.usuario', 'u', 'u.id_usuario = :id_usuario', {
          id_usuario: usuario.id_usuario,
        })
        .innerJoinAndSelect('mu.institucionInfraccion', 'ii')
        .innerJoinAndSelect('ii.institucion', 'i')
        .andWhere('mu.activo = 1')
        .getMany(),
    );
  }

  async quitarMulta(id_institucion_usuario: number) {
    const institucionUsuario = await this.institucionUsuarioService.findById(
      id_institucion_usuario,
    );

    return this.repository
      .createQueryBuilder('mu')
      .innerJoin('mu.prestamo', 'p')
      .innerJoin('p.usuario', 'u')
      .innerJoin(
        'u.instituciones',
        'is',
        'is.id_institucion_usuario = :id_institucion_usuario',
        { id_institucion_usuario: institucionUsuario.id_institucion_usuario },
      )
      .where('mu.activo = 1')
      .getOne()
      .then((multa) => {
        if (!multa)
          throw new ConflictException(
            'Este usuario no tiene una multa activa en esta institución.',
          );
        multa.activo = false;
        institucionUsuario.multa = false;
        return this.repository.save(multa);
      })
      .then((_) => this.institucionUsuarioService.update(institucionUsuario))
      .then((_) => ({ message: 'Se guardaron los cambios correctamente.' }));
  }
}