Ejemplo n.º 1
0
        public async Task <IActionResult> Especificaciones(TipoNormaEspecificacionViewModel tipoNormaEspecificacion)
        {
            try
            {
                await cargarListaEspecificacionesViewData();

                if (tipoNormaEspecificacion.ValorMinimo == null && tipoNormaEspecificacion.ValorMaximo == null)
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.DebeIntroducirAlMenosUnRango}";
                    return(View(await ObtenerNormaEspecificacion(tipoNormaEspecificacion.TipoNormaId, tipoNormaEspecificacion)));
                }

                if (tipoNormaEspecificacion.ValorMinimo > tipoNormaEspecificacion.ValorMaximo)
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ValorMinimoMayorRangoMaximo}";
                    return(View(await ObtenerNormaEspecificacion(tipoNormaEspecificacion.TipoNormaId, tipoNormaEspecificacion)));
                }

                var existeRegistro = false;

                if (!await db.Norma.AnyAsync(c => c.EspecificacionId == tipoNormaEspecificacion.EspecificacionId && c.TipoNormaId == tipoNormaEspecificacion.TipoNormaId))
                {
                    var p = new Norma
                    {
                        TipoNormaId      = tipoNormaEspecificacion.TipoNormaId,
                        EspecificacionId = tipoNormaEspecificacion.EspecificacionId,
                        ValorMaximo      = tipoNormaEspecificacion.ValorMaximo,
                        ValorMinimo      = tipoNormaEspecificacion.ValorMinimo,
                    };
                    await db.AddAsync(p);
                }
                else
                {
                    existeRegistro = true;
                }

                if (!existeRegistro)
                {
                    await db.SaveChangesAsync();

                    TempData["Mensaje"] = $"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}";
                    return(View(await ObtenerNormaEspecificacion(tipoNormaEspecificacion.TipoNormaId, null)));
                }
                else
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                }

                return(View(await ObtenerNormaEspecificacion(tipoNormaEspecificacion.TipoNormaId, tipoNormaEspecificacion)));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> Manage(Models.Especificacion Especificacion)
        {
            try
            {
                ViewBag.accion = Especificacion.EspecificacionId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    var existeRegistro = false;
                    if (Especificacion.EspecificacionId == 0)
                    {
                        if (!await db.Especificacion.AnyAsync(c => c.Descripcion.ToUpper().Trim() == Especificacion.Descripcion.ToUpper().Trim()))
                        {
                            await db.AddAsync(Especificacion);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.Especificacion.Where(c => c.Descripcion.ToUpper().Trim() == Especificacion.Descripcion.ToUpper().Trim()).AnyAsync(c => c.EspecificacionId != Especificacion.EspecificacionId))
                        {
                            var CurrentEspecificacion = await db.Especificacion.Where(x => x.EspecificacionId == Especificacion.EspecificacionId).FirstOrDefaultAsync();

                            CurrentEspecificacion.Descripcion         = Especificacion.Descripcion;
                            CurrentEspecificacion.TipoEspecificacion  = Especificacion.TipoEspecificacion;
                            CurrentEspecificacion.Analisis            = Especificacion.Analisis;
                            CurrentEspecificacion.ClaseEspecificacion = Especificacion.ClaseEspecificacion;
                            CurrentEspecificacion.DescripcionIngles   = Especificacion.DescripcionIngles;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(base.View(Especificacion));
                }

                return(base.View(Especificacion));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
        public async Task <IActionResult> Manage(ProductoFinal ProductoFinal)
        {
            try
            {
                ViewBag.accion = ProductoFinal.ProductoFinalId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    await cargarCombos();

                    var existeRegistro = false;
                    if (ProductoFinal.ProductoFinalId == 0)
                    {
                        if (!await db.ProductoFinal.AnyAsync(c => c.Codigo.ToUpper().Trim() == ProductoFinal.Codigo.ToUpper().Trim() && c.ProductoId == ProductoFinal.ProductoId))
                        {
                            await db.AddAsync(ProductoFinal);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.ProductoFinal.Where(c => c.Codigo.ToUpper().Trim() == ProductoFinal.Codigo.ToUpper().Trim() && c.ProductoId == ProductoFinal.ProductoId).AnyAsync(c => c.ProductoFinalId != ProductoFinal.ProductoFinalId))
                        {
                            var CurrentProductoFinal = await db.ProductoFinal.Where(x => x.ProductoFinalId == ProductoFinal.ProductoFinalId).FirstOrDefaultAsync();

                            CurrentProductoFinal.Codigo      = ProductoFinal.Codigo;
                            CurrentProductoFinal.Descripcion = ProductoFinal.Descripcion;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(View(ProductoFinal));
                }

                return(View(ProductoFinal));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 4
0
        public async Task <IActionResult> Manage(Cliente Cliente)
        {
            try
            {
                ViewBag.accion = Cliente.ClienteId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    var existeRegistro = false;
                    if (Cliente.ClienteId == 0)
                    {
                        if (!await db.Cliente.AnyAsync(c => c.NombreCliente.ToUpper().Trim() == Cliente.NombreCliente.ToUpper().Trim()))
                        {
                            await db.AddAsync(Cliente);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.Cliente.Where(c => c.NombreCliente.ToUpper().Trim() == Cliente.NombreCliente.ToUpper().Trim()).AnyAsync(c => c.ClienteId != Cliente.ClienteId))
                        {
                            var CurrentCliente = await db.Cliente.Where(x => x.ClienteId == Cliente.ClienteId).FirstOrDefaultAsync();

                            CurrentCliente.NombreCliente = Cliente.NombreCliente;
                            CurrentCliente.CodigoCliente = null;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(View(Cliente));
                }

                return(View(Cliente));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 5
0
        public async Task <IActionResult> Manage(Proveedor proveedor)
        {
            try
            {
                ViewBag.accion = proveedor.ProveedorId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    var existeRegistro = false;
                    if (proveedor.ProveedorId == 0)
                    {
                        if (!await db.Proveedor.AnyAsync(c => c.CodigoProveedor.ToUpper().Trim() == proveedor.CodigoProveedor.ToUpper().Trim()))
                        {
                            await db.AddAsync(proveedor);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.Proveedor.Where(c => c.CodigoProveedor.ToUpper().Trim() == proveedor.CodigoProveedor.ToUpper().Trim()).AnyAsync(c => c.ProveedorId != proveedor.ProveedorId))
                        {
                            var CurrentProveedor = await db.Proveedor.Where(x => x.ProveedorId == proveedor.ProveedorId).FirstOrDefaultAsync();

                            CurrentProveedor.NombreProveedor = proveedor.NombreProveedor;
                            CurrentProveedor.CodigoProveedor = proveedor.CodigoProveedor;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(View(proveedor));
                }

                return(View(proveedor));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
        public async Task <IActionResult> Especificaciones(TipoMaterialEspecificacionViewModel tipoMaterialEspecificacion)
        {
            try
            {
                await cargarListaEspecificacionesViewData();

                var existeRegistro = false;

                if (!await db.TipoMaterialEspecificacion.AnyAsync(c => c.EspecificacionId == tipoMaterialEspecificacion.EspecificacionId && c.TipoMaterialId == tipoMaterialEspecificacion.TipoMaterialId))
                {
                    var p = new TipoMaterialEspecificacion
                    {
                        TipoMaterialId   = tipoMaterialEspecificacion.TipoMaterialId,
                        EspecificacionId = tipoMaterialEspecificacion.EspecificacionId,
                    };
                    await db.AddAsync(p);
                }
                else
                {
                    existeRegistro = true;
                }

                if (!existeRegistro)
                {
                    await db.SaveChangesAsync();

                    TempData["Mensaje"] = $"{Mensaje.Informacion}|{Mensaje.Satisfactorio}";
                    return(View(await ObtenerTipoMaterialEspecificacion(tipoMaterialEspecificacion.TipoMaterialId, null)));
                }
                else
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                }

                return(View(await ObtenerTipoMaterialEspecificacion(tipoMaterialEspecificacion.TipoMaterialId, tipoMaterialEspecificacion)));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 7
0
        public async Task <IActionResult> Manage(Maquina maquina)
        {
            try
            {
                ViewBag.accion = maquina.MaquinaId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    var existeRegistro = false;
                    if (maquina.MaquinaId == 0)
                    {
                        if (!await db.Maquina.AnyAsync(c => c.NombreMaquina.ToUpper().Trim() == maquina.NombreMaquina.ToUpper().Trim()))
                        {
                            await db.AddAsync(maquina);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.Maquina.Where(c => c.NombreMaquina.ToUpper().Trim() == maquina.NombreMaquina.ToUpper().Trim()).AnyAsync(c => c.MaquinaId != maquina.MaquinaId))
                        {
                            var CurrentMaquina = await db.Maquina.Where(x => x.MaquinaId == maquina.MaquinaId).FirstOrDefaultAsync();

                            CurrentMaquina.NombreMaquina = maquina.NombreMaquina;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(View(maquina));
                }

                return(View(maquina));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 8
0
        public async Task <IActionResult> Manage(Pais Pais)
        {
            try
            {
                ViewBag.accion = Pais.PaisId == 0 ? "Crear" : "Editar";
                if (ModelState.IsValid)
                {
                    var existeRegistro = false;
                    if (Pais.PaisId == 0)
                    {
                        if (!await db.Pais.AnyAsync(c => c.DescripcionPais.ToUpper().Trim() == Pais.DescripcionPais.ToUpper().Trim()))
                        {
                            await db.AddAsync(Pais);
                        }

                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    else
                    {
                        if (!await db.Pais.Where(c => c.DescripcionPais.ToUpper().Trim() == Pais.DescripcionPais.ToUpper().Trim()).AnyAsync(c => c.PaisId != Pais.PaisId))
                        {
                            var CurrentPais = await db.Pais.Where(x => x.PaisId == Pais.PaisId).FirstOrDefaultAsync();

                            CurrentPais.DescripcionPais = Pais.DescripcionPais;
                        }
                        else
                        {
                            existeRegistro = true;
                        }
                    }
                    if (!existeRegistro)
                    {
                        await db.SaveChangesAsync();

                        return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
                    }
                    else
                    {
                        TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                    }
                    return(View(Pais));
                }

                return(View(Pais));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 9
0
        public async Task <IActionResult> Especificaciones(ProductoEspecificacionViewModel productoEspecificacion)
        {
            try
            {
                await cargarListaEspecificacionesViewData();


                var existeRegistro = false;

                if (!await db.ProductoEspecificacion.AnyAsync(c => c.EspecificacionId == productoEspecificacion.EspecificacionId && c.ProductoId == productoEspecificacion.ProductoId))
                {
                    var especificacion = await db.Especificacion.Where(x => x.EspecificacionId == productoEspecificacion.EspecificacionId).FirstOrDefaultAsync();

                    var p = new ProductoEspecificacion
                    {
                        ProductoId       = productoEspecificacion.ProductoId,
                        EspecificacionId = productoEspecificacion.EspecificacionId,
                    };

                    switch (especificacion.TipoEspecificacion)
                    {
                    case "Rango":
                        if (productoEspecificacion.RangoMinimo == null && productoEspecificacion.RangoMaximo == null)
                        {
                            TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.DebeIntroducirAlMenosUnRango}";
                            return(View(await ObtenerProductoEspecificacion(productoEspecificacion.ProductoId, productoEspecificacion)));
                        }
                        if (productoEspecificacion.RangoMinimo > productoEspecificacion.RangoMaximo)
                        {
                            TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.RangoMinimoMayorRangoMaximo}";
                            return(View(await ObtenerProductoEspecificacion(productoEspecificacion.ProductoId, productoEspecificacion)));
                        }
                        p.RangoMaximo = productoEspecificacion.RangoMaximo;
                        p.RangoMinimo = productoEspecificacion.RangoMinimo;
                        break;

                    case "Texto":
                        p.ValorEsperado = productoEspecificacion.ValorEsperado;
                        break;

                    case "Número":
                        p.ValorEsperadoNum = productoEspecificacion.ValorEsperadoNum;
                        break;

                    case "Bit":
                        p.ValorEsperado = "CUMPLE";
                        break;
                    }
                    await db.AddAsync(p);
                }
                else
                {
                    existeRegistro = true;
                }

                if (!existeRegistro)
                {
                    await db.SaveChangesAsync();

                    TempData["Mensaje"] = $"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}";
                    return(View(await ObtenerProductoEspecificacion(productoEspecificacion.ProductoId, null)));
                }
                else
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                }

                return(View(await ObtenerProductoEspecificacion(productoEspecificacion.ProductoId, productoEspecificacion)));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 10
0
        public async Task <IActionResult> Especificaciones(MaterialEspecificacionViewModel materialEspecificacion)
        {
            try
            {
                await cargarListaEspecificacionesViewData();

                var especificacionId = materialEspecificacion.EspecificacionId;
                var Material         = await db.Material.Where(x => x.MaterialId == materialEspecificacion.MaterialId).FirstOrDefaultAsync();

                // var materialEspecificacionA = db.Material.Where(x => x.MaterialId == materialEspecificacion.MaterialId).FirstOrDefaultAsync();

                var Norma = await db.Norma.Where(c => c.EspecificacionId == especificacionId &&
                                                 c.TipoNorma.TipoNormaId == Material.TipoNormaId)
                            .FirstOrDefaultAsync();

                var cumpleNorma = true;

                if (Norma.ValorMinimo >= Convert.ToDecimal(materialEspecificacion.ValorEspecificacion) || Norma.ValorMinimo <= Convert.ToDecimal(materialEspecificacion.ValorEspecificacion))
                {
                    cumpleNorma = false;
                }


                var existeRegistro = false;

                if (!await db.MaterialEspecificacion.AnyAsync(c => c.EspecificacionId == materialEspecificacion.EspecificacionId && c.MaterialId == materialEspecificacion.MaterialId))
                {
                    var p = new MaterialEspecificacion
                    {
                        MaterialId          = materialEspecificacion.MaterialId,
                        EspecificacionId    = materialEspecificacion.EspecificacionId,
                        ValorEspecificacion = materialEspecificacion.ValorEspecificacion,
                    };
                    await db.AddAsync(p);
                }
                else
                {
                    existeRegistro = true;
                }

                if (!existeRegistro)
                {
                    await db.SaveChangesAsync();

                    if (cumpleNorma)
                    {
                        TempData["Mensaje"] = $"{Mensaje.Informacion}|{Mensaje.Satisfactorio}";
                        return(View(await ObtenerMaterialeEspecificacion(materialEspecificacion.MaterialId, null)));
                    }

                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.NoCumpleNorma}";
                    return(View(await ObtenerMaterialeEspecificacion(materialEspecificacion.MaterialId, null)));
                }
                else
                {
                    TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
                }

                return(View(await ObtenerMaterialeEspecificacion(materialEspecificacion.MaterialId, materialEspecificacion)));
            }
            catch (Exception)
            {
                return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
            }
        }
Ejemplo n.º 11
0
        public async Task <JsonResult> Create(List <DetalleAnalisis> listaDetalle, Analisis analisis, List <Material> listaMateriales)
        {
            using (var transaction = await db.Database.BeginTransactionAsync())
            {
                try
                {
                    var resultado = listaDetalle.Where(x => (x.Aprobado == false)).FirstOrDefault();

                    if (resultado != null)
                    {
                        analisis.Resultado = "NO CUMPLE";
                    }
                    else
                    {
                        analisis.Resultado = "CUMPLE";
                    }

                    if (string.IsNullOrEmpty(analisis.Observaciones))
                    {
                        analisis.Observaciones = string.Empty;
                    }

                    analisis.NombreUsuario = User.Identity.Name;

                    var analisisCreate = await db.AddAsync(analisis);

                    await db.SaveChangesAsync();

                    var idAnalisisCreado = analisisCreate.Entity.AnalisisId;



                    var listaDetalleInsertar = listaDetalle.Select(x => new DetalleAnalisis {
                        AnalisisId = idAnalisisCreado, Aprobado = x.Aprobado, EspecificacionId = x.EspecificacionId, RangoReferenciaActual = x.RangoReferenciaActual, Resultado = x.Resultado,
                    }).ToList();
                    await db.AddRangeAsync(listaDetalleInsertar);

                    var listaAnalisisMaterialInsertar = listaMateriales.Select(x => new AnalisisMaterial {
                        AnalisisId = idAnalisisCreado, MateriaId = x.MaterialId
                    });
                    await db.AddRangeAsync(listaAnalisisMaterialInsertar);


                    await db.SaveChangesAsync();

                    if (analisis.Resultado == "NO CUMPLE")
                    {
                        var listadoEmails        = new List <string>();
                        var listaAdministradores = await userManager.GetUsersInRoleAsync(Perfiles.Administracion);

                        foreach (var item in listaAdministradores)
                        {
                            listadoEmails.Add(item.Email);
                        }

                        var cuerpo = await emailSender.CuerpoAnalisisNoValido(analisisCreate.Entity);

                        emailSender.SendEmailAsync(listadoEmails, Mensaje.AsuntoCorreo, cuerpo);
                    }

                    transaction.Commit();

                    return(Json(1));
                }
                catch (Exception)
                {
                    transaction.Rollback();
                    return(Json(-1));
                }
            }
        }