Merge branch 'dev' of https://repositorio.acatlan.unam.mx/CIDWA/pcpuma_unam_api into saavedra

catalogos.sql

@@ -20,3 +20,21 @@ INSERT INTO tipo_usuario (tipo_usuario) VALUES ("Operador");
 INSERT INTO tipo_usuario (tipo_usuario) VALUES ("Profesor");
 INSERT INTO tipo_usuario (tipo_usuario) VALUES ("Alumno");
 INSERT INTO tipo_usuario (tipo_usuario) VALUES ("Posgrado");
+
+INSERT INTO dia (dia) VALUES ("Lunes");
+INSERT INTO dia (dia) VALUES ("Martes");
+INSERT INTO dia (dia) VALUES ("Miercoles");
+INSERT INTO dia (dia) VALUES ("Jueves");
+INSERT INTO dia (dia) VALUES ("Viernes");
+
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (1, 1);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (1, 2);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (1, 3);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (1, 4);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (1, 5);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (2, 1);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (2, 2);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (2, 3);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (2, 4);
+INSERT INTO institucion_dia (id_institucion, id_dia) VALUES (2, 5);
+

src/institucion-dia/dto/institucion-dia-update.dto.ts

@@ -0,0 +1,18 @@
+import { IsBoolean, IsInt, IsMilitaryTime, IsOptional } from 'class-validator';
+
+export class InstitucionDiaUpdateDto {
+  @IsInt()
+  id_institucion_dia: number;
+
+  @IsBoolean()
+  @IsOptional()
+  activo?: boolean;
+
+  @IsMilitaryTime()
+  @IsOptional()
+  hora_fin?: string;
+
+  @IsMilitaryTime()
+  @IsOptional()
+  hora_inicio?: string;
+}

src/institucion-dia/entity/institucion-dia.entity.ts

@@ -18,13 +18,13 @@ export class InstitucionDia {
   @Column({ type: Boolean, nullable: false, default: false })
   activo: boolean;
 
-  @Column({ type: Date, nullable: false })
-  hora_fin: Date;
+  @Column({ type: String, nullable: false, default: '17:45', length: 5 })
+  hora_fin: string;
 
-  @Column({ type: Date, nullable: false })
-  hora_inicio: Date;
+  @Column({ type: String, nullable: false, default: '09:00', length: 5 })
+  hora_inicio: string;
 
-  @ManyToOne(() => Dia, (dia) => dia.institucionesDias)
+  @ManyToOne(() => Dia, (dia) => dia.institucionesDias, { eager: true })
   @JoinColumn({ name: 'id_dia' })
   dia: Dia;
 

src/institucion-dia/institucion-dia.controller.ts

@@ -1,13 +1,26 @@
-import { Controller, Get, Put } from '@nestjs/common';
+import { Body, Controller, Get, Put, Query } from '@nestjs/common';
 import { InstitucionDiaService } from './institucion-dia.service';
+import { IdInstitucionDto } from '../dto/id-institucion.dto';
+import { InstitucionDiaUpdateDto } from './dto/institucion-dia-update.dto';
 
 @Controller('institucion-dia')
 export class InstitucionDiaController {
   constructor(private institucionDiaService: InstitucionDiaService) {}
 
   @Get()
-  get() {}
+  get() {
+    return this.institucionDiaService.findAll();
+  }
+
+  @Get('instituciones_dias')
+  institucionesDias(@Query() query: IdInstitucionDto) {
+    return this.institucionDiaService.findAllByIdInstitucion(
+      Number(query.id_institucion),
+    );
+  }
 
   @Put()
-  update() {}
+  update(@Body() body: InstitucionDiaUpdateDto) {
+    return this.institucionDiaService.update(body);
+  }
 }

src/institucion-dia/institucion-dia.module.ts

@@ -4,9 +4,10 @@ import { InstitucionDiaController } from './institucion-dia.controller';
 import { InstitucionDiaService } from './institucion-dia.service';
 import { InstitucionDia } from './entity/institucion-dia.entity';
 import { Dia } from './entity/dia.entity';
+import { InstitucionModule } from '../institucion/institucion.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Dia, InstitucionDia])],
+  imports: [TypeOrmModule.forFeature([Dia, InstitucionDia]), InstitucionModule],
   controllers: [InstitucionDiaController],
   providers: [InstitucionDiaService],
 })

src/institucion-dia/institucion-dia.service.ts

@@ -2,11 +2,44 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { InstitucionDia } from './entity/institucion-dia.entity';
-
+import { InstitucionService } from '../institucion/institucion.service';
 @Injectable()
 export class InstitucionDiaService {
   constructor(
     @InjectRepository(InstitucionDia)
-    private repository: Repository<InstitucionDia>,
+    private repositoryInstitucionDia: Repository<InstitucionDia>,
+    private institucionService: InstitucionService,
   ) {}
+
+  findAll() {
+    return this.repositoryInstitucionDia.find();
+  }
+
+  findAllByIdInstitucion(id_institucion: number) {
+    return this.institucionService
+      .findById(id_institucion)
+      .then((institucion) =>
+        this.repositoryInstitucionDia.find({ institucion }),
+      );
+  }
+
+  findById(id_institucion_dia: number) {
+    return this.repositoryInstitucionDia
+      .findOne({ id_institucion_dia })
+      .then((institucionDia) => {
+        if (!institucionDia) throw new Error('No existe esta institucion dia.');
+        return institucionDia;
+      });
+  }
+
+  update(attrs: Partial<InstitucionDia>) {
+    return this.findById(attrs.id_institucion_dia)
+      .then((institucionDia) => {
+        Object.assign(institucionDia, attrs);
+        return this.repositoryInstitucionDia.save(institucionDia);
+      })
+      .then((_) => ({
+        message: 'Se actualió correctamente la institucion infracción.',
+      }));
+  }
 }

src/institucion-infraccion/dto/institucion-infraccion-update.dto.ts

@@ -1,7 +1,7 @@
-import { IsNumber } from 'class-validator';
+import { IsInt, IsNumber } from 'class-validator';
 
 export class InstitucionInfraccionUpdateDto {
-  @IsNumber()
+  @IsInt()
   id_institucion_infraccion: number;
 
   @IsNumber()

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

@@ -7,7 +7,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { InstitucionInfraccion } from './entity/institucion-infraccion.entity';
 import { Infraccion } from './entity/infraccion.entity';
-import { InstitucionService } from 'src/institucion/institucion.service';
+import { InstitucionService } from '../institucion/institucion.service';
 
 @Injectable()
 export class InstitucionInfraccionService {

src/institucion-tipo-carrito/dto/institucion-tipo-carrito-update.dto.ts

@@ -1,7 +1,7 @@
-import { IsBoolean, IsNumber } from 'class-validator';
+import { IsBoolean, IsInt, IsNumber } from 'class-validator';
 
 export class InstitucionTipoCarritoUpdateDto {
-  @IsNumber()
+  @IsInt()
   id_institucion_tipo_carrito: number;
 
   @IsBoolean()

src/institucion-tipo-carrito/institucion-tipo-carrito.service.ts

@@ -7,7 +7,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { InstitucionTipoCarrito } from './entity/institucion-tipo-carrito.entity';
 import { TipoCarrito } from './entity/tipo-carrito.entity';
-import { InstitucionService } from 'src/institucion/institucion.service';
+import { InstitucionService } from '../institucion/institucion.service';
 
 @Injectable()
 export class InstitucionTipoCarritoService {

src/institucion/dto/institucion-update.dto.ts

@@ -0,0 +1,22 @@
+import { IsNumber, IsOptional, IsInt } from 'class-validator';
+
+export class InstitucionUpdateDto {
+  @IsInt()
+  id_institucion: number;
+
+  @IsNumber()
+  @IsOptional()
+  dias_multa_retraso?: number;
+
+  @IsNumber()
+  @IsOptional()
+  tiempo_entrega?: number;
+
+  @IsNumber()
+  @IsOptional()
+  tiempo_prestamo?: number;
+
+  @IsNumber()
+  @IsOptional()
+  tiempo_recoger?: number;
+}

src/institucion/institucion.controller.ts

@@ -1,5 +1,7 @@
-import { Controller, Get, Put } from '@nestjs/common';
+import { Body, Controller, Get, Put, Query } from '@nestjs/common';
 import { InstitucionService } from './institucion.service';
+import { IdInstitucionDto } from '../dto/id-institucion.dto';
+import { InstitucionUpdateDto } from './dto/institucion-update.dto';
 
 @Controller('institucion')
 export class InstitucionController {
@@ -10,6 +12,13 @@ export class InstitucionController {
     return this.institucionService.findAll();
   }
 
+  @Get('institucion')
+  institucion(@Query() query: IdInstitucionDto) {
+    return this.institucionService.findById(Number(query.id_institucion));
+  }
+
   @Put()
-  update() {}
+  update(@Body() body: InstitucionUpdateDto) {
+    return this.institucionService.update(body);
+  }
 }

src/institucion/institucion.service.ts

@@ -20,4 +20,15 @@ export class InstitucionService {
       return institucion;
     });
   }
+
+  update(attrs: Partial<Institucion>) {
+    return this.findById(attrs.id_institucion)
+      .then((institucion) => {
+        Object.assign(institucion, attrs);
+        return this.repository.save(institucion);
+      })
+      .then((_) => ({
+        message: 'Se actualió correctamente la institucion.',
+      }));
+  }
 }

src/modulo/dto/modulo-create.dto.ts

@@ -1,7 +1,7 @@
-import { IsNumber, IsString } from 'class-validator';
+import { IsInt, IsString } from 'class-validator';
 
 export class ModuloCreateDto {
-  @IsNumber()
+  @IsInt()
   id_institucion: number;
 
   @IsString()

src/modulo/dto/modulo-update.dto.ts

@@ -1,14 +1,14 @@
-import { IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
+import { IsBoolean, IsInt, IsOptional, IsString } from 'class-validator';
 
 export class ModuloUpdateDto {
-  @IsNumber()
+  @IsInt()
   id_modulo: number;
 
-  @IsString()
-  @IsOptional()
-  modulo?: string;
-
   @IsBoolean()
   @IsOptional()
   activo?: boolean;
+
+  @IsString()
+  @IsOptional()
+  modulo?: string;
 }

src/operador/dto/operador-create.dto.ts

@@ -0,0 +1,12 @@
+import { IsInt, IsString } from 'class-validator';
+
+export class OperadorCreateDto {
+  @IsInt()
+  id_institucion: number;
+
+  @IsString()
+  operador: string;
+
+  @IsString()
+  password: string;
+}

src/operador/dto/operador-login.dto.ts

@@ -0,0 +1,9 @@
+import { IsNumberString, IsString } from 'class-validator';
+
+export class OperadorLoginDto {
+  @IsNumberString()
+  operador: string;
+
+  @IsString()
+  password: string;
+}

src/operador/dto/operador-operadores.dto.ts

@@ -0,0 +1,14 @@
+import { IsNumberString, IsOptional, IsString } from 'class-validator';
+
+export class OperadorOperadoresDto {
+  @IsNumberString()
+  pagina: string;
+
+  @IsNumberString()
+  @IsOptional()
+  id_institucion?: string;
+
+  @IsString()
+  @IsOptional()
+  operador?: string;
+}

src/operador/dto/operador-update.dto.ts

@@ -0,0 +1,18 @@
+import { IsBoolean, IsInt, IsOptional, IsString } from 'class-validator';
+
+export class OperadorUpdateDto {
+  @IsInt()
+  id_operador: number;
+
+  @IsBoolean()
+  @IsOptional()
+  activo?: boolean;
+
+  @IsString()
+  @IsOptional()
+  operador?: string;
+
+  @IsString()
+  @IsOptional()
+  password?: string;
+}

src/operador/dto/operador.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class OperadorDto {
+  @IsString()
+  operador: string;
+}

src/operador/operador.controller.ts

@@ -1,25 +1,43 @@
-import { Controller, Get, Post, Put } from '@nestjs/common';
+import { Body, Controller, Get, Post, Put, Query } from '@nestjs/common';
 import { OperadorService } from './operador.service';
-
+import { OperadorCreateDto } from './dto/operador-create.dto';
+import { OperadorLoginDto } from './dto/operador-login.dto';
+import { OperadorOperadoresDto } from './dto/operador-operadores.dto';
+import { OperadorUpdateDto } from './dto/operador-update.dto';
+import { OperadorDto } from './dto/operador.dto';
 @Controller('operador')
 export class OperadorController {
   constructor(private operadorService: OperadorService) {}
 
   @Post()
-  create() {}
+  create(@Body() body: OperadorCreateDto) {
+    return this.operadorService.create(
+      body.id_institucion,
+      body.operador,
+      body.password,
+    );
+  }
 
   @Post('login')
-  login() {}
+  login(@Body() body: OperadorLoginDto) {
+    return this.operadorService.login(body.operador, body.password);
+  }
 
   @Get('operador')
-  operador() {}
+  operador(@Query() query: OperadorDto) {
+    return this.operadorService.findByOperador(query.operador);
+  }
 
   @Get('operadores')
-  operadores() {}
+  operadores(@Query() query: OperadorOperadoresDto) {
+    return this.operadorService.findAll(query);
+  }
 
   @Get('reporte')
   reporte() {}
 
   @Put()
-  update() {}
+  update(@Body() body: OperadorUpdateDto) {
+    return this.operadorService.update(body);
+  }
 }

src/operador/operador.module.ts

@@ -3,9 +3,15 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { OperadorController } from './operador.controller';
 import { OperadorService } from './operador.service';
 import { Operador } from './entity/operador.entity';
+import { InstitucionModule } from 'src/institucion/institucion.module';
+import { TipoUsuarioModule } from 'src/tipo-usuario/tipo-usuario.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Operador])],
+  imports: [
+    TypeOrmModule.forFeature([Operador]),
+    InstitucionModule,
+    TipoUsuarioModule,
+  ],
   controllers: [OperadorController],
   providers: [OperadorService],
 })

src/operador/operador.service.ts

@@ -1,11 +1,94 @@
-import { Injectable } from '@nestjs/common';
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Operador } from './entity/operador.entity';
+import { InstitucionService } from 'src/institucion/institucion.service';
+import { TipoUsuarioService } from 'src/tipo-usuario/tipo-usuario.service';
 
 @Injectable()
 export class OperadorService {
   constructor(
     @InjectRepository(Operador) private repository: Repository<Operador>,
+    private isnstitucionService: InstitucionService,
+    private tipoUsuarioService: TipoUsuarioService,
   ) {}
+
+  async create(id_institucion: number, operador: string, password: string) {
+    const institucion = await this.isnstitucionService.findById(id_institucion);
+    const tipoUsuario = await this.tipoUsuarioService.findById(4);
+
+    return this.repository
+      .findOne({ operador, institucion })
+      .then((existeOperador) => {
+        if (existeOperador)
+          throw new ConflictException(
+            'Ya existe un operador con ese nombre, intente de nuevo.',
+          );
+        /* Encriptar password */
+        return this.repository.save(
+          this.repository.create({
+            institucion,
+            operador,
+            password,
+            tipoUsuario,
+          }),
+        );
+      })
+      .then((_) => ({ message: 'Se creo correctamente al operador.' }));
+  }
+
+  async findAll(filtros: {
+    pagina: string;
+    id_institucion?: string;
+    operador?: string;
+  }) {
+    const busqueda: any = {};
+    const institucion = filtros.id_institucion
+      ? await this.isnstitucionService.findById(Number(filtros.id_institucion))
+      : null;
+
+    if (filtros.operador) busqueda.operador = filtros.operador;
+    if (filtros.id_institucion) busqueda.institucion = institucion;
+    return this.repository.find(busqueda);
+  }
+
+  findById(id_operador: number) {
+    return this.repository.findOne({ id_operador }).then((operador) => {
+      if (!operador) throw new NotFoundException('No existe este operador');
+      return operador;
+    });
+  }
+
+  findByOperador(operador: string) {
+    return this.repository.findOne({ operador }).then((operador) => {
+      if (!operador) throw new NotFoundException('No existe este operador');
+      return operador;
+    });
+  }
+
+  login(operador: string, password: string) {
+    return this.findByOperador(operador).then((operador) => {
+      if (operador.password !== password)
+        throw new UnauthorizedException('Contraseña incorrecta.');
+      /* Crear JWT y regresarlo */
+      return operador;
+    });
+  }
+
+  async update(attrs: Partial<Operador>) {
+    return this.findById(attrs.id_operador)
+      .then((operador) => {
+        /* encriptar password */
+        Object.assign(operador, attrs);
+        return this.repository.save(operador);
+      })
+      .then((_) => ({
+        message: 'Se actualizo correctamente la información del operador.',
+      }));
+  }
 }

src/programa/dto/programa-create.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class ProgramaCreateDto {
+  @IsString()
+  programa: string;
+}

src/programa/programa.controller.ts

@@ -1,10 +1,18 @@
-import { Controller, Get } from '@nestjs/common';
+import { Body, Controller, Get, Post } from '@nestjs/common';
 import { ProgramaService } from './programa.service';
+import { ProgramaCreateDto } from './dto/programa-create.dto';
 
 @Controller('programa')
 export class ProgramaController {
   constructor(private programaService: ProgramaService) {}
 
+  @Post()
+  create(@Body() body: ProgramaCreateDto) {
+    return this.programaService.create(body.programa);
+  }
+
   @Get()
-  get() {}
+  get() {
+    return this.programaService.findAll();
+  }
 }

src/programa/programa.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { ConflictException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Programa } from './entity/programa.entity';
@@ -8,4 +8,19 @@ export class ProgramaService {
   constructor(
     @InjectRepository(Programa) private repository: Repository<Programa>,
   ) {}
+
+  create(programa: string) {
+    return this.repository
+      .findOne({ programa })
+      .then((existePrograma) => {
+        if (existePrograma)
+          throw new ConflictException('Ya existe este programa.');
+        return this.repository.save(this.repository.create({ programa }));
+      })
+      .then((_) => ({ message: 'Se creo correctamente el programa.' }));
+  }
+
+  findAll() {
+    return this.repository.find();
+  }
 }

src/tipo-usuario/dto/tipo-usuario-update.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class TipoUsuarioUpdateDto {
+  @IsString()
+  tipo_usuario: string;
+}

src/tipo-usuario/tipo-usuario.controller.ts

@@ -1,10 +1,17 @@
-import { Controller, Get } from '@nestjs/common';
+import { Body, Controller, Get, Post } from '@nestjs/common';
 import { TipoUsuarioService } from './tipo-usuario.service';
-
+import { TipoUsuarioUpdateDto } from './dto/tipo-usuario-update.dto';
 @Controller('tipo-usuario')
 export class TipoUsuarioController {
   constructor(private tipoUsuarioService: TipoUsuarioService) {}
 
+  @Post()
+  create(@Body() body: TipoUsuarioUpdateDto) {
+    return this.tipoUsuarioService.create(body.tipo_usuario);
+  }
+
   @Get()
-  get() {}
+  get() {
+    return this.tipoUsuarioService.findAll();
+  }
 }

src/tipo-usuario/tipo-usuario.module.ts

@@ -8,5 +8,6 @@ import { TipoUsuario } from './entity/tipo-usuario.entity';
   imports: [TypeOrmModule.forFeature([TipoUsuario])],
   controllers: [TipoUsuarioController],
   providers: [TipoUsuarioService],
+  exports: [TipoUsuarioService],
 })
 export class TipoUsuarioModule {}

src/tipo-usuario/tipo-usuario.service.ts

@@ -1,4 +1,8 @@
-import { Injectable } from '@nestjs/common';
+import {
+  ConflictException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { TipoUsuario } from './entity/tipo-usuario.entity';
@@ -8,4 +12,27 @@ export class TipoUsuarioService {
   constructor(
     @InjectRepository(TipoUsuario) private repository: Repository<TipoUsuario>,
   ) {}
+
+  create(tipo_usuario: string) {
+    return this.repository
+      .findOne({ tipo_usuario })
+      .then((existeTipoUsuario) => {
+        if (existeTipoUsuario)
+          throw new ConflictException('Ya existe este tipo usuario');
+        return this.repository.save(this.repository.create({ tipo_usuario }));
+      })
+      .then((_) => ({ message: 'Se creo correctamente el tipo usuario.' }));
+  }
+
+  findAll() {
+    return this.repository.find();
+  }
+
+  findById(id_tipo_usuario: number) {
+    return this.repository.findOne({ id_tipo_usuario }).then((tipoUsuario) => {
+      if (!tipoUsuario)
+        throw new NotFoundException('No existe este tipo usuairo');
+      return tipoUsuario;
+    });
+  }
 }

src/usuario/dto/usuario-escolares.dto.ts

@@ -0,0 +1,6 @@
+import { IsNumberString } from 'class-validator';
+
+export class UsuarioEscolaresDto {
+  @IsNumberString()
+  usuario: string;
+}

src/usuario/dto/usuario-login.dto.ts

@@ -0,0 +1,9 @@
+import { IsNumberString, IsString } from 'class-validator';
+
+export class UsuarioLoginDto {
+  @IsNumberString()
+  usuario: string;
+
+  @IsString()
+  password: string;
+}

src/usuario/dto/usuario-registrar.dto.ts

@@ -0,0 +1,9 @@
+import { IsInt, IsPhoneNumber } from 'class-validator';
+
+export class UsuarioRegistrarDto {
+  @IsInt()
+  id_usuario: number;
+
+  @IsPhoneNumber('MX')
+  telefono: string;
+}

src/usuario/dto/usuario-update.dto.ts

@@ -0,0 +1,18 @@
+import { IsBoolean, IsInt, IsOptional, IsPhoneNumber } from 'class-validator';
+
+export class UsuarioUpdateDto {
+  @IsInt()
+  id_usuario: number;
+
+  @IsBoolean()
+  @IsOptional()
+  activo?: boolean;
+
+  @IsBoolean()
+  @IsOptional()
+  multa?: boolean;
+
+  @IsPhoneNumber()
+  @IsOptional()
+  telefono?: string;
+}

src/usuario/dto/usuario-usuarios.dto.ts

@@ -0,0 +1,22 @@
+import { IsNumberString, IsOptional } from 'class-validator';
+
+export class UsuarioUsuariosDto {
+  @IsNumberString()
+  pagina: string;
+
+  @IsNumberString()
+  @IsOptional()
+  id_carrera: string;
+
+  @IsNumberString()
+  @IsOptional()
+  id_institucion: string;
+
+  @IsNumberString()
+  @IsOptional()
+  id_tipo_usuario: string;
+
+  @IsNumberString()
+  @IsOptional()
+  usuario: string;
+}

src/usuario/dto/usuario.dto.ts

@@ -0,0 +1,6 @@
+import { IsNumberString } from 'class-validator';
+
+export class UsuarioDto {
+  @IsNumberString()
+  usuario: string;
+}

src/usuario/entity/usuario.entity.ts

@@ -25,6 +25,9 @@ export class Usuario {
   @Column({ type: String, nullable: false, length: 60 })
   password: string;
 
+  @Column({ type: String, nullable: false, length: 10 })
+  telefono: string;
+
   @Column({ type: String, nullable: false, length: 10 })
   usuario: string;
 

src/usuario/usuario.controller.ts

@@ -1,25 +1,42 @@
-import { Controller, Get, Post, Put } from '@nestjs/common';
+import { Body, Controller, Get, Post, Put, Query } from '@nestjs/common';
 import { UsuarioService } from './usuario.service';
+import { UsuarioEscolaresDto } from './dto/usuario-escolares.dto';
+import { UsuarioLoginDto } from './dto/usuario-login.dto';
+import { UsuarioRegistrarDto } from './dto/usuario-registrar.dto';
+import { UsuarioUpdateDto } from './dto/usuario-update.dto';
+import { UsuarioUsuariosDto } from './dto/usuario-usuarios.dto';
+import { UsuarioDto } from './dto/usuario.dto';
 
 @Controller('usuario')
 export class UsuarioController {
   constructor(private usuarioService: UsuarioService) {}
 
-  @Get()
-  get() {}
+  /* Pendiente por conexión */
+  @Get('escolares')
+  escolares(@Query() query: UsuarioEscolaresDto) {}
 
   @Post('login')
-  login() {}
+  login(@Body() body: UsuarioLoginDto) {
+    return this.usuarioService.login(body.usuario, body.password);
+  }
 
   @Post('registrar')
-  registrar() {}
+  registrar(@Body() body: UsuarioRegistrarDto) {
+    return this.usuarioService.registrar(body.id_usuario, body.telefono);
+  }
 
   @Put()
-  update() {}
+  update(@Body() body: UsuarioUpdateDto) {
+    return this.usuarioService.update(body);
+  }
 
   @Get('usuario')
-  usuario() {}
+  usuario(@Query() query: UsuarioDto) {
+    return this.usuarioService.findByUsuario(query.usuario);
+  }
 
   @Get('usuarios')
-  usuarios() {}
+  usuarios(@Query() query: UsuarioUsuariosDto) {
+    return this.usuarioService.findAll(query);
+  }
 }

src/usuario/usuario.module.ts

@@ -3,9 +3,15 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { UsuarioController } from './usuario.controller';
 import { UsuarioService } from './usuario.service';
 import { Usuario } from './entity/usuario.entity';
+import { InstitucionModule } from '../institucion/institucion.module';
+import { TipoUsuarioModule } from '../tipo-usuario/tipo-usuario.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Usuario])],
+  imports: [
+    TypeOrmModule.forFeature([Usuario]),
+    InstitucionModule,
+    TipoUsuarioModule,
+  ],
   controllers: [UsuarioController],
   providers: [UsuarioService],
 })

src/usuario/usuario.service.ts

@@ -1,11 +1,82 @@
-import { Injectable } from '@nestjs/common';
+import {
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Usuario } from './entity/usuario.entity';
+import { InstitucionService } from '../institucion/institucion.service';
+import { TipoUsuarioService } from '../tipo-usuario/tipo-usuario.service';
 
 @Injectable()
 export class UsuarioService {
   constructor(
     @InjectRepository(Usuario) private repository: Repository<Usuario>,
+    private institucionService: InstitucionService,
+    private tipoUsuarioService: TipoUsuarioService,
   ) {}
+
+  async findAll(filtros: {
+    pagina: string;
+    id_carrera?: string;
+    id_institucion?: string;
+    id_tipo_usuario?: string;
+    usuario?: string;
+  }) {
+    const institucion = filtros.id_institucion
+      ? this.institucionService.findById(Number(filtros.id_institucion))
+      : null;
+    const tipoUsuario = filtros.id_tipo_usuario
+      ? this.tipoUsuarioService.findById(Number(filtros.id_tipo_usuario))
+      : null;
+    const updtae = {};
+    /* Terminar cuando se tengan las fuinciones faltantes */
+  }
+
+  findById(id_usuario: number) {
+    return this.repository.findOne({ id_usuario }).then((usuario) => {
+      if (!usuario) throw new NotFoundException('No existe este usuario.');
+      return usuario;
+    });
+  }
+
+  findByUsuario(usuario: string) {
+    return this.repository.findOne({ usuario }).then((usuario) => {
+      if (!usuario) throw new NotFoundException('No existe este usuario.');
+      return usuario;
+    });
+  }
+
+  login(usuario: string, password: string) {
+    return this.findByUsuario(usuario).then((usuario) => {
+      if (password !== usuario.password)
+        throw new UnauthorizedException('Contraseña incorrecta.');
+      /* Crear JWT y regresarlo */
+      return usuario;
+    });
+  }
+
+  registrar(id_usuario: number, telefono: string) {
+    return this.findById(id_usuario)
+      .then((usuario) => {
+        usuario.telefono = telefono;
+        /* crear contraseña, encriptarla y mandarla por correo */
+        usuario.password = 'hola';
+        return this.repository.save(usuario);
+      })
+      .then((_) => ({ message: 'Se creo correctamente un usuario.' }));
+  }
+
+  async update(attrs: Partial<Usuario>) {
+    return this.findById(attrs.id_usuario)
+      .then((usuario) => {
+        /* crear y encriptar password en caso de cambio de password */
+        Object.assign(usuario, attrs);
+        return this.repository.save(usuario);
+      })
+      .then((_) => ({
+        message: 'Se actualizo correctamente la información del usuario.',
+      }));
+  }
 }