From d49cfb56e8c6afa0f85f8cca9c9c9be0dec514fa Mon Sep 17 00:00:00 2001 From: tyrannusss Date: Wed, 17 Sep 2025 14:35:12 -0600 Subject: [PATCH 1/2] 1 --- src/alumno/dto/create-student.dto.ts | 2 ++ src/alumno/student.service.ts | 1 + 2 files changed, 3 insertions(+) diff --git a/src/alumno/dto/create-student.dto.ts b/src/alumno/dto/create-student.dto.ts index 130445e..8aae090 100644 --- a/src/alumno/dto/create-student.dto.ts +++ b/src/alumno/dto/create-student.dto.ts @@ -20,3 +20,5 @@ export class CreateStudentDto { @IsString() correo: string; } + +//Hubo pedos con la base , revisar diff --git a/src/alumno/student.service.ts b/src/alumno/student.service.ts index d14dc03..cf5dc91 100644 --- a/src/alumno/student.service.ts +++ b/src/alumno/student.service.ts @@ -13,6 +13,7 @@ export class StudentService { ) {} async create(createStudentDto: CreateStudentDto): Promise { + //Hubo pedos con la base , revisar const student = this.studentRepository.create(createStudentDto); return await this.studentRepository.save(student); } From 54306452abdd348b34a35edf7cbc92b3ae0e61c4 Mon Sep 17 00:00:00 2001 From: tyrannusss Date: Wed, 17 Sep 2025 16:35:52 -0600 Subject: [PATCH 2/2] Creacion de entities y servicios --- src/Operations/operations.services.ts | 13 +++-- src/alumno/entities/student.entity.ts | 47 +++++++++++++++++-- src/alumno/student.controller.ts | 18 +++---- src/alumno/student.module.ts | 4 +- src/alumno/student.service.ts | 2 +- .../alumno_sancion.controller.spec.ts | 20 ++++++++ .../alumno_sancion.controller.ts | 34 ++++++++++++++ src/alumno_sancion/alumno_sancion.module.ts | 9 ++++ .../alumno_sancion.service.spec.ts | 18 +++++++ src/alumno_sancion/alumno_sancion.service.ts | 41 ++++++++++++++++ .../dto/create-alumno_sancion.dto.ts | 15 ++++++ .../dto/update-alumno_sancion.dto.ts | 4 ++ .../entities/alumno_sancion.entity.ts | 45 ++++++++++++++++++ src/app.module.ts | 17 ++++++- .../entities/detalle_servicio.entity.ts | 43 +++++++++++++---- src/periodo/entities/periodo.entity.ts | 9 +++- src/sancion/dto/create-sancion.dto.ts | 12 +++++ src/sancion/dto/update-sancion.dto.ts | 4 ++ src/sancion/entities/sancion.entity.ts | 20 ++++++++ src/sancion/sancion.controller.spec.ts | 20 ++++++++ src/sancion/sancion.controller.ts | 34 ++++++++++++++ src/sancion/sancion.module.ts | 9 ++++ src/sancion/sancion.service.spec.ts | 18 +++++++ src/sancion/sancion.service.ts | 26 ++++++++++ src/servicio/entities/servicio.entity.ts | 8 +++- src/user/entities/user.entity.ts | 9 +++- 26 files changed, 460 insertions(+), 39 deletions(-) create mode 100644 src/alumno_sancion/alumno_sancion.controller.spec.ts create mode 100644 src/alumno_sancion/alumno_sancion.controller.ts create mode 100644 src/alumno_sancion/alumno_sancion.module.ts create mode 100644 src/alumno_sancion/alumno_sancion.service.spec.ts create mode 100644 src/alumno_sancion/alumno_sancion.service.ts create mode 100644 src/alumno_sancion/dto/create-alumno_sancion.dto.ts create mode 100644 src/alumno_sancion/dto/update-alumno_sancion.dto.ts create mode 100644 src/alumno_sancion/entities/alumno_sancion.entity.ts create mode 100644 src/sancion/dto/create-sancion.dto.ts create mode 100644 src/sancion/dto/update-sancion.dto.ts create mode 100644 src/sancion/entities/sancion.entity.ts create mode 100644 src/sancion/sancion.controller.spec.ts create mode 100644 src/sancion/sancion.controller.ts create mode 100644 src/sancion/sancion.module.ts create mode 100644 src/sancion/sancion.service.spec.ts create mode 100644 src/sancion/sancion.service.ts diff --git a/src/Operations/operations.services.ts b/src/Operations/operations.services.ts index e609e3d..44e55a0 100644 --- a/src/Operations/operations.services.ts +++ b/src/Operations/operations.services.ts @@ -1,5 +1,5 @@ import { BadRequestException, Injectable } from '@nestjs/common'; -import { StudentService } from 'src/alumno/student.service'; +import { AlumnoService } from 'src/alumno/student.service'; import { DetalleServicioService } from 'src/detalle_servicio/detalle_servicio.service'; import { DataSource } from 'typeorm'; import { chargePrintDto } from './dto/operations.dto'; @@ -9,7 +9,7 @@ import { CreateDetalleServicioDto } from 'src/detalle_servicio/dto/create-detall export class OperationsService { constructor( private readonly dataSource: DataSource, - private readonly studentService: StudentService, + private readonly alumnoService: AlumnoService, private readonly detalleServicioService: DetalleServicioService, ) {} @@ -21,7 +21,7 @@ export class OperationsService { await queryRunner.startTransaction(); try { - const credit = await this.studentService.GetCredit(id_cuenta); + const credit = await this.alumnoService.GetCredit(id_cuenta); if (credit < monto) { throw new BadRequestException('Crédito insuficiente'); @@ -34,9 +34,12 @@ export class OperationsService { fecha_operacion: new Date(), }; - await this.detalleServicioService.Create(detalleData, queryRunner.manager); + await this.detalleServicioService.Create( + detalleData, + queryRunner.manager, + ); - await this.studentService.UpdateCredit( + await this.alumnoService.UpdateCredit( id_cuenta, monto, queryRunner.manager, diff --git a/src/alumno/entities/student.entity.ts b/src/alumno/entities/student.entity.ts index 1380f9a..5ed2329 100644 --- a/src/alumno/entities/student.entity.ts +++ b/src/alumno/entities/student.entity.ts @@ -1,4 +1,30 @@ -import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'; +import { AlumnoSancion } from 'src/alumno_sancion/entities/alumno_sancion.entity'; +import { DetalleServicio } from 'src/detalle_servicio/entities/detalle_servicio.entity'; +import { + Column, + Entity, + JoinColumn, + ManyToOne, + OneToMany, + PrimaryGeneratedColumn, +} from 'typeorm'; + +@Entity({ name: 'carrea' }) +export class Carrera { + @PrimaryGeneratedColumn({ name: 'id_carrera', type: 'int', unsigned: true }) + id_carrera: number; + + @Column({ + name: 'nombre_carrea', + type: 'varchar', + length: 100, + nullable: false, + }) + nombre_carrea: string; + + @OneToMany(() => Student, (id_carrera) => id_carrera.id_cuenta) + id_carreras: Student[]; +} @Entity({ name: 'alumno' }) export class Student { @@ -54,9 +80,22 @@ export class Student { }) fecha_registro: Date; - @Column({ name: 'id_carrera', type: 'int', nullable: false }) - id_carrera: number; - @Column({ name: 'generacion', type: 'int', width: 4, nullable: true }) generacion: number | null; + + @OneToMany( + () => DetalleServicio, + (id_detalle_servicio) => id_detalle_servicio.id_cuenta, + ) + detalles_servicio: DetalleServicio[]; + + @ManyToOne(() => Carrera, (id_cuenta) => id_cuenta.id_carreras, { + eager: true, + nullable: true, + }) + @JoinColumn({ name: 'id_carrera' }) + id_periodos: Carrera; + + @OneToMany(() => AlumnoSancion, (id_cuenta) => id_cuenta.id_alumno_sancion) + id_cuentas: AlumnoSancion[]; } diff --git a/src/alumno/student.controller.ts b/src/alumno/student.controller.ts index d064281..37befbc 100644 --- a/src/alumno/student.controller.ts +++ b/src/alumno/student.controller.ts @@ -1,30 +1,24 @@ -import { - Controller, - Get, - Post, - Body, - Param, -} from '@nestjs/common'; -import { StudentService } from './student.service'; +import { Controller, Get, Post, Body, Param } from '@nestjs/common'; +import { AlumnoService } from './student.service'; import { CreateStudentDto } from './dto/create-student.dto'; import { Student } from './entities/student.entity'; @Controller('student') export class StudentController { - constructor(private readonly studentService: StudentService) {} + constructor(private readonly alumnoService: AlumnoService) {} @Post() async create(@Body() createStudentDto: CreateStudentDto): Promise { - return this.studentService.create(createStudentDto); + return this.alumnoService.create(createStudentDto); } @Get() async findAll(): Promise { - return this.studentService.findAll(); + return this.alumnoService.findAll(); } @Get(':id') findOne(@Param('id') id: number) { - return this.studentService.findOne(+id); + return this.alumnoService.findOne(+id); } } diff --git a/src/alumno/student.module.ts b/src/alumno/student.module.ts index e62ebe4..eb72c91 100644 --- a/src/alumno/student.module.ts +++ b/src/alumno/student.module.ts @@ -1,5 +1,5 @@ import { Module } from '@nestjs/common'; -import { StudentService } from './student.service'; +import { AlumnoService } from './student.service'; import { StudentController } from './student.controller'; import { TypeOrmModule } from '@nestjs/typeorm'; import { Student } from './entities/student.entity'; @@ -7,6 +7,6 @@ import { Student } from './entities/student.entity'; @Module({ imports: [TypeOrmModule.forFeature([Student])], controllers: [StudentController], - providers: [StudentService], + providers: [AlumnoService], }) export class StudentModule {} diff --git a/src/alumno/student.service.ts b/src/alumno/student.service.ts index 697b0c8..7b0dabb 100644 --- a/src/alumno/student.service.ts +++ b/src/alumno/student.service.ts @@ -6,7 +6,7 @@ import { EntityManager, Repository } from 'typeorm'; import { InjectRepository } from '@nestjs/typeorm'; @Injectable() -export class StudentService { +export class AlumnoService { constructor( @InjectRepository(Student) private readonly studentRepository: Repository, diff --git a/src/alumno_sancion/alumno_sancion.controller.spec.ts b/src/alumno_sancion/alumno_sancion.controller.spec.ts new file mode 100644 index 0000000..6a4c343 --- /dev/null +++ b/src/alumno_sancion/alumno_sancion.controller.spec.ts @@ -0,0 +1,20 @@ +import { Test, TestingModule } from '@nestjs/testing'; +import { AlumnoSancionController } from './alumno_sancion.controller'; +import { AlumnoSancionService } from './alumno_sancion.service'; + +describe('AlumnoSancionController', () => { + let controller: AlumnoSancionController; + + beforeEach(async () => { + const module: TestingModule = await Test.createTestingModule({ + controllers: [AlumnoSancionController], + providers: [AlumnoSancionService], + }).compile(); + + controller = module.get(AlumnoSancionController); + }); + + it('should be defined', () => { + expect(controller).toBeDefined(); + }); +}); diff --git a/src/alumno_sancion/alumno_sancion.controller.ts b/src/alumno_sancion/alumno_sancion.controller.ts new file mode 100644 index 0000000..f64825b --- /dev/null +++ b/src/alumno_sancion/alumno_sancion.controller.ts @@ -0,0 +1,34 @@ +import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common'; +import { AlumnoSancionService } from './alumno_sancion.service'; +import { CreateAlumnoSancionDto } from './dto/create-alumno_sancion.dto'; +import { UpdateAlumnoSancionDto } from './dto/update-alumno_sancion.dto'; + +@Controller('alumno-sancion') +export class AlumnoSancionController { + constructor(private readonly alumnoSancionService: AlumnoSancionService) {} + + @Post() + create(@Body() createAlumnoSancionDto: CreateAlumnoSancionDto) { + return this.alumnoSancionService.create(createAlumnoSancionDto); + } + + @Get() + findAll() { + return this.alumnoSancionService.findAll(); + } + + @Get(':id') + findOne(@Param('id') id: string) { + return this.alumnoSancionService.findOne(+id); + } + + @Patch(':id') + update(@Param('id') id: string, @Body() updateAlumnoSancionDto: UpdateAlumnoSancionDto) { + return this.alumnoSancionService.update(+id, updateAlumnoSancionDto); + } + + @Delete(':id') + remove(@Param('id') id: string) { + return this.alumnoSancionService.remove(+id); + } +} diff --git a/src/alumno_sancion/alumno_sancion.module.ts b/src/alumno_sancion/alumno_sancion.module.ts new file mode 100644 index 0000000..ac6124b --- /dev/null +++ b/src/alumno_sancion/alumno_sancion.module.ts @@ -0,0 +1,9 @@ +import { Module } from '@nestjs/common'; +import { AlumnoSancionService } from './alumno_sancion.service'; +import { AlumnoSancionController } from './alumno_sancion.controller'; + +@Module({ + controllers: [AlumnoSancionController], + providers: [AlumnoSancionService], +}) +export class AlumnoSancionModule {} diff --git a/src/alumno_sancion/alumno_sancion.service.spec.ts b/src/alumno_sancion/alumno_sancion.service.spec.ts new file mode 100644 index 0000000..2f371b2 --- /dev/null +++ b/src/alumno_sancion/alumno_sancion.service.spec.ts @@ -0,0 +1,18 @@ +import { Test, TestingModule } from '@nestjs/testing'; +import { AlumnoSancionService } from './alumno_sancion.service'; + +describe('AlumnoSancionService', () => { + let service: AlumnoSancionService; + + beforeEach(async () => { + const module: TestingModule = await Test.createTestingModule({ + providers: [AlumnoSancionService], + }).compile(); + + service = module.get(AlumnoSancionService); + }); + + it('should be defined', () => { + expect(service).toBeDefined(); + }); +}); diff --git a/src/alumno_sancion/alumno_sancion.service.ts b/src/alumno_sancion/alumno_sancion.service.ts new file mode 100644 index 0000000..724bb0a --- /dev/null +++ b/src/alumno_sancion/alumno_sancion.service.ts @@ -0,0 +1,41 @@ +import { Injectable, NotFoundException } from '@nestjs/common'; +import { CreateAlumnoSancionDto } from './dto/create-alumno_sancion.dto'; +import { UpdateAlumnoSancionDto } from './dto/update-alumno_sancion.dto'; +import { InjectRepository } from '@nestjs/typeorm'; +import { AlumnoSancion } from './entities/alumno_sancion.entity'; +import { Repository } from 'typeorm'; +import { Student } from 'src/alumno/entities/student.entity'; + +@Injectable() +export class AlumnoSancionService { + constructor( + @InjectRepository(AlumnoSancion) + private readonly alumnosancionRepository: Repository, + ) {} + + create(createAlumnoSancionDto: CreateAlumnoSancionDto) { + return 'This action adds a new alumnoSancion'; + } + + findAll() { + return `This action returns all alumnoSancion`; + } + + async findOne(id_cuenta: CreateAlumnoSancionDto): Promise { + const alusancion = await this.alumnosancionRepository.findOne({ + where: { id_cuenta }, + }); + if (!alusancion) { + throw new NotFoundException(`Student with ID ${id_cuenta} not found`); + } + return alusancion; + } + + update(id: number, updateAlumnoSancionDto: UpdateAlumnoSancionDto) { + return `This action updates a #${id} alumnoSancion`; + } + + remove(id: number) { + return `This action removes a #${id} alumnoSancion`; + } +} diff --git a/src/alumno_sancion/dto/create-alumno_sancion.dto.ts b/src/alumno_sancion/dto/create-alumno_sancion.dto.ts new file mode 100644 index 0000000..7d716a2 --- /dev/null +++ b/src/alumno_sancion/dto/create-alumno_sancion.dto.ts @@ -0,0 +1,15 @@ +import { IsDateString, IsInt, IsNotEmpty, IsOptional } from 'class-validator'; + +export class CreateAlumnoSancionDto { + @IsNotEmpty() + @IsInt() + id_sancion: number; + + @IsNotEmpty() + @IsInt() + id_cuenta: number; + + @IsOptional() + @IsDateString() + fecha_inicio?: string; +} diff --git a/src/alumno_sancion/dto/update-alumno_sancion.dto.ts b/src/alumno_sancion/dto/update-alumno_sancion.dto.ts new file mode 100644 index 0000000..1b7a8e3 --- /dev/null +++ b/src/alumno_sancion/dto/update-alumno_sancion.dto.ts @@ -0,0 +1,4 @@ +import { PartialType } from '@nestjs/mapped-types'; +import { CreateAlumnoSancionDto } from './create-alumno_sancion.dto'; + +export class UpdateAlumnoSancionDto extends PartialType(CreateAlumnoSancionDto) {} diff --git a/src/alumno_sancion/entities/alumno_sancion.entity.ts b/src/alumno_sancion/entities/alumno_sancion.entity.ts new file mode 100644 index 0000000..5c0e315 --- /dev/null +++ b/src/alumno_sancion/entities/alumno_sancion.entity.ts @@ -0,0 +1,45 @@ +import { Student } from 'src/alumno/entities/student.entity'; +import { Sancion } from 'src/sancion/entities/sancion.entity'; +import { + Column, + Entity, + JoinColumn, + ManyToOne, + PrimaryGeneratedColumn, +} from 'typeorm'; + +@Entity({ name: 'alumno_sancion' }) +export class AlumnoSancion { + @PrimaryGeneratedColumn({ name: 'id_alumno_sancion', type: 'int' }) + id_alumno_sancion: number; + + @Column({ + name: 'fecha_inicio', + type: 'timestamp', + default: () => 'CURRENT_TIMESTAMP', + nullable: false, + }) + fecha_inicio: Date; + + @ManyToOne( + () => Student, + (id_alumno_sancion) => id_alumno_sancion.id_cuentas, + { + eager: true, + nullable: true, + }, + ) + @JoinColumn({ name: 'id_cuenta' }) + id_cuenta: Student; + + @ManyToOne( + () => Sancion, + (id_alumno_sancion) => id_alumno_sancion.id_sanciones, + { + eager: true, + nullable: true, + }, + ) + @JoinColumn({ name: 'id_sancion' }) + id_sancion: Sancion; +} diff --git a/src/app.module.ts b/src/app.module.ts index eb62c13..5a70d38 100644 --- a/src/app.module.ts +++ b/src/app.module.ts @@ -13,6 +13,9 @@ import { Student } from './alumno/entities/student.entity'; import { DetalleServicio } from './detalle_servicio/entities/detalle_servicio.entity'; import { Periodo } from './periodo/entities/periodo.entity'; import { Servicio } from './servicio/entities/servicio.entity'; +import { SancionModule } from './sancion/sancion.module'; +import { AlumnoSancionModule } from './alumno_sancion/alumno_sancion.module'; +import { AlumnoSancion } from './alumno_sancion/entities/alumno_sancion.entity'; @Module({ imports: [ @@ -29,8 +32,16 @@ import { Servicio } from './servicio/entities/servicio.entity'; username: configService.get('DB_USER'), password: configService.get('DB_PASSWORD'), database: configService.get('DB_NAME'), - entities: [User,Student,DetalleServicio,Periodo,Servicio,Perfil], - synchronize: false,//Never change to true in production! + entities: [ + User, + Student, + DetalleServicio, + Periodo, + Servicio, + Perfil, + AlumnoSancion, + ], + synchronize: false, //Never change to true in production! }), }), UserModule, @@ -39,6 +50,8 @@ import { Servicio } from './servicio/entities/servicio.entity'; PeriodoModule, ServicioModule, StudentModule, + SancionModule, + AlumnoSancionModule, ], controllers: [AppController], providers: [AppService], diff --git a/src/detalle_servicio/entities/detalle_servicio.entity.ts b/src/detalle_servicio/entities/detalle_servicio.entity.ts index e6691f3..09ff81f 100644 --- a/src/detalle_servicio/entities/detalle_servicio.entity.ts +++ b/src/detalle_servicio/entities/detalle_servicio.entity.ts @@ -1,4 +1,14 @@ -import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'; +import { Student } from 'src/alumno/entities/student.entity'; +import { Periodo } from 'src/periodo/entities/periodo.entity'; +import { Servicio } from 'src/servicio/entities/servicio.entity'; +import { User } from 'src/user/entities/user.entity'; +import { + Column, + Entity, + JoinColumn, + ManyToOne, + PrimaryGeneratedColumn, +} from 'typeorm'; @Entity({ name: 'detalle_servicio' }) export class DetalleServicio { @@ -28,15 +38,28 @@ export class DetalleServicio { }) fecha_operacion: Date; - @Column({ name: 'id_cuenta', type: 'int', nullable: false }) - id_cuenta: number; + @ManyToOne(() => Student, (id_cuenta) => id_cuenta.detalles_servicio, { + eager: true, + }) + @JoinColumn({ name: 'id_cuenta' }) + id_cuenta: Student; - @Column({ name: 'id_servicio', type: 'int', nullable: false }) - id_servicio: number; + @ManyToOne(() => Servicio, (id_servicio) => id_servicio.detalles_servicio, { + eager: true, + }) + @JoinColumn({ name: 'id_servicio' }) + id_servicio: Servicio; - @Column({ name: 'id_usuario', type: 'int', nullable: false }) - id_usuario: number; + @ManyToOne(() => User, (id_perfil) => id_perfil.detalles_servicio, { + eager: true, + }) + @JoinColumn({ name: 'id_usuario' }) + id_perfil: User; - @Column({ name: 'id_perido', type: 'int', default: null }) - id_periodo: number; -} \ No newline at end of file + @ManyToOne(() => Periodo, (id_periodo) => id_periodo.detalles_servicio, { + eager: true, + nullable: true, + }) + @JoinColumn({ name: 'id_periodo' }) + id_periodo: Periodo; +} diff --git a/src/periodo/entities/periodo.entity.ts b/src/periodo/entities/periodo.entity.ts index 3218596..b1a6dcc 100644 --- a/src/periodo/entities/periodo.entity.ts +++ b/src/periodo/entities/periodo.entity.ts @@ -1,4 +1,5 @@ -import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm'; +import { DetalleServicio } from 'src/detalle_servicio/entities/detalle_servicio.entity'; +import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm'; @Entity({ name: 'periodo' }) export class Periodo { @@ -20,4 +21,10 @@ export class Periodo { default: () => "b'1'", }) activo: boolean; + + @OneToMany( + () => DetalleServicio, + (id_detalle_servicio) => id_detalle_servicio.id_periodo, + ) + detalles_servicio: DetalleServicio[]; } diff --git a/src/sancion/dto/create-sancion.dto.ts b/src/sancion/dto/create-sancion.dto.ts new file mode 100644 index 0000000..8621e5e --- /dev/null +++ b/src/sancion/dto/create-sancion.dto.ts @@ -0,0 +1,12 @@ +import { IsInt, IsNotEmpty, IsString, MaxLength } from 'class-validator'; + +export class CreateSancionDto { + @IsNotEmpty() + @IsString() + @MaxLength(45) + sancion: string; + + @IsNotEmpty() + @IsInt() + duracion: number; +} diff --git a/src/sancion/dto/update-sancion.dto.ts b/src/sancion/dto/update-sancion.dto.ts new file mode 100644 index 0000000..04b23e3 --- /dev/null +++ b/src/sancion/dto/update-sancion.dto.ts @@ -0,0 +1,4 @@ +import { PartialType } from '@nestjs/mapped-types'; +import { CreateSancionDto } from './create-sancion.dto'; + +export class UpdateSancionDto extends PartialType(CreateSancionDto) {} diff --git a/src/sancion/entities/sancion.entity.ts b/src/sancion/entities/sancion.entity.ts new file mode 100644 index 0000000..674817b --- /dev/null +++ b/src/sancion/entities/sancion.entity.ts @@ -0,0 +1,20 @@ +import { AlumnoSancion } from 'src/alumno_sancion/entities/alumno_sancion.entity'; +import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm'; + +@Entity({ name: 'sancion' }) +export class Sancion { + @PrimaryGeneratedColumn({ name: 'id_sancion', type: 'int' }) + id_sancion: number; + + @Column({ name: 'sancion', type: 'varchar', length: 45, nullable: false }) + sancion: string; + + @Column({ name: 'duracion', type: 'int', nullable: false }) + duracion: number; + + @OneToMany( + () => AlumnoSancion, + (id_sanncion) => id_sanncion.id_alumno_sancion, + ) + id_sanciones: AlumnoSancion[]; +} diff --git a/src/sancion/sancion.controller.spec.ts b/src/sancion/sancion.controller.spec.ts new file mode 100644 index 0000000..39e267f --- /dev/null +++ b/src/sancion/sancion.controller.spec.ts @@ -0,0 +1,20 @@ +import { Test, TestingModule } from '@nestjs/testing'; +import { SancionController } from './sancion.controller'; +import { SancionService } from './sancion.service'; + +describe('SancionController', () => { + let controller: SancionController; + + beforeEach(async () => { + const module: TestingModule = await Test.createTestingModule({ + controllers: [SancionController], + providers: [SancionService], + }).compile(); + + controller = module.get(SancionController); + }); + + it('should be defined', () => { + expect(controller).toBeDefined(); + }); +}); diff --git a/src/sancion/sancion.controller.ts b/src/sancion/sancion.controller.ts new file mode 100644 index 0000000..ef78a21 --- /dev/null +++ b/src/sancion/sancion.controller.ts @@ -0,0 +1,34 @@ +import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common'; +import { SancionService } from './sancion.service'; +import { CreateSancionDto } from './dto/create-sancion.dto'; +import { UpdateSancionDto } from './dto/update-sancion.dto'; + +@Controller('sancion') +export class SancionController { + constructor(private readonly sancionService: SancionService) {} + + @Post() + create(@Body() createSancionDto: CreateSancionDto) { + return this.sancionService.create(createSancionDto); + } + + @Get() + findAll() { + return this.sancionService.findAll(); + } + + @Get(':id') + findOne(@Param('id') id: string) { + return this.sancionService.findOne(+id); + } + + @Patch(':id') + update(@Param('id') id: string, @Body() updateSancionDto: UpdateSancionDto) { + return this.sancionService.update(+id, updateSancionDto); + } + + @Delete(':id') + remove(@Param('id') id: string) { + return this.sancionService.remove(+id); + } +} diff --git a/src/sancion/sancion.module.ts b/src/sancion/sancion.module.ts new file mode 100644 index 0000000..aa8774e --- /dev/null +++ b/src/sancion/sancion.module.ts @@ -0,0 +1,9 @@ +import { Module } from '@nestjs/common'; +import { SancionService } from './sancion.service'; +import { SancionController } from './sancion.controller'; + +@Module({ + controllers: [SancionController], + providers: [SancionService], +}) +export class SancionModule {} diff --git a/src/sancion/sancion.service.spec.ts b/src/sancion/sancion.service.spec.ts new file mode 100644 index 0000000..825601c --- /dev/null +++ b/src/sancion/sancion.service.spec.ts @@ -0,0 +1,18 @@ +import { Test, TestingModule } from '@nestjs/testing'; +import { SancionService } from './sancion.service'; + +describe('SancionService', () => { + let service: SancionService; + + beforeEach(async () => { + const module: TestingModule = await Test.createTestingModule({ + providers: [SancionService], + }).compile(); + + service = module.get(SancionService); + }); + + it('should be defined', () => { + expect(service).toBeDefined(); + }); +}); diff --git a/src/sancion/sancion.service.ts b/src/sancion/sancion.service.ts new file mode 100644 index 0000000..d64a702 --- /dev/null +++ b/src/sancion/sancion.service.ts @@ -0,0 +1,26 @@ +import { Injectable } from '@nestjs/common'; +import { CreateSancionDto } from './dto/create-sancion.dto'; +import { UpdateSancionDto } from './dto/update-sancion.dto'; + +@Injectable() +export class SancionService { + create(createSancionDto: CreateSancionDto) { + return 'This action adds a new sancion'; + } + + findAll() { + return `This action returns all sancion`; + } + + findOne(id: number) { + return `This action returns a #${id} sancion`; + } + + update(id: number, updateSancionDto: UpdateSancionDto) { + return `This action updates a #${id} sancion`; + } + + remove(id: number) { + return `This action removes a #${id} sancion`; + } +} diff --git a/src/servicio/entities/servicio.entity.ts b/src/servicio/entities/servicio.entity.ts index bc1d060..ce01eb1 100644 --- a/src/servicio/entities/servicio.entity.ts +++ b/src/servicio/entities/servicio.entity.ts @@ -1,4 +1,5 @@ -import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm'; +import { DetalleServicio } from 'src/detalle_servicio/entities/detalle_servicio.entity'; +import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm'; @Entity({ name: 'servicio' }) export class Servicio { @@ -7,4 +8,9 @@ export class Servicio { @Column({ type: 'varchar', length: 45, nullable: false }) servicio: string; + @OneToMany( + () => DetalleServicio, + (id_detalle_servicio) => id_detalle_servicio.id_servicio, + ) + detalles_servicio: DetalleServicio[]; } diff --git a/src/user/entities/user.entity.ts b/src/user/entities/user.entity.ts index 66718e1..19919d5 100644 --- a/src/user/entities/user.entity.ts +++ b/src/user/entities/user.entity.ts @@ -1,3 +1,4 @@ +import { DetalleServicio } from 'src/detalle_servicio/entities/detalle_servicio.entity'; import { Column, Entity, @@ -51,4 +52,10 @@ export class User { @ManyToOne(() => Perfil, (perfil) => perfil.usuarios, { eager: true }) @JoinColumn({ name: 'id_perfil' }) perfil: Perfil; -} \ No newline at end of file + + @OneToMany( + () => DetalleServicio, + (id_detalle_servicio) => id_detalle_servicio.id_perfil, + ) + detalles_servicio: DetalleServicio[]; +}