pcpuma_unam_api/src/prestamo/prestamo.controller.ts

import {
  Body,
  Controller,
  Get,
  Post,
  Put,
  Query,
  Request,
  UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import {
  ApiBearerAuth,
  ApiBody,
  ApiOperation,
  ApiQuery,
  ApiTags,
} from '@nestjs/swagger';
import { Serealize } from '../interceptors/serialize.interceptor';
import { PrestamoService } from './prestamo.service';
import { ValidarUsuarioService } from '../validar-usuario/validar-usuario.service';
import { Modulo } from '../modulo/entity/modulo.entity';
import { Operador } from '../operador/entity/operador.entity';
import { Usuario } from '../usuario/entity/usuario.entity';
import { IdEquipoPaginaDto } from '../dto/input/id-equipo-pagina.dto';
import { IdUsuarioPaginaDto } from '../dto/input/id-usuario-pagina.dto';
import { NumeroInventarioDto } from '../dto/input/numero-inventario.dto';
import { ActivosDto } from './dto/input/activos.dto';
import { CancelarOperadorDto } from './dto/input/cancelar-operador.dto';
import { EntregarDto } from './dto/input/entregar.dto';
import { HistorialDto } from './dto/input/historial.dto';
import { IdPrestamoDto } from './dto/input/id-prestamo.dto';
import { PedirDto } from './dto/input/pedir.dto';
import { RegresarIdPrestamoDto } from './dto/input/regresar-id-prestamo.dto';
import { RegresarNumeroInventarioDto } from './dto/input/regresar-numero-inventario.dto';
import { ReporteDto } from './dto/input/reporte';
import { MessageOutputDto } from '../dto/output/message.dto';
import { EquipoMinOutputDto } from '../equipo/dto/output/equipo-min.dto';
import { ActivosOutputDto } from './dto/output/activos.dto';
import { PrestamoOutputDto } from './dto/output/prestamo.dto';
import { PrestamoEquipoOutputDto } from './dto/output/prestamo-equipo.dto';
import { PrestamosOutputDto } from './dto/output/prestamos.dto';
import { PrestamosEquipoOutputDto } from './dto/output/prestamos-equipo.dto';
import { PrestamosUsuarioOutputDto } from './dto/output/prestamos-usuario.dto';
import { ReporteOutputDto } from './dto/output/reporte';

@Controller('prestamo')
@ApiTags('prestamo')
export class PrestamoController {
  constructor(
    private prestamoService: PrestamoService,
    private validarUsuarioService: ValidarUsuarioService,
  ) {}

  @Serealize(ActivosOutputDto)
  @Get('activos')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Información de 25 préstamos activos dependiendo de los filtros enviados.',
  })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Página en la que se encuentra el usuario.',
    name: 'pagina',
    type: 'string',
  })
  @ApiQuery({
    description: 'Carrito que se quiere usar como filtro.',
    name: 'carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Equipo que se quiere usar como filtro.',
    name: 'equipo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id de la institución que se quiere usar como filtro.',
    name: 'id_institucion',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del modulo que se quiere usar como filtro.',
    name: 'id_modulo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del préstamo que se quiere usar como filtro.',
    name: 'id_prestamo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de carrito que se quiere usar como filtro.',
    name: 'id_tipo_carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de usuario que se quiere usar como filtro.',
    name: 'id_tipo_usuario',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Usuario que se quiere usar como filtro.',
    name: 'usuario',
    type: 'string',
    required: false,
  })
  activos(@Request() req, @Query() query: ActivosDto) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarAdminOperador(operador);
    return this.prestamoService.findAll(query);
  }

  @Serealize(MessageOutputDto)
  @Put('cancelar-operador')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Cancelar un préstamo por parte del operador.' })
  @ApiBearerAuth('jwt')
  @ApiBody({
    description: 'Variables que necesita el endpoint.',
    examples: { ejemplo: { value: { id_prestamo: 1, motivo: '' } } },
  })
  cancelarOperador(@Request() req, @Body() body: CancelarOperadorDto) {
    const operador: Operador = req.user.operador;
    const modulo: Modulo = req.user.modulo;

    this.validarUsuarioService.validarAdminOperador(operador);
    return this.prestamoService.cancelarOperador(
      operador,
      body.id_prestamo,
      body.motivo,
      modulo,
    );
  }

  @Serealize(MessageOutputDto)
  @Put('cancelar-usuario')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Cancelar un préstamo activo del usuario.' })
  @ApiBearerAuth('jwt')
  cancelarUsuario(@Request() req) {
    const usuario: Usuario = req.user.usuario;

    this.validarUsuarioService.validarUsuario(usuario);
    return this.prestamoService.cancelarUsuario(usuario);
  }

  @Serealize(EquipoMinOutputDto)
  @Put('entregar')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Entregar un equipo de cómputo.' })
  @ApiBearerAuth('jwt')
  @ApiBody({
    description: 'Variables que necesita el endpoint.',
    examples: { ejemplo: { value: { id_prestamo: 1 } } },
  })
  entregar(@Request() req, @Body() body: EntregarDto) {
    const operador: Operador = req.user.operador;
    const modulo: Modulo = req.user.modulo;

    this.validarUsuarioService.validarAdminOperador(operador);
    return this.prestamoService.entregar(operador, modulo, body.id_prestamo);
  }

  @Serealize(PrestamosOutputDto)
  @Get('historial')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Información de 25 préstamos dependiendo de los filtros enviados.',
  })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Página en la que se encuentra el usuario.',
    name: 'pagina',
    type: 'string',
  })
  @ApiQuery({
    description: 'Boleano para obtener préstamos activos como filtro.',
    name: 'activo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description:
      'Boleano para obtener préstamos cancelados por operadores como filtro.',
    name: 'cancelado_operador',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description:
      'Boleano para obtener préstamos cancelados por usuarios como filtro.',
    name: 'cancelado_usuario',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Carrito que se quiere usar como filtro.',
    name: 'carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Equipo que se quiere usar como filtro.',
    name: 'equipo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Fecha fin se quiere usar como filtro.',
    name: 'fechaFin',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Fecha inicio que se quiere usar como filtro.',
    name: 'fechaInicio',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id de la institución que se quiere usar como filtro.',
    name: 'id_institucion',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id de la institución carrera que se quiere usar como filtro.',
    name: 'id_institucion_carrera',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del modulo que se quiere usar como filtro.',
    name: 'id_modulo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del operador de entrega que se quiere usar como filtro.',
    name: 'id_operador_entrega',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del operador de regreso que se quiere usar como filtro.',
    name: 'id_operador_regreso',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del préstamo que se quiere usar como filtro.',
    name: 'id_prestamo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de carrito que se quiere usar como filtro.',
    name: 'id_tipo_carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de usuario que se quiere usar como filtro.',
    name: 'id_tipo_usuario',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Usuario que se quiere usar como filtro.',
    name: 'usuario',
    type: 'string',
    required: false,
  })
  historial(@Request() req, @Query() query: HistorialDto) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarOperador(operador);
    return this.prestamoService.findAll(query);
  }

  @Serealize(PrestamosEquipoOutputDto)
  @Get('historial-equipo')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Información de 25 préstamos de un equipo dependiendo de los filtros enviados.',
  })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Id del equipo.',
    name: 'id_equipo',
    type: 'string',
  })
  @ApiQuery({
    description: 'Página en la que se encuentra el usuario.',
    name: 'pagina',
    type: 'string',
  })
  historialEquipo(@Request() req, @Query() query: IdEquipoPaginaDto) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarAdminOperador(operador);
    return this.prestamoService.findAllByIdEquipo(
      parseInt(query.id_equipo),
      parseInt(query.pagina),
    );
  }

  @Serealize(PrestamosUsuarioOutputDto)
  @Get('historial-usuario')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Información de 25 préstamos de un usuario dependiendo de los filtros enviados.',
  })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Id del usuario.',
    name: 'id_usuario',
    type: 'string',
  })
  @ApiQuery({
    description: 'Página en la que se encuentra el usuario.',
    name: 'pagina',
    type: 'string',
  })
  historialUsuario(@Request() req, @Query() query: IdUsuarioPaginaDto) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarAdminOperador(operador);
    return this.prestamoService.findAllByIdUsuario(
      parseInt(query.id_usuario),
      parseInt(query.pagina),
    );
  }

  @Serealize(PrestamoOutputDto)
  @Post()
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Pedir un equipo de cómputo.' })
  @ApiBearerAuth('jwt')
  @ApiBody({
    description:
      'Variables que necesita el endpoint. Las variables con "_" al inicio son opcionales.',
    examples: {
      ejemplo: {
        value: {
          id_modulo: 1,
          id_tipo_carrito: 1,
          _id_programa: 1,
          _id_tipo_entrada: 1,
        },
      },
    },
  })
  pedir(@Request() req, @Body() body: PedirDto) {
    const usuario: Usuario = req.user.usuario;

    this.validarUsuarioService.validarUsuario(usuario);
    return this.prestamoService.create(
      usuario,
      body.id_modulo,
      body.id_tipo_carrito,
      body.id_programa,
      body.id_tipo_entrada,
    );
  }

  @Serealize(PrestamoOutputDto)
  @Get('prestamo-id-prestamo')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Información de un préstamo por su id.' })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Id del préstamo.',
    name: 'id_prestamo',
    type: 'text',
  })
  prestamoIdPrestamo(@Request() req, @Query() query: IdPrestamoDto) {
    const usuarioOperador: Operador | Usuario =
      req.user.operador || req.user.usuario;

    if (usuarioOperador instanceof Usuario)
      this.validarUsuarioService.validarUsuario(usuarioOperador);
    else this.validarUsuarioService.validarSoloOperador(usuarioOperador);
    return this.prestamoService.prestamoInfoById(parseInt(query.id_prestamo));
  }

  @Serealize(PrestamoOutputDto)
  @Get('prestamo-id-usuario')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description: 'Información de un préstamo activo de un usuario.',
  })
  @ApiBearerAuth('jwt')
  prestamoIdUsuario(@Request() req) {
    const usuario: Usuario = req.user.usuario;

    this.validarUsuarioService.validarUsuario(usuario);
    return this.prestamoService.prestamoInfoByUsuario(usuario, false);
  }

  @Serealize(PrestamoEquipoOutputDto)
  @Get('prestamo-numero-inventario')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Información de un préstamo activo de un equipo por su número de inventario.',
  })
  @ApiQuery({
    description: 'El número de inventario del equipo.',
    name: 'numero_inventario',
    type: 'string',
  })
  prestamoNumeroInventario(
    @Request() req,
    @Query() query: NumeroInventarioDto,
  ) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarSoloOperador(operador);
    return this.prestamoService.prestamoInfoByNumeroInventario(
      operador,
      query.numero_inventario,
    );
  }

  @Serealize(MessageOutputDto)
  @Put('regresar-id-prestamo')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Endpoint que desactiva un préstamo.' })
  @ApiBearerAuth('jwt')
  @ApiBody({
    description: 'Variables que necesita el endpoint.',
    examples: {
      ejemplo: {
        value: {
          id_prestamo: 1,
          id_status: 1,
          _descripcion: '',
          _motivo: '',
          _id_institucion_infraccion: 603,
        },
      },
    },
  })
  regresarIdPrestamo(@Request() req, @Body() body: RegresarIdPrestamoDto) {
    const operador: Operador = req.user.operador;
    const modulo: Modulo = req.user.modulo;

    this.validarUsuarioService.validarSoloOperador(operador);
    return this.prestamoService.regresarIdPrestamo(
      operador,
      modulo,
      body.id_prestamo,
      body.id_status,
      body.motivo,
      body.descripcion,
      body.id_institucion_infraccion,
    );
  }

  @Serealize(MessageOutputDto)
  @Put('regresar-numero-inventario')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({ description: 'Endpoint que desactiva un préstamo.' })
  @ApiBearerAuth('jwt')
  @ApiBody({
    description: 'Variables que necesita el endpoint.',
    examples: {
      ejemplo: {
        value: {
          numero_inventario: '',
          id_status: 1,
          _descripcion: '',
          _motivo: '',
          _id_institucion_infraccion: 603,
        },
      },
    },
  })
  regresarNumeroInventario(
    @Request() req,
    @Body() body: RegresarNumeroInventarioDto,
  ) {
    const operador: Operador = req.user.operador;
    const modulo: Modulo = req.user.modulo;

    this.validarUsuarioService.validarSoloOperador(operador);
    return this.prestamoService.regresarNumeroInventario(
      operador,
      modulo,
      body.numero_inventario,
      body.id_status,
      body.motivo,
      body.descripcion,
      body.id_institucion_infraccion,
    );
  }

  @Serealize(ReporteOutputDto)
  @Get('reporte')
  @UseGuards(AuthGuard('jwt'))
  @ApiOperation({
    description:
      'Reporte de todos los préstamos dependiendo de los filtros enviados.',
  })
  @ApiBearerAuth('jwt')
  @ApiQuery({
    description: 'Boleano para obtener préstamos activos como filtro.',
    name: 'activo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description:
      'Boleano para obtener préstamos cancelados por operadores como filtro.',
    name: 'cancelado_operador',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description:
      'Boleano para obtener préstamos cancelados por usuarios como filtro.',
    name: 'cancelado_usuario',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Carrito que se quiere usar como filtro.',
    name: 'carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Equipo que se quiere usar como filtro.',
    name: 'equipo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Fecha fin se quiere usar como filtro.',
    name: 'fechaFin',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Fecha inicio que se quiere usar como filtro.',
    name: 'fechaInicio',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id de la institución que se quiere usar como filtro.',
    name: 'id_institucion',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id de la institución carrera que se quiere usar como filtro.',
    name: 'id_institucion_carrera',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del modulo que se quiere usar como filtro.',
    name: 'id_modulo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del operador de entrega que se quiere usar como filtro.',
    name: 'id_operador_entrega',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del operador de regreso que se quiere usar como filtro.',
    name: 'id_operador_regreso',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del préstamo que se quiere usar como filtro.',
    name: 'id_prestamo',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de carrito que se quiere usar como filtro.',
    name: 'id_tipo_carrito',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Id del tipo de usuario que se quiere usar como filtro.',
    name: 'id_tipo_usuario',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Página en la que se encuentra el usuario.',
    name: 'pagina',
    type: 'string',
    required: false,
  })
  @ApiQuery({
    description: 'Usuario que se quiere usar como filtro.',
    name: 'usuario',
    type: 'string',
    required: false,
  })
  reporte(@Request() req, @Query() query: ReporteDto) {
    const operador: Operador = req.user.operador;

    this.validarUsuarioService.validarOperador(operador);
    return this.prestamoService.findAll(query);
  }
}