// Deserializacion
        public async static Task <List <Empleado> > DeserializarArchivo(Stream stream, string nombreArchivo)
        {
            List <Empleado> empleados = new List <Empleado>();

            using (var reader = new StreamReader(stream))
            {
                while (reader.EndOfStream == false)
                {
                    string lineaTexto = await reader.ReadLineAsync();

                    lineaTexto = lineaTexto.Trim();

                    if (lineaTexto == "")
                    {
                        throw HttpResponseException
                              .BadRequest("El archivo no cumple con el formato requerido. Hay lineas vacias");
                    }

                    Empleado e = CrearEmpleadoDeLineaDeTexto(lineaTexto, nombreArchivo);
                    empleados.Add(e);
                }
            }

            return(empleados);
        }
        // Verificador de formato
        public static async Task <bool> FormatoDeDatosDeArchivoEsCorrecto(Stream stream)
        {
            using (var reader = new StreamReader(stream))
            {
                while (reader.EndOfStream == false)
                {
                    string lineaTexto = await reader.ReadLineAsync();

                    lineaTexto = lineaTexto.Trim();

                    if (lineaTexto == "")
                    {
                        throw HttpResponseException
                              .BadRequest("El archivo no cumple con el formato requerido. Hay lineas vacias");
                    }

                    bool formatoCorrectoDeEmpleado = CamposDeEmpleadoCorrecto(lineaTexto);

                    if (!formatoCorrectoDeEmpleado)
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
        private static Empleado CrearEmpleadoDesdeArray(string[] arrayCamposEmpleado, string nombreArchivo)
        {
            Empleado empleado;

            try
            {
                empleado = new Empleado()
                {
                    nombre   = arrayCamposEmpleado[0],
                    apellido = arrayCamposEmpleado[1],
                    dni      = arrayCamposEmpleado[2],
                    idPuesto = int.Parse(arrayCamposEmpleado[3]),
                    horasTrabajadasUltimoMes = int.Parse(arrayCamposEmpleado[4]),
                    cuitEmpresa = arrayCamposEmpleado[5],
                };

                if (nombreArchivo != null)
                {
                    empleado.archivo = nombreArchivo;
                }
            }
            catch (IndexOutOfRangeException)
            {
                throw HttpResponseException.BadRequest("Los campos del archivo no corresponden a los definidos en la API");
            }
            catch (Exception e)
            {
                throw HttpResponseException.InternalServer(e.Message);
            }

            return(empleado);
        }
Ejemplo n.º 4
0
        public async Task <List <EmpleadoDTO> > ImportarArchivoEmpleados(IFormFile file)
        {
            ArchivoEmpleados archivoDB = await _context.ArchivosEmpleados
                                         .Where(a => a.archivo == file.FileName).FirstOrDefaultAsync();

            if (archivoDB != null)
            {
                throw HttpResponseException.BadRequest("El archivo a importar ya fue procesado o tiene el mismo nombre");
            }

            List <Empleado> empleados = new List <Empleado>();

            bool formatoDeArchivoEsCorrecto = await DeserializadorArchivoEmpleados.FormatoDeDatosDeArchivoEsCorrecto(file.OpenReadStream());

            if (formatoDeArchivoEsCorrecto)
            {
                empleados = await DeserializadorArchivoEmpleados.DeserializarArchivo(file.OpenReadStream(), file.FileName);

                empleados = await EliminarEmpleadosExistentesEnDB(empleados);

                if (empleados.Count == 0)
                {
                    throw HttpResponseException
                          .BadRequest("Los empleados del archivo ya estan registrados. Pertenecen a otro de nombre diferente");
                }

                ArchivoEmpleados archivoDb = await SubirArchivo(file);

                if (archivoDb != null)
                {
                    _context.Empleados.AddRange(empleados);
                    int filasAfectadasDeEmpleados = await _context.SaveChangesAsync();

                    if (filasAfectadasDeEmpleados == 0)
                    {
                        throw HttpResponseException.InternalServer("Error al insertar los Empleados del archivo");
                    }
                }
                else
                {
                    throw HttpResponseException.InternalServer("Error al insertar el archivo");
                }
            }

            List <EmpleadoDTO> resul = CrearListaEmpleadosDTO(empleados);

            return(resul);
        }
        private static bool CamposDeEmpleadoCorrecto(string texto)
        {
            List <string> camposEmpleadoFormateados = texto
                                                      .Split("|").ToList()
                                                      .Select(campo => campo.Trim()).ToList()
                                                      .Where(campo => !campo.Equals("")).ToList();

            Empleado e;

            string[] arrayCamposEmpleado = camposEmpleadoFormateados.ToArray();
            try
            {
                e = CrearEmpleadoDesdeArray(arrayCamposEmpleado, null);
            }
            catch (IndexOutOfRangeException)
            {
                throw HttpResponseException
                      .BadRequest("El archivo no contiene todos los datos requeridos de un Empleado");
            }

            return(true);
        }