496 lines
17 KiB
TypeScript
496 lines
17 KiB
TypeScript
import * as fs from 'fs';
|
|
import * as csvtojson from 'csvtojson';
|
|
import { BadRequestException, Injectable } from '@nestjs/common';
|
|
import { AppGateway } from '../app.gateway';
|
|
import { Equipo } from '../equipo/entity/equipo.entity';
|
|
import { Institucion } from '../institucion/entity/institucion.entity';
|
|
import { InstitucionUsuario } from '../institucion-usuario/entity/institucion-usuario.entity';
|
|
import { CarritoService } from '../carrito/carrito.service';
|
|
import { EquipoService } from '../equipo/equipo.service';
|
|
import { EquipoProgramaService } from '../equipo-programa/equipo-programa.service';
|
|
import { EquipoTipoEntradaService } from '../equipo-tipo-entrada/equipo-tipo-entrada.service';
|
|
import { InstitucionService } from '../institucion/institucion.service';
|
|
import { InstitucionCarreraService } from '../institucion-carrera/institucion-carrera.service';
|
|
import { InstitucionProgramaService } from '../institucion-programa/institucion-programa.service';
|
|
import { InstitucionTipoCarritoService } from '../institucion-tipo-carrito/institucion-tipo-carrito.service';
|
|
import { InstitucionTipoEntradaService } from '../institucion-tipo-entrada/institucion-tipo-entrada.service';
|
|
import { InstitucionUsuarioService } from '../institucion-usuario/institucion-usuario.service';
|
|
import { MarcaService } from '../marca/marca.service';
|
|
import { ModeloService } from '../modelo/modelo.service';
|
|
import { ModuloService } from '../modulo/modulo.service';
|
|
import { TipoUsuarioService } from '../tipo-usuario/tipo-usuario.service';
|
|
import { UsuarioService } from '../usuario/usuario.service';
|
|
import { UploadFileCargaMasivaUsuarioDto } from './dto/upload-file-carga-masiva-usuario.dto';
|
|
import { UploadFileCargaMasivaEquipoDto } from './dto/upload-file-carga-masiva-equipo.dto';
|
|
|
|
@Injectable()
|
|
export class UploadFileService {
|
|
constructor(
|
|
private appGateway: AppGateway,
|
|
private carritoService: CarritoService,
|
|
private equipoService: EquipoService,
|
|
private equipoProgramaService: EquipoProgramaService,
|
|
private equipoTipoEntradaService: EquipoTipoEntradaService,
|
|
private institucionService: InstitucionService,
|
|
private institucionCarreraService: InstitucionCarreraService,
|
|
private institucionProgramaService: InstitucionProgramaService,
|
|
private institucionTipoCarritoService: InstitucionTipoCarritoService,
|
|
private institucionTipoEntradaService: InstitucionTipoEntradaService,
|
|
private institucionUsuarioService: InstitucionUsuarioService,
|
|
private marcaService: MarcaService,
|
|
private modeloService: ModeloService,
|
|
private moduloService: ModuloService,
|
|
private tipoUsuarioService: TipoUsuarioService,
|
|
private usuarioService: UsuarioService,
|
|
) {}
|
|
|
|
async createEquipos(path: string, id_institucion: number) {
|
|
const institucion = await this.institucionService.findById(id_institucion);
|
|
let errores: string[] = [];
|
|
let mensajes: string[] = [];
|
|
let equiposNuevos: Equipo[] = [];
|
|
|
|
csvtojson()
|
|
.fromFile(path)
|
|
.then(async (equipos: UploadFileCargaMasivaEquipoDto[]) => {
|
|
for (let i = 0; i < equipos.length; i++) {
|
|
await this.evaluarEquipo(
|
|
institucion,
|
|
i,
|
|
equipos[i],
|
|
mensajes,
|
|
errores,
|
|
equiposNuevos,
|
|
);
|
|
if ((i + 1) % 90 === 0 || i + 1 === equipos.length) {
|
|
this.appGateway.equiposNuevos(institucion.id_institucion, {
|
|
errores,
|
|
mensajes,
|
|
equiposNuevos,
|
|
});
|
|
errores = [];
|
|
mensajes = [];
|
|
equiposNuevos = [];
|
|
}
|
|
}
|
|
fs.unlink(path, (err) => {});
|
|
});
|
|
return { message: 'Se subió y cargó correctamente su archivo csv.' };
|
|
}
|
|
|
|
async createUsuarios(path: string, id_institucion: number) {
|
|
const institucion = await this.institucionService.findById(id_institucion);
|
|
let errores: string[] = [];
|
|
let mensajes: string[] = [];
|
|
let usuariosNuevos: InstitucionUsuario[] = [];
|
|
|
|
csvtojson()
|
|
.fromFile(path)
|
|
.then(async (usuarios: UploadFileCargaMasivaUsuarioDto[]) => {
|
|
for (let i = 0; i < usuarios.length; i++) {
|
|
await this.evaluarUsuario(
|
|
institucion,
|
|
i,
|
|
usuarios[i],
|
|
mensajes,
|
|
errores,
|
|
usuariosNuevos,
|
|
);
|
|
if ((i + 1) % 100 === 0 || i + 1 === usuarios.length) {
|
|
this.appGateway.usuariosNuevos(institucion.id_institucion, {
|
|
errores,
|
|
mensajes,
|
|
usuariosNuevos,
|
|
});
|
|
errores = [];
|
|
mensajes = [];
|
|
usuariosNuevos = [];
|
|
}
|
|
}
|
|
});
|
|
return { message: 'Se subió y cargó correctamente tu archivo csv.' };
|
|
}
|
|
|
|
downloadLogo(id_institucion: number) {
|
|
// return this.institucionService
|
|
// .findById(id_institucion)
|
|
// .then((institucion) => institucion.logo);
|
|
}
|
|
|
|
errorBase(index) {
|
|
return `Se saltó la linea ${
|
|
index + 2
|
|
} por el siguiente/los siguientes motivo(s):`;
|
|
}
|
|
|
|
async evaluarEquipo(
|
|
institucion: Institucion,
|
|
index: number,
|
|
dataEquipo: UploadFileCargaMasivaEquipoDto,
|
|
mensajes: string[],
|
|
errores: string[],
|
|
equiposNuevos: Equipo[],
|
|
) {
|
|
const errorAux = this.errorBase(index);
|
|
let error = errorAux;
|
|
|
|
if (
|
|
!dataEquipo.carrito ||
|
|
!dataEquipo.entradas ||
|
|
!dataEquipo.equipo ||
|
|
!dataEquipo.marca ||
|
|
!dataEquipo.modelo ||
|
|
!dataEquipo.modulo ||
|
|
!dataEquipo.numero_inventario ||
|
|
!dataEquipo.numero_serie ||
|
|
!dataEquipo.tipo
|
|
) {
|
|
if (!dataEquipo.carrito) error += ' falta del campo carrito';
|
|
if (!dataEquipo.entradas) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo entradas';
|
|
}
|
|
if (!dataEquipo.equipo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo equipo';
|
|
}
|
|
if (!dataEquipo.marca) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo marca';
|
|
}
|
|
if (!dataEquipo.modelo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo modelo';
|
|
}
|
|
if (!dataEquipo.modulo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo modulo';
|
|
}
|
|
if (!dataEquipo.numero_inventario) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo numero_inventario';
|
|
}
|
|
if (!dataEquipo.numero_serie) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo numero_serie';
|
|
}
|
|
if (!dataEquipo.tipo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo tipo';
|
|
}
|
|
errores.push(error + '.');
|
|
return;
|
|
}
|
|
|
|
const tipoCarrito =
|
|
await this.institucionTipoCarritoService.findTipoCarritoByTipoCarrito(
|
|
dataEquipo.tipo,
|
|
);
|
|
const modulo = await this.moduloService.findModulo(
|
|
institucion,
|
|
dataEquipo.modulo,
|
|
);
|
|
const marca = await this.marcaService.findByMarca(
|
|
dataEquipo.marca,
|
|
'e',
|
|
false,
|
|
);
|
|
const modelo = await this.modeloService.findByModelo(
|
|
dataEquipo.modelo,
|
|
'e',
|
|
false,
|
|
);
|
|
const carrito =
|
|
tipoCarrito && modulo
|
|
? await this.carritoService.findCarrito(
|
|
modulo,
|
|
tipoCarrito,
|
|
dataEquipo.carrito,
|
|
)
|
|
: null;
|
|
let equipo = carrito
|
|
? await this.equipoService.findByEquipo(carrito, dataEquipo.equipo, false)
|
|
: null;
|
|
|
|
if (!tipoCarrito || !marca || !modelo || !modulo || !carrito) {
|
|
if (!tipoCarrito) error += ' no existe este tipo de carrito';
|
|
if (!marca) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' no existe esta marca';
|
|
}
|
|
if (!modelo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' no existe este modelo';
|
|
}
|
|
if (!modulo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' no existe este módulo';
|
|
}
|
|
if (!carrito) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' no existe este carrito';
|
|
}
|
|
errores.push(error + '.');
|
|
return;
|
|
}
|
|
|
|
if (equipo) {
|
|
errores.push(
|
|
`${error} ya existe un equipo de cómputo con el sobrenombre: ${equipo.equipo} en el carrito: ${equipo.carrito.carrito}.`,
|
|
);
|
|
return;
|
|
} else {
|
|
equipo = await this.equipoService.findByNumeroInventario(
|
|
institucion,
|
|
dataEquipo.numero_inventario,
|
|
false,
|
|
);
|
|
if (equipo) {
|
|
errores.push(
|
|
`${error} ya existe un equipo con ese número de inventario en esta institución.`,
|
|
);
|
|
return;
|
|
}
|
|
await this.equipoService
|
|
.create(
|
|
dataEquipo.equipo,
|
|
carrito,
|
|
dataEquipo.numero_inventario,
|
|
dataEquipo.numero_serie,
|
|
marca,
|
|
modelo,
|
|
)
|
|
.then(async (equipo) => {
|
|
const entradas = dataEquipo.entradas.split(',');
|
|
const programas = dataEquipo.programas
|
|
? dataEquipo.programas.split(',')
|
|
: [];
|
|
|
|
equipo.programas = [];
|
|
equipo.tiposEntradas = [];
|
|
for (let j = 0; j < entradas.length; j++) {
|
|
const tipoEntrada =
|
|
await this.institucionTipoEntradaService.findTipoEntradaByTipoEntrada(
|
|
entradas[j].trim(),
|
|
);
|
|
const existeEquipoTipoEntrada = tipoEntrada
|
|
? await this.equipoTipoEntradaService.findByEquipoTipoEntrada(
|
|
equipo,
|
|
tipoEntrada,
|
|
)
|
|
: null;
|
|
|
|
if (!tipoEntrada || existeEquipoTipoEntrada) {
|
|
if (!tipoEntrada)
|
|
errores.push(
|
|
`No se asignó el conector: ${
|
|
entradas[j]
|
|
}, al equipo de la linea ${
|
|
index + 2
|
|
} porque no existe este conector.`,
|
|
);
|
|
if (existeEquipoTipoEntrada)
|
|
errores.push(
|
|
`El conector: ${
|
|
entradas[j]
|
|
}, ya fue asignado al equipo de la linea ${index + 2}.`,
|
|
);
|
|
continue;
|
|
}
|
|
await this.equipoTipoEntradaService
|
|
.create(equipo, tipoEntrada)
|
|
.then((equipoTipoEntrada) =>
|
|
equipo.tiposEntradas.push(equipoTipoEntrada),
|
|
);
|
|
}
|
|
for (let j = 0; j < programas.length; j++) {
|
|
const programa =
|
|
await this.institucionProgramaService.findProgramaByPrograma(
|
|
programas[j].trim(),
|
|
);
|
|
const existeEquipoPrograma = programa
|
|
? await this.equipoProgramaService.findByEquipoPrograma(
|
|
equipo,
|
|
programa,
|
|
)
|
|
: null;
|
|
|
|
if (!programa || existeEquipoPrograma) {
|
|
if (!programa)
|
|
errores.push(
|
|
`No se asignó el software: ${
|
|
programas[j]
|
|
}, al equipo de la linea ${
|
|
index + 2
|
|
} porque no existe este software.`,
|
|
);
|
|
if (existeEquipoPrograma)
|
|
errores.push(
|
|
`El programa: ${
|
|
programas[j]
|
|
}, ya lo tiene asignado el equipo de la linea ${index + 2}.`,
|
|
);
|
|
continue;
|
|
}
|
|
await this.equipoProgramaService
|
|
.create(equipo, programa)
|
|
.then((equipoPrograma) => equipo.programas.push(equipoPrograma));
|
|
}
|
|
equiposNuevos.push(equipo);
|
|
});
|
|
}
|
|
}
|
|
|
|
async evaluarUsuario(
|
|
institucion: Institucion,
|
|
index: number,
|
|
dataUsuario: UploadFileCargaMasivaUsuarioDto,
|
|
mensajes: string[],
|
|
errores: string[],
|
|
usuariosNuevos: InstitucionUsuario[],
|
|
) {
|
|
const errorAux = this.errorBase(index);
|
|
let error = errorAux;
|
|
|
|
if (!dataUsuario.numero_cuenta || !dataUsuario.tipo_usuario) {
|
|
if (!dataUsuario.numero_cuenta) error += ' falta del campo numero_cuenta';
|
|
if (!dataUsuario.tipo_usuario) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo tipo_usuario';
|
|
}
|
|
errores.push(`${error}.`);
|
|
return;
|
|
}
|
|
|
|
const tipoUsuario = await this.tipoUsuarioService.findByTipoUsuario(
|
|
dataUsuario.tipo_usuario,
|
|
false,
|
|
);
|
|
const usuario = await this.usuarioService.findByUsuario(
|
|
dataUsuario.numero_cuenta,
|
|
);
|
|
const carrera =
|
|
tipoUsuario && (tipoUsuario.id_tipo_usuario === 5 || dataUsuario.carrera)
|
|
? await this.institucionCarreraService.findCarreraByCarrera(
|
|
tipoUsuario.id_tipo_usuario === 5
|
|
? 'PROFESOR'
|
|
: dataUsuario.carrera,
|
|
false,
|
|
)
|
|
: null;
|
|
const institucionCarrera = carrera
|
|
? await this.institucionCarreraService.findByIdInstitucionIdCarrera(
|
|
institucion,
|
|
carrera,
|
|
)
|
|
: null;
|
|
|
|
if (
|
|
!tipoUsuario ||
|
|
tipoUsuario.id_tipo_usuario < 5 ||
|
|
!carrera ||
|
|
(carrera && !institucionCarrera)
|
|
) {
|
|
if (!tipoUsuario) error += ' no existe este tipo de usuario.';
|
|
else if (tipoUsuario.id_tipo_usuario < 5)
|
|
' no se puede asignar este tipo de usuario a este usuario.';
|
|
if (!carrera) error += ' falta del campo carrera para el alumno.';
|
|
if (carrera && !institucionCarrera)
|
|
error += ' la carrera no pertenece a la institución.';
|
|
errores.push(error);
|
|
return;
|
|
}
|
|
|
|
let nombre = `${dataUsuario.apellido_p.trim()} ${dataUsuario.apellido_m.trim()} ${dataUsuario.nombres.trim()}`;
|
|
|
|
while (nombre.search('Ñ') != -1) {
|
|
nombre = nombre.replace('√ë', 'Ñ');
|
|
}
|
|
while (nombre.search('Ñ') != -1) {
|
|
nombre = nombre.replace('√É∆í√¢‚ǨÀú', 'Ñ');
|
|
}
|
|
if (usuario) {
|
|
let existeInstitucionUsuario =
|
|
await this.institucionUsuarioService.findByIdUsuarioIdInstitucionCarrera(
|
|
usuario.id_usuario,
|
|
institucionCarrera.id_institucion_carrera,
|
|
);
|
|
|
|
if (existeInstitucionUsuario && !existeInstitucionUsuario.activo) {
|
|
existeInstitucionUsuario.activo = true;
|
|
await this.institucionUsuarioService.save(existeInstitucionUsuario);
|
|
} else if (!existeInstitucionUsuario)
|
|
await this.institucionUsuarioService
|
|
.create(institucionCarrera, usuario)
|
|
.then(({ message }) => mensajes.push(message));
|
|
if (
|
|
usuario.nombre != nombre ||
|
|
usuario.tipoUsuario.id_tipo_usuario != tipoUsuario.id_tipo_usuario ||
|
|
(dataUsuario.correo && usuario.correo != dataUsuario.correo)
|
|
) {
|
|
if (usuario.tipoUsuario.id_tipo_usuario != tipoUsuario.id_tipo_usuario)
|
|
usuario.tipoUsuario = tipoUsuario;
|
|
if (usuario.nombre != nombre) usuario.nombre = nombre;
|
|
if (dataUsuario.correo && usuario.correo != dataUsuario.correo)
|
|
usuario.correo = dataUsuario.correo;
|
|
await this.usuarioService
|
|
.save(usuario)
|
|
.then(({ message }) => mensajes.push(message));
|
|
}
|
|
} else {
|
|
if (
|
|
!dataUsuario.nombres ||
|
|
!dataUsuario.apellido_m ||
|
|
!dataUsuario.apellido_p ||
|
|
!dataUsuario.correo ||
|
|
(tipoUsuario.id_tipo_usuario === 5 && !dataUsuario.rfc)
|
|
) {
|
|
if (tipoUsuario.id_tipo_usuario === 5 && !dataUsuario.rfc)
|
|
error += ' falta del campo rfc';
|
|
if (!dataUsuario.nombres) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo nombres';
|
|
}
|
|
if (!dataUsuario.apellido_m) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo apellido_m';
|
|
}
|
|
if (!dataUsuario.apellido_p) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo apellido_p';
|
|
}
|
|
if (!dataUsuario.correo) {
|
|
if (error != errorAux) error += ',';
|
|
error += ' falta del campo correo';
|
|
}
|
|
errores.push(`${error}.`);
|
|
return;
|
|
}
|
|
await this.usuarioService
|
|
.create(
|
|
dataUsuario.numero_cuenta,
|
|
nombre,
|
|
tipoUsuario,
|
|
institucionCarrera,
|
|
dataUsuario.correo,
|
|
dataUsuario.rfc ? dataUsuario.rfc : '',
|
|
)
|
|
.then(({ message, institucionUsuario }) => {
|
|
usuariosNuevos.push(institucionUsuario);
|
|
mensajes.push(message);
|
|
});
|
|
}
|
|
}
|
|
|
|
async uploadLogo(file: Express.Multer.File, id_institucion: number) {
|
|
const path = file ? `${file.destination}/${file.filename}` : null;
|
|
const institucion = await this.institucionService.findById(id_institucion);
|
|
|
|
if (!file) throw new BadRequestException('No se mandó ningún logo.');
|
|
institucion.logo = path;
|
|
// return this.institucionService
|
|
// .update(institucion)
|
|
// .then((_) => ({ message: 'Se subió correctamente el logo.' }));
|
|
}
|
|
}
|