se crearon endpoints para traer datos de los servicios por periodo

src/Operations/operations.controller.ts

@@ -2,33 +2,40 @@ import { Body, Controller, Post, Req, UseGuards } from '@nestjs/common';
 import { OperationsService } from './operations.services';
 import { chargePrintDto } from './dto/operations.dto';
 import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('operations')
 export class OperationsController {
-  constructor(private readonly operationsService: OperationsService) {}
+  constructor(private readonly operationsService: OperationsService) { }
 
-  @UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.ATENCION_USUARIOS, Role.PCPUMA, Role.SERVICIO_SOCIAL)
   @Post('impressions')
   async chargePrint(@Body() data: chargePrintDto, @Req() req: any) {
     const id_usuario = req.user.id;
     return this.operationsService.chargePrint(data, id_usuario);
   }
 
-  @UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.ATENCION_USUARIOS, Role.PCPUMA, Role.SERVICIO_SOCIAL)
   @Post('receipt')
   async addCredit(@Body() data, @Req() req: any) {
     const id_usuario = req.user.id;
     return this.operationsService.addCredit(data, id_usuario);
   }
 
-  @UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.SERVICIO_SOCIAL, Role.ATENCION_USUARIOS)
   @Post('registration')
   async addReceiptInscription(@Body() data, @Req() req: any) {
     const id_usuario = req.user.id;
     return this.operationsService.addReceiptInscription(data, id_usuario);
   }
 
-  @UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.SERVICIO_SOCIAL, Role.ATENCION_USUARIOS)
   @Post('time')
   async addTime(@Body() data, @Req() req: any) {
     const id_usuario = req.user.id;

src/alumno/student.controller.ts

@@ -11,28 +11,36 @@ import { Role } from 'src/role.enum';
 export class AlumnoController {
   constructor(private readonly alumnoService: AlumnoService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   async find() {
     return this.alumnoService.findAll()
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post()
   async create(@Body() createStudentDto: CreateStudentDto): Promise<Alumno> {
     return this.alumnoService.create(createStudentDto);
   }
 
-  //@UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL,Role.PCPUMA)
   @Get(':id')
   findOneWhitSancion(@Param('id') id: number) {
     return this.alumnoService.findOneWhitSancion(+id);
   }
 
-  //@UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL,Role.PCPUMA)
   @Get('sancion/:id')
   findOne(@Param('id') id: number) {
     return this.alumnoService.findOne(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('/create')
   async newStudent(@Body() createStudentDto: CreateStudentDto) {
     return this.alumnoService.create(createStudentDto);

src/alumno_inscrito/alumno_inscrito.controller.ts

@@ -1,44 +1,48 @@
-import { Controller, Get, Post, Body, Param, Patch } from '@nestjs/common';
+import { Controller, Get, Post, Body, Param, Patch, UseGuards, ParseIntPipe } from '@nestjs/common';
 import { AlumnoInscritoService } from './alumno_inscrito.service';
 import {
   CreateAlumnoInscritoDto,
 } from './dto/create-alumno_inscrito.dto';
 import { AlumnoInscrito } from './entities/alumno_inscrito.entity';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('alumno-inscrito')
 export class AlumnoInscritoController {
   constructor(private readonly alumnoInscritoService: AlumnoInscritoService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Post()
   async create(@Body() dto: CreateAlumnoInscritoDto): Promise<AlumnoInscrito> {
     return this.alumnoInscritoService.createWhitoutPay(dto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   async findAll(): Promise<AlumnoInscrito[]> {
     return this.alumnoInscritoService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get("/inscritos/:idPeriodo")
   async findAllInscritos(@Param('idPeriodo') idPeriodo: number) {
     return this.alumnoInscritoService.findAllInscritos(idPeriodo);
   }
 
-  // @Post('/tiempo')
-  // async addTime(@Body() body: AddTimeDto) {
-  //   const { idCuenta, idPlataforma, tiempoExtra } = body;
-  //   return this.alumnoInscritoService.(
-  //     idCuenta,
-  //     idPlataforma,
-  //     tiempoExtra,
-  //   );
-  // }
-
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('/plataforma')
   async findAllPlataforma() {
     return this.alumnoInscritoService.findAllPlataforma();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get(':id_cuenta')
   async findByIdWhitoud(
     @Param('id_cuenta') id_cuenta: number,
@@ -46,6 +50,8 @@ export class AlumnoInscritoController {
     return this.alumnoInscritoService.findByIdWhitoud(id_cuenta);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get(':id_cuenta/sancion')
   async findById(
     @Param('id_cuenta') id_cuenta: number,
@@ -53,17 +59,26 @@ export class AlumnoInscritoController {
     return this.alumnoInscritoService.findById(id_cuenta);
   }
 
-  //pruebas borrar
-  @Patch('platica/:idCuenta/:idPeriodo/:idPlataforma')
-  marcarPlatica(
-    @Param('idCuenta') idCuenta: number,
-    @Param('idPeriodo') idPeriodo: number,
-    @Param('idPlataforma') idPlataforma: number,
+@Get('inscritos/periodo/:inicio/:fin')
+  findByPeriodo(
+    @Param('inicio', ParseIntPipe) inicio: number,
+    @Param('fin', ParseIntPipe) fin: number,
   ) {
-    return this.alumnoInscritoService.marcarPlatica(
-      idCuenta,
-      idPeriodo,
-      idPlataforma,
-    );
+    return this.alumnoInscritoService.findAllInscritosByRango(inicio, fin, 'periodo');
+  }
+
+  @Get('inscritos/anio/:inicio/:fin')
+  findByAnio(
+    @Param('inicio', ParseIntPipe) inicio: number,
+    @Param('fin', ParseIntPipe) fin: number,
+  ) {
+    return this.alumnoInscritoService.findAllInscritosByRango(inicio, fin, 'anio');
+  }
+
+  @Get('inscritos/mes/:anio')
+  findByMes(
+    @Param('anio', ParseIntPipe) anio: number,
+  ) {
+    return this.alumnoInscritoService.findAllInscritosByRango(anio, 0, 'mes');
   }
 }

src/alumno_inscrito/alumno_inscrito.service.ts

@@ -61,31 +61,26 @@ export class AlumnoInscritoService {
       take: 100,
     });
   }
-
-  async findAllInscritos(idPeriodo: number) {
-    return this.alumnoInscritoRepo
-      .createQueryBuilder('inscritos')
-
-      .innerJoin('inscritos.alumno', 'alumno')
-      .innerJoin('alumno.carrera', 'carrera')
-      .innerJoin('inscritos.plataforma', 'plataforma')
-      .innerJoin('inscritos.periodo', 'periodo')
-
-      .where('periodo.id_periodo = :idPeriodo', { idPeriodo })
-
-      .select([
-        'carrera.carrera AS carrera',
-        'alumno.genero AS genero',
-        'plataforma.nombre AS profesor',
-        'COUNT(DISTINCT alumno.id_cuenta) AS total'
-      ])
-
-      .groupBy('carrera.carrera')
-      .addGroupBy('alumno.genero')
-      .addGroupBy('plataforma.nombre')
-
-      .getRawMany();
-  }
+async findAllInscritos(idPeriodo: number) {
+  return this.alumnoInscritoRepo
+    .createQueryBuilder('inscritos')
+    .innerJoin('inscritos.alumno', 'alumno')
+    .innerJoin('alumno.carrera', 'carrera')
+    .innerJoin('inscritos.plataforma', 'plataforma')
+    .innerJoin('inscritos.periodo', 'periodo')
+    .where('periodo.id_periodo = :idPeriodo', { idPeriodo })
+    .select([
+      'carrera.carrera AS carrera',
+      'periodo.semestre AS semestre',
+      'plataforma.nombre AS profesor',
+      'COUNT(DISTINCT CASE WHEN alumno.genero IN (\'F\', \'Femenino\') THEN alumno.id_cuenta END) AS femenino',
+      'COUNT(DISTINCT CASE WHEN alumno.genero IN (\'M\', \'Masculino\') THEN alumno.id_cuenta END) AS masculino',
+      'COUNT(DISTINCT alumno.id_cuenta) AS total' 
+    ])
+    .groupBy('carrera.carrera')
+    .addGroupBy('plataforma.nombre')
+    .getRawMany();
+}
 
   async findAllPlataforma() {
     return this.plataformaRepo.find();
@@ -199,7 +194,7 @@ export class AlumnoInscritoService {
     }
   }
 
-  //Borrar
+  
   async addTimeBorrar(
     idCuenta: number,
     idPlataforma: number,
@@ -236,4 +231,119 @@ export class AlumnoInscritoService {
     const create = repo.create(data);
     return await repo.save(create);
   }
+async findAllInscritosByRango(
+  inicio: number,
+  fin: number,
+  tipo: 'periodo' | 'mes' | 'anio',
+) {
+  const qb = this.alumnoInscritoRepo
+    .createQueryBuilder('inscritos')
+    .innerJoin('inscritos.alumno', 'alumno')
+    .innerJoin('alumno.carrera', 'carrera')
+    .innerJoin('inscritos.plataforma', 'plataforma')
+    .innerJoin('inscritos.periodo', 'periodo');
+
+  // ============================
+  // 🟢 PERIODO
+  // ============================
+  if (tipo === 'periodo') {
+    qb.where('periodo.id_periodo BETWEEN :inicio AND :fin', {
+      inicio,
+      fin,
+    });
+
+    qb.select([
+      'periodo.id_periodo AS id_periodo',
+      'periodo.semestre AS semestre',
+      'carrera.carrera AS carrera',
+      'plataforma.nombre AS profesor',
+
+      `COUNT(DISTINCT CASE 
+        WHEN alumno.genero IN ('F', 'Femenino') 
+        THEN alumno.id_cuenta 
+      END) AS femenino`,
+
+      `COUNT(DISTINCT CASE 
+        WHEN alumno.genero IN ('M', 'Masculino') 
+        THEN alumno.id_cuenta 
+      END) AS masculino`,
+
+      'COUNT(DISTINCT alumno.id_cuenta) AS total',
+    ]);
+
+    qb.groupBy('periodo.id_periodo')
+      .addGroupBy('carrera.carrera')
+      .addGroupBy('plataforma.nombre')
+      .orderBy('periodo.id_periodo', 'ASC');
+  }
+
+  // ============================
+  // 🔵 AÑO
+  // ============================
+  else if (tipo === 'anio') {
+    qb.where(
+      'periodo.fecha_inicio_servicio BETWEEN :inicio AND :fin',
+      {
+        inicio: `${inicio}-01-01`,
+        fin: `${fin}-12-31`,
+      },
+    );
+
+    qb.select([
+      'YEAR(periodo.fecha_inicio_servicio) AS semestre',
+      'carrera.carrera AS carrera',
+      'plataforma.nombre AS profesor',
+
+      `COUNT(DISTINCT CASE 
+        WHEN alumno.genero IN ('F', 'Femenino') 
+        THEN alumno.id_cuenta 
+      END) AS femenino`,
+
+      `COUNT(DISTINCT CASE 
+        WHEN alumno.genero IN ('M', 'Masculino') 
+        THEN alumno.id_cuenta 
+      END) AS masculino`,
+
+      'COUNT(DISTINCT alumno.id_cuenta) AS total',
+    ]);
+
+    qb.groupBy('YEAR(periodo.fecha_inicio_servicio)')
+      .addGroupBy('carrera.carrera')
+      .addGroupBy('plataforma.nombre')
+     .orderBy('YEAR(periodo.fecha_inicio_servicio)', 'ASC')
+  }
+
+  // ============================
+  // 🟡 MES (UN SOLO AÑO)
+  // ============================
+  else if (tipo === 'mes') {
+    qb.where('YEAR(periodo.fecha_inicio_servicio) = :anio', {
+      anio: inicio, // aquí "inicio" es el año
+    });
+
+qb.select([
+  'MONTH(periodo.fecha_inicio_servicio) AS semestre',
+  'carrera.carrera AS carrera',
+  'plataforma.nombre AS profesor',
+
+  `COUNT(DISTINCT CASE 
+    WHEN alumno.genero IN ('F', 'Femenino') 
+    THEN alumno.id_cuenta 
+  END) AS femenino`,
+
+  `COUNT(DISTINCT CASE 
+    WHEN alumno.genero IN ('M', 'Masculino') 
+    THEN alumno.id_cuenta 
+  END) AS masculino`,
+
+  'COUNT(DISTINCT alumno.id_cuenta) AS total',
+]);
+    qb.groupBy('MONTH(periodo.fecha_inicio_servicio)')
+      .addGroupBy('carrera.carrera')
+      .addGroupBy('plataforma.nombre')
+      .orderBy('YEAR(periodo.fecha_inicio_servicio)', 'ASC')
+  }
+
+  return qb.getRawMany();
 }
+}

src/alumno_sancion/alumno_sancion.controller.ts

@@ -1,21 +1,31 @@
-import { Body, Controller, Delete, Get, Param, Post } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Post, UseGuards } from '@nestjs/common';
 import { AlumnoSancionService } from './alumno_sancion.service';
 import { CreateAlumnoSancionDto } from './dto/create-alumno_sancion.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('alumno-sancion')
 export class AlumnoSancionController {
-  constructor(private readonly alumnoSancionService: AlumnoSancionService) {}
+  constructor(private readonly alumnoSancionService: AlumnoSancionService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post()
   async create(@Body() createAlumnoSancionDto: CreateAlumnoSancionDto) {
     return this.alumnoSancionService.create(createAlumnoSancionDto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findbyStudent(@Param('id') id: number) {
     return this.alumnoSancionService.findbyStudent(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Delete(':id_cuenta')
   async deleteSancionesAlumno(@Param('id_cuenta') id_cuenta: number) {
     return this.alumnoSancionService.removeByStudent(+id_cuenta);

src/alumno_sancion/alumno_sancion.service.ts

@@ -56,9 +56,6 @@ export class AlumnoSancionService {
       where: { alumno: { id_cuenta } },
     });
 
-    if (alusancion.length === 0) {
-      throw new NotFoundException(`El estudiante no cuenta con una sanción activa`);
-    }
     return { student, alusancion };
   }
 

src/area_ubicacion/area_ubicacion.controller.ts

@@ -1,22 +1,32 @@
-import { Controller, Get, Param } from '@nestjs/common';
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
 import { AreaUbicacionService } from './area_ubicacion.service';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('area-ubicacion')
 export class AreaUbicacionController {
-  constructor(private readonly areaUbicacionService: AreaUbicacionService) {}
+  constructor(private readonly areaUbicacionService: AreaUbicacionService) { }
 
-  @Get()
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
+  @Get()  
   findAll() {
     return this.areaUbicacionService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string) {
     return this.areaUbicacionService.findOne(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('/programs/:id')
-  findProgramsByArea(@Param('id')id:number){
+  findProgramsByArea(@Param('id') id: number) {
     return this.areaUbicacionService.findProgramsByArea(+id)
   }
 }

src/bitacora/bitacora.controller.ts

@@ -1,26 +1,38 @@
-import { Controller, Get, Post, Body, Param, Patch } from '@nestjs/common';
+import { Controller, Get, Post, Body, Param, Patch, UseGuards } from '@nestjs/common';
 import { BitacoraService } from './bitacora.service';
 import { BitacoraAlumnoDto, CreateBitacoraDto, EquiposPorEquipoDto } from './dto/create-bitacora.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('bitacora')
 export class BitacoraController {
   constructor(private readonly bitacoraService: BitacoraService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Post()
   assignment(@Body() createBitacoraDto: CreateBitacoraDto) {
     return this.bitacoraService.assignment(createBitacoraDto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/cuenta/:id')
   findOneByAcount(@Param('id') id: string) {
     return this.bitacoraService.findOneByAcount(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/equipo/:id')
   findOneByMachine(@Param('id') id: string) {
     return this.bitacoraService.findOneByMachine(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Patch('cancelar/:id')
   cancelationByMachine(
     @Param('id') id: number,
@@ -29,12 +41,15 @@ export class BitacoraController {
     return this.bitacoraService.cancelation(id, tiempo_asignado);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   findAll() {
     return this.bitacoraService.findAll();
   }
 
-
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('equipos-por-dia')
   async obtenerEquipos(
     @Body() dto: BitacoraAlumnoDto
@@ -45,6 +60,8 @@ export class BitacoraController {
     );
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('equipos-por-equipo')
   async equiposPorEquipo(
     @Body() dto: EquiposPorEquipoDto,

src/bitacora_mesa/bitacora_mesa.controller.ts

@@ -5,45 +5,63 @@ import {
   Body,
   Patch,
   Param,
-  Delete,
+  UseGuards,
 } from '@nestjs/common';
 import { BitacoraMesaService } from './bitacora_mesa.service';
 import { CreateBitacoraMesaDto, FindByDate } from './dto/create-bitacora_mesa.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('bitacora-mesa')
 export class BitacoraMesaController {
   constructor(private readonly bitacoraMesaService: BitacoraMesaService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Post()
   assignment(@Body() createBitacoraMesaDto: CreateBitacoraMesaDto) {
     return this.bitacoraMesaService.assignment(createBitacoraMesaDto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   findAll() {
     return this.bitacoraMesaService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string) {
     return this.bitacoraMesaService.findOne(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/cuenta/:id_cuenta')
   findByCuenta(@Param('id_cuenta') id_cuenta: string) {
     return this.bitacoraMesaService.findByCuenta(+id_cuenta);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/table/:id_mesa')
   findByTable(@Param('id_mesa') id_mesa: number) {
     return this.bitacoraMesaService.findByTable(id_mesa);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('/date')
   findByDate(@Body() data: FindByDate) {
     return this.bitacoraMesaService.findByDate(data.date);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Patch('cancelar/:id')
   cancelationByMachine(
     @Param('id') id: number,
@@ -52,6 +70,8 @@ export class BitacoraMesaController {
     return this.bitacoraMesaService.cancelation(id, tiempo_asignado);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('mesas-por-dia')
   mesasPorDia(@Body() body: { fecha: string }) {
     return this.bitacoraMesaService.mesasPorFecha(body.fecha);

src/carrera/carrera.controller.ts

@@ -1,11 +1,17 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, UseGuards } from '@nestjs/common';
 import { CarreraService } from './carrera.service';
 import { Carrera } from './entities/carrera.entity';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('carrera')
 export class CarreraController {
-  constructor(private readonly carreraService: CarreraService) {}
+  constructor(private readonly carreraService: CarreraService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get()
   findAll(): Promise<Carrera[]> {
     return this.carreraService.findAll();

src/costo/costo.controller.ts

@@ -1,13 +1,25 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
 import { CostoService } from './costo.service';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Role } from 'src/role.enum';
+import { Roles } from 'src/roles.decorator';
 
 @Controller('costo')
 export class CostoController {
-  constructor(private readonly costoService: CostoService) {}
+  constructor(private readonly costoService: CostoService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL,Role.PCPUMA)
   @Get()
   findAll() {
     return this.costoService.findAll();
   }
-
+  
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
+  @Get('/:id_servicio')
+  find(@Param('id_servicio') id_servicio: number) {
+    return this.costoService.find(id_servicio);
+  }
 }

src/costo/costo.service.ts

@@ -6,9 +6,14 @@ import { Repository } from 'typeorm';
 @Injectable()
 export class CostoService {
   constructor(@InjectRepository(Costo)
-  private readonly CostoRepository: Repository<Costo>) { }
+  private readonly CostoRepository: Repository<Costo>) {}
+  
   findAll() {
     return this.CostoRepository.find();
   }
 
+  find(id_servicio: number) {
+    return this.CostoRepository.find({ where: { id_servicio } });
+  }
+
 }

src/detalle_servicio/detalle_servicio.controller.ts

@@ -1,20 +1,40 @@
-import { Body, Controller, Get, Post } from '@nestjs/common';
+import { Body, Controller, Get, Post, Query, UseGuards } from '@nestjs/common';
 import { DetalleServicioService } from './detalle_servicio.service';
 import { FindReciboByRangeDto } from 'src/recibo/dto/create-recibo.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 
 @Controller('detalle-servicio')
 export class DetalleServicioController {
-  constructor(private readonly detalleServicioService: DetalleServicioService) {}
+  constructor(private readonly detalleServicioService: DetalleServicioService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
-  findAll(){
+  findAll() {
     return this.detalleServicioService.findAll()
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('rango')
   async findByDateRange(@Body() data: FindReciboByRangeDto) {
     return this.detalleServicioService.findByDateRange(data.desde, data.hasta);
   }
 
+
+@Get('totales-por-periodo')
+async getTotalesPorPeriodo(
+  @Query('periodoInicio') periodoInicio?: string,
+  @Query('periodoFin') periodoFin?: string,
+  @Query('servicioId') servicioId?: string,
+) {
+  const inicio = periodoInicio ? parseInt(periodoInicio) : undefined;
+  const fin = periodoFin ? parseInt(periodoFin) : undefined;
+  const servicio = servicioId ? parseInt(servicioId) : undefined;
+  return this.detalleServicioService.getTotalesPorServicioYPeriodo(inicio, fin, servicio);
+}
 }

src/detalle_servicio/detalle_servicio.service.ts

@@ -35,4 +35,42 @@ export class DetalleServicioService {
       .addGroupBy('servicio.servicio')
       .getRawMany();
   }
+
+async getTotalesPorServicioYPeriodo(periodoInicio?: number, periodoFin?: number, servicioId?: number) {
+  const query = this.detalleServicioRepository
+    .createQueryBuilder('ds')
+    .select('s.servicio', 'nombre_servicio')
+    .addSelect('p.semestre', 'periodo')
+    .addSelect('p.id_periodo', 'id_periodo')
+    .addSelect('SUM(ds.monto)', 'monto_total')
+    .innerJoin('ds.servicio', 's')
+    .innerJoin('ds.periodo', 'p');
+
+  if (periodoInicio && periodoFin) {
+    query.andWhere('p.id_periodo BETWEEN :inicio AND :fin', { inicio: periodoInicio, fin: periodoFin });
+  } else if (periodoInicio) {
+    query.andWhere('p.id_periodo >= :inicio', { inicio: periodoInicio });
+  } else if (periodoFin) {
+    query.andWhere('p.id_periodo <= :fin', { fin: periodoFin });
+  }
+
+  if (servicioId) {
+    query.andWhere('s.id_servicio = :servicioId', { servicioId });
+  }
+
+  const resultados = await query
+    .groupBy('s.id_servicio')
+    .addGroupBy('p.id_periodo')
+    .orderBy('p.id_periodo')
+    .addOrderBy('s.servicio')
+    .getRawMany();
+
+  return resultados.map(item => ({
+    nombre_servicio: item.nombre_servicio,
+    periodo: item.periodo,
+    monto_total: parseFloat(item.monto_total) || 0,
+  }));
 }
+  
+}
+//IO

src/equipo/equipo.controller.ts

@@ -1,57 +1,81 @@
-import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common';
+import { Body, Controller, Get, Param, Patch, Post, UseGuards } from '@nestjs/common';
 import { EquipoService } from './equipo.service';
 import { Equipo } from './entities/equipo.entity';
 import { CreateEquipoDto, UpdateAreaEquiposDto } from './dto/create-equipo.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('equipo')
 export class EquipoController {
   constructor(private readonly equipoService: EquipoService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
   @Get()
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.ATENCION_USUARIOS, Role.SERVICIO_SOCIAL)
   findAll(): Promise<Equipo[]> {
     return this.equipoService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/active')
   findActive() {
     return this.equipoService.findActive();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('/disable')
   findDisable() {
     return this.equipoService.findDisable();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('/student/:id')
   findOnlyUsable(@Param('id') id: number): Promise<Equipo[]> {
     return this.equipoService.findOnlyUsable(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('/busy')
   findOnlyBusy(): Promise<Equipo[]> {
     return this.equipoService.findOnlyBusy();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string): Promise<Equipo> {
     return this.equipoService.findOne(id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post()
   create(@Body() equipo: CreateEquipoDto) {
     return this.equipoService.create(equipo);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Patch()
   update(@Body() equipo: CreateEquipoDto) {
     return this.equipoService.update(equipo);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR, Role.ATENCION_USUARIOS, Role.SERVICIO_SOCIAL)
   @Patch(':id/activo')
   toggleActivo(@Param('id') id: number) {
     return this.equipoService.toggleActivo(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Patch('actualizar-area')
   actualizarPorArea(
     @Body() updateAreaEquiposDto: UpdateAreaEquiposDto,

src/mensaje/mensaje.controller.ts

@@ -1,17 +1,22 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
 import { MensajeService } from './mensaje.service';
-import { CreateMensajeDto } from './dto/create-mensaje.dto';
-import { UpdateMensajeDto } from './dto/update-mensaje.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('mensaje')
 export class MensajeController {
-  constructor(private readonly mensajeService: MensajeService) {}
+  constructor(private readonly mensajeService: MensajeService) { }
 
-  @Get()
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Get()  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   findAll() {
     return this.mensajeService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string) {
     return this.mensajeService.findOne(+id);

src/mesa/mesa.controller.ts

@@ -1,26 +1,38 @@
-import { Controller, Body, Patch, Param, Get } from '@nestjs/common';
+import { Controller, Body, Patch, Param, Get, UseGuards } from '@nestjs/common';
 import { MesaService } from './mesa.service';
 import { UpdateMesaDto } from './dto/update-mesa.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Role } from 'src/role.enum';
+import { Roles } from 'src/roles.decorator';
 
 @Controller('mesa')
 export class MesaController {
   constructor(private readonly mesaService: MesaService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get()
   async findAll() {
     return this.mesaService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('activo')
   async findAllActivo() {
     return this.mesaService.findAllActivo();
   }
-
+  
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Get('uso')
   async findActiveMesas() {
     return this.mesaService.findActiveMesas();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Patch(':id')
   async updateActivo(
     @Param('id') id: number,
@@ -29,6 +41,8 @@ export class MesaController {
     return this.mesaService.updateActivo(id, updateMesaDto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR,Role.ATENCION_USUARIOS,Role.SERVICIO_SOCIAL)
   @Patch(':id/activo')
   toggleActivo(@Param('id') id: number) {
     return this.mesaService.toggleActivo(+id);

src/periodo/periodo.controller.ts

@@ -1,28 +1,59 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, Put } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Put, Query, UseGuards } from '@nestjs/common';
 import { PeriodoService } from './periodo.service';
 import { CreatePeriodoDto, ModifiedDateDto } from './dto/create-periodo.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('periodo')
 export class PeriodoController {
     constructor(private readonly periodoService: PeriodoService) { }
 
+    @UseGuards(JwtAuthGuard, RolesGuard)
+    @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
     @Get()
     findAll() {
         return this.periodoService.findAll();
     }
 
+    @UseGuards(JwtAuthGuard, RolesGuard)
+    @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
     @Post()
-    create(@Body() data: CreatePeriodoDto) {
+    create(@Body() data: CreatePeriodoDto) {    
         return this.periodoService.create(data);
     }
 
+    @UseGuards(JwtAuthGuard, RolesGuard)
+    @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
     @Delete("/:id_periodo")
     delete(@Param("id_periodo") id_periodo: number) {
         return this.periodoService.delete(id_periodo)
     }
 
+    @UseGuards(JwtAuthGuard, RolesGuard)
+    @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
     @Patch("/date/:id_periodo")
     modifiedDate(@Body() data: ModifiedDateDto, @Param("id_periodo") id_periodo: number) {
         return this.periodoService.modifiedDate(data, id_periodo)
     }
+
+    @UseGuards(JwtAuthGuard, RolesGuard)
+@Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
+@Get('compare')
+compare(
+  @Query('p1') p1: number,
+  @Query('p2') p2: number,
+) {
+  return this.periodoService.comparePeriodos(p1, p2);
+}
+
+@Get('range')
+getRange(
+  @Query('p1') p1: number,
+  @Query('p2') p2: number,
+) {
+  return this.periodoService.getPeriodosEnRango(p1, p2);
+}
+    
 }

src/periodo/periodo.service.ts

@@ -1,7 +1,7 @@
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Periodo } from './entities/periodo.entity';
-import { Repository } from 'typeorm';
+import { Between, Repository } from 'typeorm';
 import { CreatePeriodoDto, ModifiedDateDto } from './dto/create-periodo.dto';
 
 @Injectable()
@@ -16,7 +16,7 @@ export class PeriodoService {
   }
 
   async findAll() {
-    return this.periodoRepository.find();
+    return this.periodoRepository.find({order:{'id_periodo':"DESC"}});
   }
 
   async getPeriodoActivo(): Promise<Periodo> {
@@ -32,7 +32,7 @@ export class PeriodoService {
     return periodo;
   }
 
-    async getPeriodoActivoWhitoutError(): Promise<Periodo | null> {
+  async getPeriodoActivoWhitoutError(): Promise<Periodo | null> {
     const periodo = await this.periodoRepository.findOne({
       where: { activo: true },
       order: { id_periodo: 'DESC' },
@@ -45,7 +45,7 @@ export class PeriodoService {
     await this.periodoRepository.delete(id_periodo)
   }
 
-  async periodoDisable(id_periodo:number) {
+  async periodoDisable(id_periodo: number) {
     await this.periodoRepository.update(id_periodo, { activo: false })
   }
 
@@ -58,7 +58,7 @@ export class PeriodoService {
 
     const periodoActive = await this.getPeriodoActivoWhitoutError();
 
-    if(periodoActive){
+    if (periodoActive) {
       await this.periodoDisable(periodoActive.id_periodo)
     }
 
@@ -66,7 +66,53 @@ export class PeriodoService {
     return this.periodoRepository.save(create)
   }
 
-  async modifiedDate(data:ModifiedDateDto,id_periodo){
-    return this.periodoRepository.update(id_periodo,data)
+  async modifiedDate(data: ModifiedDateDto, id_periodo) {
+    return this.periodoRepository.update(id_periodo, data)
   }
+
+  async comparePeriodos(id1: number, id2: number) {
+  const periodo1 = await this.periodoRepository.findOne({
+    where: { id_periodo: id1 },
+  });
+
+  const periodo2 = await this.periodoRepository.findOne({
+    where: { id_periodo: id2 },
+  });
+
+  if (!periodo1 || !periodo2) {
+    throw new NotFoundException('Uno de los periodos no existe');
+  }
+
+  return {
+    periodo1: {
+      id: periodo1.id_periodo,
+      nombre: periodo1.semestre,
+      fecha_inicio: periodo1.fecha_inicio_servicio,
+      fecha_fin: periodo1.fecha_fin_servicio,
+    },
+    periodo2: {
+      id: periodo2.id_periodo,
+      nombre: periodo2.semestre,
+      fecha_inicio: periodo2.fecha_inicio_servicio,
+      fecha_fin: periodo2.fecha_fin_servicio,
+    },
+  };
 }
+
+async getPeriodosEnRango(id1: number, id2: number) {
+  const min = Math.min(id1, id2);
+  const max = Math.max(id1, id2);
+
+  return this.periodoRepository.find({
+    where: {
+      id_periodo: Between(min, max),
+    },
+    order: {
+      id_periodo: 'ASC',
+    },
+  });
+}
+  
+}
+
+

src/programa/programa.controller.ts

@@ -1,31 +1,45 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { Controller, Get, Post, Body, Patch, Param, Delete, UseGuards } from '@nestjs/common';
 import { ProgramaService } from './programa.service';
 import { UpdateProgramaDto } from './dto/update-programa.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('programa')
 export class ProgramaController {
   constructor(private readonly programaService: ProgramaService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   findAll() {
     return this.programaService.findAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string) {
     return this.programaService.findOne(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post()
   create(@Body() body) {
     return this.programaService.create(body);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Patch(':id')
   update(@Param('id') id: string, @Body() updateProgramaDto: UpdateProgramaDto) {
     return this.programaService.update(+id, updateProgramaDto);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Delete(':id')
   delete(@Param('id') id:string){
     return this.programaService.delete(+id);

src/programa_equipo/programa_equipo.controller.ts

@@ -1,26 +1,39 @@
-import { Controller, Get, Body, Patch, Param } from '@nestjs/common';
+import { Controller, Get, Body, Patch, Param, UseGuards } from '@nestjs/common';
 import { ProgramaEquipoService } from './programa_equipo.service';
 import { UpdateProgramaEquipoDto, UpdateProgramasSalaDto } from './dto/update-programa_equipo.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('programa-equipo')
 export class ProgramaEquipoController {
-  constructor(private readonly programaEquipoService: ProgramaEquipoService) {}
+  constructor(private readonly programaEquipoService: ProgramaEquipoService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('programas/:id')
   findAllProgramByNumber(@Param('id') id: number) {
     return this.programaEquipoService.findAllProgramByNumber(+id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
+
   @Get('ubicacion/:id')
   findAllProgramByUbicacion(@Param('id') id: string) {
     return this.programaEquipoService.findAllProgramByUbication(id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: string) {
     return this.programaEquipoService.findOne(id);
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Patch('equipo/:id')
   updateMachine(
     @Param('id') id: string,
@@ -32,6 +45,8 @@ export class ProgramaEquipoController {
     );
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Patch('sala')
   updateBySala(@Body() dto: UpdateProgramasSalaDto) {
     return this.programaEquipoService.updateBySala(dto.sala, dto.programas);

src/recibo/recibo.controller.ts

@@ -3,15 +3,20 @@ import {
   Post,
   Body,
   UseGuards,
-  Req,
 } from '@nestjs/common';
 import { ReciboService } from './recibo.service';
 import { FindReciboByRangeDto } from './dto/create-recibo.dto';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('recibo')
 export class ReciboController {
-  constructor(private readonly reciboService: ReciboService) {}
+  constructor(private readonly reciboService: ReciboService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('rango')
   async findByDateRange(@Body() data: FindReciboByRangeDto) {
     return this.reciboService.findByDateRange(data.desde, data.hasta);

src/role.enum.ts

@@ -1,5 +1,7 @@
-
 export enum Role {
-  ADMINISTRADOR = 'ADMINISTRADOR',
-  OPERADOR = 'OPERADOR',
-}
+  ADMINISTRADOR = 1,
+  ATENCION_USUARIOS = 2,
+  SERVICIO_SOCIAL = 3,
+  SUPER_ADMINISTRADOR = 4,
+  PCPUMA = 5,
+}

src/roles.guard.ts

@@ -6,7 +6,7 @@ import { ROLES_KEY } from './roles.decorator';
 
 @Injectable()
 export class RolesGuard implements CanActivate {
-  constructor(private reflector: Reflector) {}
+  constructor(private reflector: Reflector) { }
 
   canActivate(context: ExecutionContext): boolean {
     const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, [
@@ -17,6 +17,6 @@ export class RolesGuard implements CanActivate {
       return true;
     }
     const { user } = context.switchToHttp().getRequest();
-    return requiredRoles.some((role) => user.role?.includes(role));
+    return requiredRoles.some((role) => user.role === role);
   }
 }

src/sancion/sancion.controller.ts

@@ -1,14 +1,22 @@
-import { Controller, Get, Param } from '@nestjs/common';
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
 import { SancionService } from './sancion.service';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 @Controller('sancion')
 export class SancionController {
-  constructor(private readonly sancionService: SancionService) {}
+  constructor(private readonly sancionService: SancionService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   find() {
     return this.sancionService.find();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get(':id')
   findOne(@Param('id') id: number) {
     return this.sancionService.findOne(+id);

src/servicio/servicio.controller.ts

@@ -1,9 +1,16 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, UseGuards } from '@nestjs/common';
 import { ServicioService } from './servicio.service';
+import { JwtAuthGuard } from 'src/user/jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('servicio')
 export class ServicioController {
-  constructor(private readonly servicioService: ServicioService) {}
+  constructor(private readonly servicioService: ServicioService) { }
+
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   findAll() {
     return this.servicioService.findAll();

src/user/user.controller.ts

@@ -4,7 +4,6 @@ import {
   Post,
   Body,
   UseGuards,
-  Request,
   Res,
   Req,
 } from '@nestjs/common';
@@ -12,16 +11,23 @@ import type { Response } from 'express';
 import { UserService } from './user.service';
 import { changePasswordDto, CreateUserDto, Login } from './dto/create-user.dto';
 import { JwtAuthGuard } from './jwt.guard';
+import { RolesGuard } from 'src/roles.guard';
+import { Roles } from 'src/roles.decorator';
+import { Role } from 'src/role.enum';
 
 @Controller('user')
 export class UserController {
-  constructor(private readonly userService: UserService) {}
+  constructor(private readonly userService: UserService) { }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get()
   async getAll() {
     return this.userService.getAll();
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Get('/perfil')
   async getAllPerfil() {
     return this.userService.getAllPerfil();
@@ -38,12 +44,15 @@ export class UserController {
     return req.user.role;
   }
 
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('/create')
   async createUser(@Body() data: CreateUserDto) {
     return this.userService.create(data);
   }
 
-  @UseGuards(JwtAuthGuard)
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.ADMINISTRADOR, Role.SUPER_ADMINISTRADOR)
   @Post('/changePassword')
   async changePassword(@Body() data: changePasswordDto, @Req() req) {
     const id_usuario = req.user.id;

src/user/user.service.ts

@@ -40,14 +40,14 @@ export class UserService {
 
     const payload = {
       id: user.id_usuario,
-      usuario: user.usuario,
+      usuario: user.nombre,
       role: user.perfil.id_perfil,
     };
     const token = await this.jwtService.signAsync(payload);
 
     res.cookie('token', token, {
       httpOnly: true,
-      secure: process.env.NODE_ENV === 'production', // en dev desactívalo
+      secure: process.env.NODE_ENV === 'production',
       sameSite: 'strict',
       path: '/',
     });