institucion programa service final

src/institucion-infraccion/institucion-infraccion.service.ts

@@ -37,7 +37,7 @@ export class InstitucionInfraccionService {
       .then(async (infraccion) => {
         const instituciones = await this.institucionService.findAll();
 
-        // Asociamos las nueva infracción con las instituciones
+        // Asociamos la nueva infracción con las instituciones existentes
         for (let i = 0; i < instituciones.length; i++)
           await this.institucionInfraccionRepository.save(
             this.institucionInfraccionRepository.create({
@@ -96,7 +96,7 @@ export class InstitucionInfraccionService {
           institucionInfraccion.institucion.id_institucion
         )
           throw new ConflictException(
-            'No puedes modificar la información este infracción porque no pertenece a tu institución.',
+            'No puedes modificar la información esta infracción porque no pertenece a tu institución.',
           );
         // Asignamos valores enviados al objeto
         Object.assign(institucionInfraccion, attrs);

src/institucion-programa/entity/institucion-programa.entity.ts

@@ -22,7 +22,9 @@ export class InstitucionPrograma {
   @Column({ type: Number, nullable: true })
   id_programa: number;
 
-  @ManyToOne(() => Institucion, (institucion) => institucion.programas)
+  @ManyToOne(() => Institucion, (institucion) => institucion.programas, {
+    eager: true,
+  })
   @JoinColumn({ name: 'id_institucion' })
   institucion: Institucion;
 

src/institucion-programa/institucion-programa.controller.ts

@@ -62,7 +62,7 @@ export class InstitucionProgramaController {
     const superAdmin: Operador = req.user.operador;
 
     this.validarUsuarioService.validarSuperAdmin(superAdmin);
-    return this.institucionProgramaService.findAllProgramas();
+    return this.institucionProgramaService.findAll();
   }
 
   @Serealize(InstitucionProgramaOutputDto)
@@ -76,9 +76,7 @@ export class InstitucionProgramaController {
     const operador: Operador = req.user.operador;
 
     this.validarUsuarioService.validarAdminOperador(operador);
-    return this.institucionProgramaService.findAllByIdInstitucion(
-      operador.institucion.id_institucion,
-    );
+    return this.institucionProgramaService.findAllOperador(operador);
   }
 
   @Serealize(InstitucionProgramaMinOutputDto)
@@ -97,9 +95,9 @@ export class InstitucionProgramaController {
     const usuario: Usuario = req.user.usuario;
 
     this.validarUsuarioService.validarUsuario(usuario);
-    return this.institucionProgramaService.findAllByIdInstitucion(
+    return this.institucionProgramaService.findAllMostrar(
+      usuario,
       parseInt(query.id_institucion),
-      true,
     );
   }
 

src/institucion-programa/institucion-programa.module.ts

@@ -6,10 +6,12 @@ import { InstitucionProgramaService } from './institucion-programa.service';
 import { InstitucionPrograma } from './entity/institucion-programa.entity';
 import { Programa } from './entity/programa.entity';
 import { InstitucionModule } from '../institucion/institucion.module';
+import { InstitucionUsuarioModule } from '../institucion-usuario/institucion-usuario.module';
 
 @Module({
   imports: [
     InstitucionModule,
+    InstitucionUsuarioModule,
     PassportModule.register({ defaultStrategy: 'jwt' }),
     TypeOrmModule.forFeature([InstitucionPrograma, Programa]),
   ],

src/institucion-programa/institucion-programa.service.ts

@@ -1,5 +1,6 @@
 import {
   ConflictException,
+  ForbiddenException,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -9,6 +10,8 @@ import { InstitucionPrograma } from './entity/institucion-programa.entity';
 import { Operador } from '../operador/entity/operador.entity';
 import { Programa } from './entity/programa.entity';
 import { InstitucionService } from '../institucion/institucion.service';
+import { InstitucionUsuarioService } from '../institucion-usuario/institucion-usuario.service';
+import { Usuario } from '../usuario/entity/usuario.entity';
 
 @Injectable()
 export class InstitucionProgramaService {
@@ -18,10 +21,11 @@ export class InstitucionProgramaService {
     @InjectRepository(Programa)
     private programaRepository: Repository<Programa>,
     private institucionService: InstitucionService,
+    private institucionUsuarioService: InstitucionUsuarioService,
   ) {}
 
-  create(programa: string) {
-    // Buscamos un programa con ese nombre
+  create(programa: string): Promise<{ message: string }> {
+    // Buscamos un registro con ese nombre
     return this.programaRepository
       .findOne({ where: { programa } })
       .then((existePrograma) => {
@@ -36,7 +40,7 @@ export class InstitucionProgramaService {
       .then(async (programa) => {
         const instituciones = await this.institucionService.findAll();
 
-        // Le asigno el nuevo programa a todas las instituciones
+        // Asociamos la nueva infracción con las instituciones existentes
         for (let i = 0; i < instituciones.length; i++)
           await this.institucionProgramaRepository.save(
             this.institucionProgramaRepository.create({
@@ -48,39 +52,47 @@ export class InstitucionProgramaService {
       });
   }
 
-  async findAllByIdInstitucion(id_institucion: number, mostrar = false) {
-    const institucion = await this.institucionService.findById(id_institucion);
-    const query = this.institucionProgramaRepository
-      .createQueryBuilder('ip')
-      .innerJoinAndSelect('ip.programa', 'p', 'p.id_programa != 1')
-      .innerJoinAndSelect(
-        'ip.institucion',
-        'i',
-        'i.id_institucion = :id_institucion',
-        { id_institucion: institucion.id_institucion },
-      )
-      .orderBy('p.programa');
-
-    if (mostrar) query.andWhere('ip.mostrar = 1');
-    return query.getMany();
-  }
-
-  findAllProgramas() {
+  findAll(): Promise<Programa[]> {
     return this.programaRepository.find({
       where: { id_programa: Not(1) },
       order: { programa: 'ASC' },
     });
   }
 
-  findById(id_institucion_programa: number) {
+  async findAllMostrar(
+    usuario: Usuario,
+    id_institucion: number,
+  ): Promise<InstitucionPrograma[]> {
+    const institucion = await this.institucionService.findById(id_institucion);
+    const institucionUsuario =
+      await this.institucionUsuarioService.findByIdUsuarioIdInstitucion(
+        usuario,
+        institucion,
+      );
+
+    if (!institucionUsuario)
+      throw new ForbiddenException(
+        'No puedes acceder a esta información porque no peteneces a esta institución.',
+      );
+    return this.institucionProgramaRepository.find({
+      where: { mostrar: true, institucion, programa: { id_programa: Not(1) } },
+      order: { programa: { programa: 'ASC' } },
+    });
+  }
+
+  async findAllOperador(operador: Operador): Promise<InstitucionPrograma[]> {
+    return this.institucionProgramaRepository.find({
+      where: {
+        institucion: operador.institucion,
+        programa: { id_programa: Not(1) },
+      },
+      order: { programa: { programa: 'ASC' } },
+    });
+  }
+
+  findById(id_institucion_programa: number): Promise<InstitucionPrograma> {
     return this.institucionProgramaRepository
-      .findOne({
-        join: {
-          alias: 'ip',
-          innerJoinAndSelect: { i: 'ip.institucion', p: 'ip.programa' },
-        },
-        where: { id_institucion_programa },
-      })
+      .findOne({ where: { id_institucion_programa } })
       .then((institucionPrograma) => {
         if (!institucionPrograma)
           throw new NotFoundException('No existe esta institucion programa.');
@@ -88,7 +100,7 @@ export class InstitucionProgramaService {
       });
   }
 
-  findProgramaById(id_programa: number) {
+  findProgramaById(id_programa: number): Promise<Programa> {
     return this.programaRepository
       .findOne({ where: { id_programa } })
       .then((programa) => {
@@ -97,27 +109,23 @@ export class InstitucionProgramaService {
       });
   }
 
-  findProgramaByPrograma(programa: string, validarNoExiste = true) {
-    return this.programaRepository
-      .findOne({ where: { programa } })
-      .then((programa) => {
-        if (validarNoExiste && !programa)
-          throw new NotFoundException('No existe este programa.');
-        return programa;
-      });
+  findProgramaByPrograma(programa: string): Promise<Programa> {
+    return this.programaRepository.findOne({ where: { programa } });
   }
 
-  update(admin: Operador, attrs: Partial<InstitucionPrograma>) {
+  update(
+    admin: Operador,
+    attrs: Partial<InstitucionPrograma>,
+  ): Promise<{ message: string }> {
     return this.findById(attrs.id_institucion_programa)
       .then((institucionPrograma) => {
-        // Validamos que la institucionPrograma le pertenezca al operador que
-        // realiza esta acción
+        // Validamos que la institucion programa pertenezca a la institución del admin
         if (
           admin.institucion.id_institucion !=
           institucionPrograma.institucion.id_institucion
         )
           throw new ConflictException(
-            'No puedes actualizar la información de este software porque no le pertenece a tu institución.',
+            'No puedes modificar la información este software porque no pertenece a tu institución.',
           );
         // Asignamos valores enviados al objeto
         Object.assign(institucionPrograma, attrs);

src/upload-file/upload-file.service.ts

@@ -309,7 +309,6 @@ export class UploadFileService {
             const programa =
               await this.institucionProgramaService.findProgramaByPrograma(
                 programas[j].trim(),
-                false,
               );
             const existeEquipoPrograma = programa
               ? await this.equipoProgramaService.findByEquipoPrograma(