cargamasviva

src/controller/Ayuda.ts

@@ -0,0 +1,30 @@
+import { getManager } from 'typeorm'
+import { Ayuda, AyudaRequest } from '@db/entity/Ayuda'
+import { TipoProblema } from '@db/entity/TipoProblema'
+
+export class AyudaController {
+  private ayudaRepository: any
+  private tipoProblemaRepository: any
+  constructor () {
+    this.ayudaRepository = getManager().getRepository(Ayuda)
+    this.tipoProblemaRepository = getManager().getRepository(TipoProblema)
+  }
+
+  async create (request: AyudaRequest) {
+    const tipoProblema = this.tipoProblemaRepository.findOne(
+      request.tipoProblema
+    )
+    request.tipoProblema = tipoProblema
+    const ayuda = this.ayudaRepository.create(request)
+    const result = await this.ayudaRepository.save(ayuda)
+    return result
+  }
+
+  async getOne (id: number) {
+    return await this.ayudaRepository.findOne(id)
+  }
+
+  async getAll () {
+    return await this.ayudaRepository.findOne()
+  }
+}

src/controller/Carrito.ts

@@ -0,0 +1,85 @@
+import { Request, Response } from 'express'
+import * as Papa from 'papaparse'
+import * as fs from 'fs'
+import { Carrito } from '@src/entity/Carrito'
+import { getRepository } from 'typeorm'
+import { Tipo } from '@src/entity/Tipo'
+import { Equipo } from '@src/entity/Equipo'
+export class CarritoController {
+  public async carga (req: Request, res: Response) {
+    const cargaFile = req.file
+    if (!cargaFile) {
+      res.status(400).send({
+        status: false,
+        data: 'No file is selected.'
+      })
+      return false
+    }
+    const fileReadResult = fs.readFileSync(cargaFile.path, 'utf-8')
+    const parseResult = await Papa.parse(fileReadResult, {
+      header: true
+    })
+    console.log(parseResult)
+    let data: any = {}
+    try {
+      for (const i in parseResult.data) {
+        data = parseResult.data[i]
+        if (
+          !data.kiosko ||
+          !data.alias_carrito ||
+          !data.no_serie ||
+          !data.no_inventario
+        ) {
+          continue
+        }
+        console.log(data)
+        await this.saveCarrito(data)
+      }
+    } catch (err) {
+      res.status(400).send(err.message)
+      return
+    }
+    res.status(200).send('okay')
+  }
+
+  private async saveCarrito (data: any) {
+    // console.log(data)
+    const carritoRepository = getRepository(Carrito)
+    const tipoRepository = getRepository(Tipo)
+    const equipoRepository = getRepository(Equipo)
+
+    const tipo = new Tipo()
+    const carrito = new Carrito()
+    const equipo = new Equipo()
+
+    const tipoFind = await tipoRepository.findOne({
+      where: {
+        nombre: data.tipo
+      }
+    })
+    console.log(tipoFind)
+    const carritoFind = await carritoRepository.findOne({
+      where: {
+        sobrenombre: data.alias_carrito
+      }
+    })
+
+    if (!tipoFind) {
+      tipo.nombre = data.tipo
+    }
+
+    if (!carritoFind) {
+      carrito.kiosko = data.kiosko
+      carrito.sobrenombre = data.alias_carrito
+      carrito.tipo = !tipoFind ? tipo : tipoFind
+    }
+
+    equipo.alias = data.equipo_carrito
+    equipo.noSerie = data.no_serie
+    equipo.noInventario = data.no_inventario
+    equipo.carrito = !carritoFind ? carrito : carritoFind
+    if (!tipoFind) await tipoRepository.save(tipo)
+    if (!carritoFind) await carritoRepository.save(carrito)
+    await equipoRepository.save(equipo)
+  }
+}

src/controller/Operador.ts

@@ -0,0 +1,64 @@
+import { Operador } from '@src/entity/Operador'
+import { Request, Response } from 'express'
+import { validate } from 'class-validator'
+import { getRepository } from 'typeorm'
+
+export class OperadorController {
+  static async create (req: Request, res: Response) {
+    const { usuario, secreto, admin } = req.body
+
+    const operador = new Operador()
+
+    operador.usuario = usuario
+    operador.secreto = secreto
+    operador.admin = admin
+
+    const errors = await validate(operador)
+    if (errors.length > 0) {
+      res.status(400).send(errors)
+    }
+
+    operador.hashPassword()
+
+    const repository = getRepository(Operador)
+    try {
+      await repository.save(operador)
+    } catch (e) {
+      res.status(409).send('username already in use')
+    }
+    res.status(201).send('User created')
+  }
+
+  static async getAll (req: Request, res: Response) {
+    const repository = getRepository(Operador)
+    const result = await repository.find({
+      select: ['id', 'usuario', 'admin']
+    })
+    res.status(200).json(result)
+  }
+
+  static async getOne (req: Request, res: Response) {
+    const id: number = +req.params.id
+    const repository = getRepository(Operador)
+    try {
+      const operador = await repository.findOneOrFail(id, {
+        select: ['id', 'usuario', 'admin']
+      })
+      res.status(200).json(operador)
+    } catch (e) {
+      res.status(404).send('User not found')
+    }
+  }
+
+  static async remove (req: Request, res: Response) {
+    const id = +req.params.id
+    const repository = getRepository(Operador)
+    try {
+      const operador = await repository.findOneOrFail(id)
+      repository.remove(operador)
+      res.status(204).send()
+    } catch (error) {
+      res.status(404).send('User not found')
+    }
+  }
+}

src/controller/Usuario.ts

@@ -0,0 +1,63 @@
+import { Usuario } from '@src/entity/Usuario'
+import { Request, Response } from 'express'
+import { validate } from 'class-validator'
+import { getRepository } from 'typeorm'
+export class UsuarioController {
+  static async create (req: Request, res: Response) {
+    const {
+      id,
+      nombre,
+      apellidoPaterno,
+      apellidoMaterno,
+      correoAlternativo,
+      numeroTelefonico,
+      identificacion,
+      institucion
+    } = req.body
+
+    const usuario = new Usuario()
+    usuario.id = id
+    usuario.nombre = nombre
+    usuario.apellidoPaterno = apellidoPaterno
+    usuario.apellidoMaterno = apellidoMaterno
+    usuario.correoAlternativo = correoAlternativo
+    usuario.numeroTelefonico = numeroTelefonico
+    usuario.identificacion = identificacion
+    usuario.institucion = institucion
+
+    const errors = await validate(usuario)
+    if (errors.length > 0) {
+      res.status(400).send(errors)
+    }
+
+    const repository = getRepository(Usuario)
+    try {
+      await repository.save(usuario)
+    } catch (e) {
+      res.status(409).send(e.message)
+      return
+    }
+    res.status(201).send('User create')
+  }
+
+  static async getAll (req: Request, res: Response) {
+    const respository = getRepository(Usuario)
+    const result = await respository.find({
+      select: ['id', 'nombre', 'apellidoMaterno', 'apellidoPaterno']
+    })
+    res.status(200).json(result)
+  }
+
+  static async getOne (req: Request, res: Response) {
+    const respository = getRepository(Usuario)
+    const id: number = +req.params.id
+    try {
+      const result = await respository.findOneOrFail(id, {
+        select: ['id', 'nombre', 'apellidoMaterno', 'apellidoPaterno']
+      })
+      res.status(200).json(result)
+    } catch (e) {
+      res.status(404).send('Usuario no encontrado')
+    }
+  }
+}