pcpuma_unam_api/src/equipo/equipo.service.ts

import {
  ConflictException,
  ForbiddenException,
  forwardRef,
  Inject,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Carrito } from '../carrito/entity/carrito.entity';
import { Equipo } from './entity/equipo.entity';
import { Institucion } from '../institucion/entity/institucion.entity';
import { Marca } from '../marca/entity/marca.entity';
import { Modelo } from '../modelo/entity/modelo.entity';
import { Modulo } from '../modulo/entity/modulo.entity';
import { Operador } from '../operador/entity/operador.entity';
import { Programa } from '../institucion-programa/entity/programa.entity';
import { TipoCarrito } from '../institucion-tipo-carrito/entity/tipo-carrito.entity';
import { TipoEntrada } from '../institucion-tipo-entrada/entity/tipo-entrada.entity';
import { CarritoService } from '../carrito/carrito.service';
import { EquipoProgramaService } from '../equipo-programa/equipo-programa.service';
import { InstitucionService } from '../institucion/institucion.service';
import { InstitucionProgramaService } from '../institucion-programa/institucion-programa.service';
import { InstitucionTipoCarritoService } from '../institucion-tipo-carrito/institucion-tipo-carrito.service';
import { InstitucionTipoEntradaService } from '../institucion-tipo-entrada/institucion-tipo-entrada.service';
import { MarcaService } from '../marca/marca.service';
import { ModeloService } from '../modelo/modelo.service';
import { ModuloService } from '../modulo/modulo.service';
import { EquipoMotivoService } from '../equipo-motivo/equipo-motivo.service';
import { OperadorService } from '../operador/operador.service';
import { StatusService } from '../status/status.service';

@Injectable()
export class EquipoService {
  constructor(
    @InjectRepository(Equipo) private repository: Repository<Equipo>,
    private carritoService: CarritoService,
    @Inject(forwardRef(() => EquipoProgramaService))
    private equipoProgramaService: EquipoProgramaService,
    private institucionService: InstitucionService,
    private institucionProgramaService: InstitucionProgramaService,
    private institucionTipoCarritoService: InstitucionTipoCarritoService,
    private institucionTipoEntradaService: InstitucionTipoEntradaService,
    private marcaService: MarcaService,
    private modeloService: ModeloService,
    private moduloService: ModuloService,
    @Inject(forwardRef(() => EquipoMotivoService))
    private equipoMotivoService: EquipoMotivoService,
    private operadorService: OperadorService,
    private statusService: StatusService,
  ) {}

  async create(
    carrito: Carrito,
    equipo: string,
    numero_inventario: string,
    numero_serie: string,
    marca: Marca,
    modelo: Modelo,
  ) {
    const activo = await this.statusService.findById(1);
    const equipoNuevo = await this.repository.save(
      this.repository.create({
        carrito,
        equipo,
        marca,
        modelo,
        numero_inventario,
        numero_serie,
        status: activo,
      }),
    );

    return this.equipoProgramaService
      .create(equipoNuevo, 1)
      .then((_) => equipoNuevo);
  }

  async findAll(
    operador: Operador,
    filtros: {
      pagina: string;
      carrito?: string;
      equipo?: string;
      id_carrito?: string;
      id_institucion?: string;
      id_marca?: string;
      id_modelo?: string;
      id_modulo?: string;
      id_programa?: string;
      id_status?: string;
      id_tipo_carrito?: string;
      id_tipo_entrada?: string;
    },
  ) {
    const carrito = filtros.id_carrito
      ? await this.carritoService.findById(parseInt(filtros.id_carrito))
      : null;
    const institucion = filtros.id_institucion
      ? await this.institucionService.findById(parseInt(filtros.id_institucion))
      : null;
    const marca = filtros.id_marca
      ? await this.marcaService.findById(parseInt(filtros.id_marca), 'e')
      : null;
    const modelo = filtros.id_modelo
      ? await this.modeloService.findById(parseInt(filtros.id_modelo), 'e')
      : null;
    const modulo = filtros.id_modulo
      ? await this.moduloService.findById(parseInt(filtros.id_modulo))
      : null;
    const programa = filtros.id_programa
      ? await this.institucionProgramaService.findProgramaById(
          parseInt(filtros.id_programa),
        )
      : null;
    const tipoCarrito = filtros.id_tipo_carrito
      ? await this.institucionTipoCarritoService.findTipoCarritoById(
          parseInt(filtros.id_tipo_carrito),
        )
      : null;
    const status = filtros.id_status
      ? await this.statusService.findById(parseInt(filtros.id_status))
      : null;
    const tipoEntrada = filtros.id_tipo_entrada
      ? await this.institucionTipoEntradaService.findTipoEntradaById(
          parseInt(filtros.id_tipo_entrada),
        )
      : null;
    const query = this.repository
      .createQueryBuilder('e')
      .innerJoinAndSelect('e.carrito', 'c')
      .innerJoinAndSelect('e.marca', 'ma')
      .innerJoinAndSelect('e.modelo', 'mo')
      .innerJoinAndSelect('e.programas', 'ps')
      .innerJoinAndSelect('e.status', 's')
      .innerJoinAndSelect('e.tiposEntradas', 'tes')
      .innerJoinAndSelect('c.modulo', 'm')
      .innerJoinAndSelect('c.tipoCarrito', 'tc')
      .innerJoinAndSelect('ps.programa', 'p')
      .innerJoinAndSelect('tes.tipoEntrada', 'te')
      .innerJoinAndSelect('m.institucion', 'i')
      .orderBy('i.institucion')
      .addOrderBy('m.modulo')
      .addOrderBy('tc.tipo_carrito')
      .addOrderBy('c.carrito')
      .addOrderBy('e.equipo')
      .take(15)
      .skip((parseInt(filtros.pagina) - 1) * 15);

    if (modulo) {
      if (
        operador.tipoUsuario.id_tipo_usuario > 2 &&
        operador.institucion.id_institucion != modulo.institucion.id_institucion
      )
        throw new ForbiddenException(
          'No puedes acceder a esta información porque este módulo no pertenece a tu institución.',
        );
      query.andWhere('m.id_modulo = :id_modulo', {
        id_modulo: modulo.id_modulo,
      });
    }
    if (carrito) {
      if (
        operador.tipoUsuario.id_tipo_usuario > 2 &&
        operador.institucion.id_institucion !=
          carrito.modulo.institucion.id_institucion
      )
        throw new ForbiddenException(
          'No puedes acceder a esta información porque este carrito no pertenece a tu institución.',
        );
      query.andWhere('c.id_carrito = :id_carrito', {
        id_carrito: carrito.id_carrito,
      });
    }
    if (filtros.carrito)
      query.andWhere('c.carrito LIKE :carrito', {
        carrito: `%${filtros.carrito}%`,
      });
    if (filtros.equipo)
      query.andWhere('e.equipo LIKE :equipo', {
        equipo: `%${filtros.equipo}%`,
      });
    if (institucion && operador.tipoUsuario.id_tipo_usuario === 2)
      query.andWhere('m.id_institucion = :id_institucion', {
        id_institucion: institucion.id_institucion,
      });
    if (marca)
      query.andWhere('ma.id_marca = :id_marca', {
        id_marca: marca.id_marca,
      });
    if (modelo)
      query.andWhere('mo.id_modelo = :id_modelo', {
        id_modelo: modelo.id_modelo,
      });
    if (programa)
      query.andWhere('ps.id_programa = :id_programa', {
        id_programa: programa.id_programa,
      });
    if (tipoCarrito)
      query.andWhere('tc.id_tipo_carrito = :id_tipo_carrito', {
        id_tipo_carrito: tipoCarrito.id_tipo_carrito,
      });
    if (tipoEntrada)
      query.andWhere('tes.id_tipo_entrada = :id_tipo_entrada', {
        id_tipo_entrada: tipoEntrada.id_tipo_entrada,
      });
    if (status)
      query.andWhere('s.id_status = :id_status', {
        id_status: status.id_status,
      });
    return query.getManyAndCount();
  }

  findById(id_equipo: number) {
    return this.repository.findOne({ id_equipo }).then((equipo) => {
      if (!equipo) throw new NotFoundException('No existe este id equipo.');
      return equipo;
    });
  }

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

    return this.repository
      .findOne({
        join: {
          alias: 'e',
          innerJoinAndSelect: {
            c: 'e.carrito',
            m: 'c.modulo',
            i: 'm.institucion',
          },
        },
        where: { numero_inventario, carrito: { modulo: { institucion } } },
      })
      .then((equipo) => {
        if (validarNoExiste && !equipo)
          throw new NotFoundException(
            'No existe este un equipo de cómputo con este número de inventario.',
          );
        return equipo;
      });
  }

  async findEquipo(
    modulo: Modulo,
    tipoCarrito: TipoCarrito,
    programa?: Programa,
    tipoEntrada?: TipoEntrada,
  ) {
    const queryReseteo = this.repository
      .createQueryBuilder('e')
      .innerJoin('e.carrito', 'c', 'c.activo = 1')
      .innerJoin('e.programas', 'ps')
      .innerJoin('e.status', 's', 's.id_status = 1')
      .innerJoin('e.tiposEntradas', 'tes')
      .innerJoin('c.modulo', 'm', 'm.id_modulo = :id_modulo AND m.activo = 1', {
        id_modulo: modulo.id_modulo,
      })
      .innerJoin(
        'c.tipoCarrito',
        'tc',
        'tc.id_tipo_carrito = :id_tipo_carrito',
        { id_tipo_carrito: tipoCarrito.id_tipo_carrito },
      )
      .innerJoin('m.institucion', 'i', 'i.activo = 1')
      .where('prestado = 1');
    const query = this.repository
      .createQueryBuilder('e')
      .innerJoinAndSelect('e.carrito', 'c', 'c.activo = 1')
      .innerJoinAndSelect('e.programas', 'ps')
      .innerJoinAndSelect('e.status', 's', 's.id_status = 1')
      .innerJoinAndSelect('e.tiposEntradas', 'tes')
      .innerJoinAndSelect(
        'c.modulo',
        'm',
        'm.id_modulo = :id_modulo AND m.activo = 1',
        {
          id_modulo: modulo.id_modulo,
        },
      )
      .innerJoinAndSelect(
        'c.tipoCarrito',
        'tc',
        'tc.id_tipo_carrito = :id_tipo_carrito',
        { id_tipo_carrito: tipoCarrito.id_tipo_carrito },
      )
      .innerJoinAndSelect('m.institucion', 'i', 'i.activo = 1')
      .innerJoinAndSelect('ps.programa', 'p')
      .innerJoinAndSelect('tes.tipoEntrada', 'te')
      .where('e.prestado = 0')
      .orderBy('c.carrito')
      .addOrderBy('e.equipo');

    if (programa) {
      query.andWhere('ps.id_programa = :id_programa', {
        id_programa: programa.id_programa,
      });
      queryReseteo.andWhere('ps.id_programa = :id_programa', {
        id_programa: programa.id_programa,
      });
    } else {
      query.andWhere('ps.id_programa = 1');
      queryReseteo.andWhere('id_programa = 1');
    }
    if (tipoEntrada) {
      query.andWhere('tes.id_tipo_entrada = :id_tipo_entrada', {
        id_tipo_entrada: tipoEntrada.id_tipo_entrada,
      });
      queryReseteo.andWhere('tes.id_tipo_entrada = :id_tipo_entrada', {
        id_tipo_entrada: tipoEntrada.id_tipo_entrada,
      });
    }

    return query.getCount().then(async (n) => {
      if (n === 0)
        await queryReseteo.getMany().then(async (equipos) => {
          for (let i = 0; i < equipos.length; i++) {
            equipos[i].prestado = false;
            await this.repository.save(equipos[i]);
          }
        });
      return query.getOne();
    });
  }

  reseteoTotal() {
    return this.repository
      .createQueryBuilder()
      .update()
      .set({ prestado: false })
      .execute();
  }

  async findEquipoByEquipo(
    id_carrito: number | Carrito,
    equipo: string,
    validarNoExiste = true,
  ) {
    const carrito =
      typeof id_carrito === 'number'
        ? await this.carritoService.findById(id_carrito)
        : id_carrito;

    return this.repository.findOne({ carrito, equipo }).then((equipo) => {
      if (validarNoExiste && !equipo)
        throw new NotFoundException('No existe este equipo.');
      return equipo;
    });
  }

  async update(
    // operador: Operador,
    attrs: Partial<Equipo>,
    id_carrito?: number,
    id_status?: number,
    id_operador?: number | Operador,
    motivo?: string,
  ) {
    const carrito = id_carrito
      ? await this.carritoService.findById(id_carrito)
      : null;
    const operador = id_operador
      ? typeof id_operador === 'number'
        ? await this.operadorService.findById(id_operador)
        : id_operador
      : null;
    const status = id_status
      ? await this.statusService.findById(id_status)
      : null;

    return this.findById(attrs.id_equipo)
      .then(async (equipo) => {
        if ((attrs.equipo && attrs.equipo != equipo.equipo) || carrito)
          await this.findEquipoByEquipo(
            carrito ? carrito : equipo.carrito,
            attrs.equipo ? attrs.equipo : equipo.equipo,
            false,
          ).then((existeEquipo) => {
            if (existeEquipo)
              throw new ConflictException(
                'Ya existe un equipo en este carrito con este nombre, intenta con otro.',
              );
          });
        if (
          status &&
          (status.id_status >= 4 ||
            (equipo.status.id_status >= 4 && status.id_status === 1))
        ) {
          if (!operador)
            throw new ConflictException('No se mandó el id operador.');
          if (!motivo)
            throw new ConflictException(
              'No se mandó el motivo para el cambio de status.',
            );
        }
        Object.assign(equipo, attrs);
        if (status) {
          if (
            status.id_status >= 4 ||
            (equipo.status.id_status >= 4 && status.id_status === 1)
          )
            await this.equipoMotivoService.create(
              equipo,
              operador,
              status,
              motivo,
            );
          equipo.status = status;
        }
        if (carrito) equipo.carrito = carrito;
        return this.repository.save(equipo);
      })
      .then((equipo) => ({
        message: 'Se guardaron los cambios correctamente.',
        equipo,
      }));
  }
}