pcpuma_unam_api/src/carrito/carrito.service.ts

import {
  ForbiddenException,
  forwardRef,
  Inject,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { FindManyOptions, FindOptionsWhere, Like, Repository } from 'typeorm';
import { Carrito } from './entity/carrito.entity';
import { InformacionCarritoView } from './entity/views/informacion-carrito.view';
import { FullInformacionCarritoView } from './entity/views/full-informacion-carrito.view';
import { Modulo } from '../modulo/entity/modulo.entity';
import { Operador } from '../operador/entity/operador.entity';
import { TipoCarrito } from '../institucion-tipo-carrito/entity/tipo-carrito.entity';
import { CarritoMotivoService } from '../carrito-motivo/carrito-motivo.service';
import { InstitucionService } from '../institucion/institucion.service';
import { InstitucionTipoCarritoService } from '../institucion-tipo-carrito/institucion-tipo-carrito.service';
import { MarcaService } from '../marca/marca.service';
import { ModeloService } from '../modelo/modelo.service';
import { ModuloService } from '../modulo/modulo.service';

@Injectable()
export class CarritoService {
  constructor(
    @InjectRepository(Carrito) private repository: Repository<Carrito>,
    @InjectRepository(InformacionCarritoView)
    private informacionCarritoView: Repository<InformacionCarritoView>,
    @InjectRepository(FullInformacionCarritoView)
    private fullInformacionCarritoView: Repository<FullInformacionCarritoView>,
    @Inject(forwardRef(() => CarritoMotivoService))
    private caritoMotivoService: CarritoMotivoService,
    private institucionService: InstitucionService,
    private institucionTipoCarritoService: InstitucionTipoCarritoService,
    private marcaService: MarcaService,
    private modeloService: ModeloService,
    private moduloService: ModuloService,
  ) {}

  async create(
    admin: Operador,
    id_modulo: number,
    id_tipo_carrito: number,
    id_marca: number,
    id_modelo: number,
  ) {
    const modulo = await this.moduloService.findInfoModuloById(id_modulo);
    const tipoCarrito =
      await this.institucionTipoCarritoService.findTipoCarritoById(
        id_tipo_carrito,
      );
    const marca = await this.marcaService.findById(id_marca, 'c');
    const modelo = await this.modeloService.findById(id_modelo, 'c');

    // Valido que el módulo seleccionado pertenezca a la institutción del admin
    if (admin.institucion.id_institucion != modulo.institucion.id_institucion)
      throw new ForbiddenException(
        'No puedes crear carritos para este módulo porque no pertenece a tu institución.',
      );
    // Cuento cuantos carritos tiene ese modulo de ese tipo de carrito
    return this.informacionCarritoView
      .count({
        where: {
          id_modulo: modulo.id_modulo,
          id_tipo_carrito: tipoCarrito.id_tipo_carrito,
        },
      })
      .then((n) =>
        // Creo y cuardo el registro
        this.repository.save(
          this.repository.create({
            carrito: `C${n >= 9 ? '' : '0'}${n + 1}`,
            marca,
            modelo,
            modulo,
            tipoCarrito,
          }),
        ),
      )
      .then((_) => ({
        message: 'Se creó correctamente un nuevo carrito para este módulo.',
      }));
  }

  findById(id_carrito: number) {
    return this.informacionCarritoView
      .findOne({ where: { id_carrito } })
      .then((infoCarrito) => {
        if (!infoCarrito)
          throw new NotFoundException('No existe este id carrito.');
        return this.viewToCarrito(infoCarrito);
      });
  }

  findCarrito(modulo: Modulo, tipoCarrito: TipoCarrito, carrito: string) {
    return this.informacionCarritoView
      .findOne({
        where: {
          carrito,
          id_modulo: modulo.id_modulo,
          id_tipo_carrito: tipoCarrito.id_tipo_carrito,
        },
      })
      .then((infoCarrito) => {
        if (!infoCarrito) return null;
        return this.viewToCarrito(infoCarrito);
      });
  }

  findFullInfoById(id_carrito: number) {
    return this.fullInformacionCarritoView
      .findOne({ where: { id_carrito } })
      .then((infoCarrito) => {
        if (!infoCarrito)
          throw new NotFoundException('No existe este id carrito.');
        return this.repository.create({
          id_carrito: infoCarrito.id_carrito,
          activo: infoCarrito.activo === 1,
          carrito: infoCarrito.carrito,
          marca: {
            id_marca: infoCarrito.id_marca,
            marca: infoCarrito.marca,
          },
          modelo: {
            id_modelo: infoCarrito.id_modelo,
            modelo: infoCarrito.modelo,
          },
          modulo: {
            id_modulo: infoCarrito.id_modulo,
            modulo: infoCarrito.modulo,
            institucion: {
              id_institucion: infoCarrito.id_institucion,
              institucion: infoCarrito.institucion,
            },
          },
          tipoCarrito: {
            id_tipo_carrito: infoCarrito.id_tipo_carrito,
            tipo_carrito: infoCarrito.tipo_carrito,
          },
        });
      });
  }

  async findFullInfoAll(filtros: {
    pagina?: string;
    activo?: string;
    carrito?: string;
    id_institucion?: string;
    id_marca?: string;
    id_modelo?: string;
    id_modulo?: string;
    id_tipo_carrito?: string;
  }) {
    const carritos: Carrito[] = [];
    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), 'c')
      : null;
    const modelo = filtros.id_modelo
      ? await this.modeloService.findById(parseInt(filtros.id_modelo), 'c')
      : null;
    const modulo = filtros.id_modulo
      ? await this.moduloService.findInfoModuloById(parseInt(filtros.id_modulo))
      : null;
    const tipoCarrito = filtros.id_tipo_carrito
      ? await this.institucionTipoCarritoService.findTipoCarritoById(
          parseInt(filtros.id_tipo_carrito),
        )
      : null;
    const options: FindManyOptions<FullInformacionCarritoView> = {};
    const busqueda: FindOptionsWhere<FullInformacionCarritoView> = {};

    if (filtros.activo === 'true') busqueda.activo = 1;
    if (filtros.activo === 'false') busqueda.activo = 0;
    if (filtros.carrito) busqueda.carrito = Like(`%${filtros.carrito}%`);
    if (institucion) busqueda.id_institucion = institucion.id_institucion;
    if (modulo) busqueda.id_modulo = modulo.id_modulo;
    if (marca) busqueda.id_marca = marca.id_marca;
    if (modelo) busqueda.id_modelo = modelo.id_modelo;
    if (tipoCarrito) busqueda.id_tipo_carrito = tipoCarrito.id_tipo_carrito;
    options.where = busqueda;
    // Si viene con página es que quiere paginación
    if (filtros.pagina) {
      options.skip = (parseInt(filtros.pagina) - 1) * 25;
      options.take = 25;
      return this.fullInformacionCarritoView
        .findAndCount(options)
        .then((infoCarritos) => {
          for (let i = 0; i < infoCarritos[0].length; i++)
            carritos.push(this.fullViewToCarrito(infoCarritos[0][i]));
          return [carritos, infoCarritos[1]];
        });
    } else
      return this.fullInformacionCarritoView
        .find(options)
        .then((infoCarritos) => {
          for (let i = 0; i < infoCarritos.length; i++)
            carritos.push(this.fullViewToCarrito(infoCarritos[i]));
          return carritos;
        });
  }

  private fullViewToCarrito(infoCarrito: FullInformacionCarritoView) {
    return this.repository.create({
      id_carrito: infoCarrito.id_carrito,
      activo: infoCarrito.activo === 1,
      carrito: infoCarrito.carrito,
      modulo: {
        id_modulo: infoCarrito.id_modulo,
        modulo: infoCarrito.modulo,
        institucion: {
          id_institucion: infoCarrito.id_institucion,
          institucion: infoCarrito.institucion,
        },
      },
      tipoCarrito: {
        id_tipo_carrito: infoCarrito.id_tipo_carrito,
        tipo_carrito: infoCarrito.tipo_carrito,
      },
    });
  }

  async update(operador: Operador, attrs: Partial<Carrito>, motivo: string) {
    return this.findById(attrs.id_carrito)
      .then(async (carrito) => {
        // Valido que el carrito pertenezca a la institución del operador
        if (
          operador.institucion.id_institucion !=
          carrito.modulo.institucion.id_institucion
        )
          throw new ForbiddenException(
            'No puedes modificar la información este carrito porque no pertenece a tu institución.',
          );
        // Actualizo el objeto con los valores enviados del front
        Object.assign(carrito, attrs);
        // Guardo cambios
        return this.repository.save(carrito);
      })
      .then((carrito) =>
        // Creo reporte de cambio de status del carrito
        this.caritoMotivoService.create(
          carrito,
          operador,
          attrs.activo,
          motivo,
        ),
      )
      .then((_) => ({ message: 'Se guardaron los cambios correctamente.' }));
  }

  private viewToCarrito(infoCarrito: InformacionCarritoView) {
    return this.repository.create({
      id_carrito: infoCarrito.id_carrito,
      modulo: {
        id_modulo: infoCarrito.id_modulo,
        institucion: { id_institucion: infoCarrito.id_institucion },
      },
      tipoCarrito: { id_tipo_carrito: infoCarrito.id_tipo_carrito },
    });
  }
}