Beispiel #1
0
        public IActionResult Editar(int Id)
        {
            fruteriashopContext context = new fruteriashopContext();
            ProductosRepository repos   = new ProductosRepository(context);
            ProductosViewModel  vm      = new ProductosViewModel();

            vm.Producto = repos.Get(Id);

            if (vm.Producto == null)
            {
                return(RedirectToAction("Index"));
            }

            CategoriasRepository cr = new CategoriasRepository(context);

            vm.Categorias = cr.GetAll().Where(x => x.Eliminado == false).OrderBy(x => x.Nombre);

            if (System.IO.File.Exists(Enviroment.WebRootPath + $"/img_frutas/{vm.Producto.Id}.jpg"))
            {
                vm.Imagen = vm.Producto.Id + ".jpg";
            }
            else
            {
                vm.Imagen = "no-disponible.png";
            }

            return(View(vm));
        }
Beispiel #2
0
        /// <summary>
        /// Este método retorna uma listagem de todos os Categorias
        /// </summary>
        /// <returns>Não possui retorno</returns>
        public HttpResponseMessage Get()
        {
            try
            {
                List <Categorias>    categoriasModel      = new List <Categorias>();
                CategoriasRepository categoriasRepository = new CategoriasRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
                CategoriasAplication categoriasAplication = new CategoriasAplication(categoriasRepository);

                List <ProjetoSistemasWeb.Domain.Entities.Categorias> categorias = categoriasAplication.ProcurarTodos();

                foreach (var cat in categorias)
                {
                    categoriasModel.Add(new Categorias()
                    {
                        Descricao = cat.Descricao,
                        Id        = cat.Id
                    });
                }

                return(Request.CreateResponse(HttpStatusCode.OK, categoriasModel));
            }
            catch (ApplicationException ap)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ap));
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
            }
        }
Beispiel #3
0
        public IActionResult Eliminar(Categorias c)
        {
            try
            {
                // ELIMINACIÓN FISICA (SE BORRA COMPLETAMENTE DE LA BASE DE DATOS)
                //using (fruteriashopContext context = new fruteriashopContext())
                //{
                //    CategoriasRepository repos = new CategoriasRepository(context);
                //    var categoria = repos.Get(c.Id);
                //    repos.Delete(categoria);
                //    return RedirectToAction("Index");
                //}

                // ELIMINACION LOGICA (SE QUEDA EN LA BASE DE DATOS PERO CON UN CAMPO PARA ESPECIFICAR QUE ESTÁ ELIMINADA)
                using (fruteriashopContext context = new fruteriashopContext())
                {
                    CategoriasRepository repos = new CategoriasRepository(context);
                    var categoria = repos.Get(c.Id);
                    categoria.Eliminado = true;
                    repos.Update(categoria);
                    return(RedirectToAction("Index"));
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View(c));
            }
        }
Beispiel #4
0
        public IActionResult Eliminar(Categorias c)
        {
            try
            {
                // Modo físico: borra un registro de la db, operación delete.
                using (fruteriashopContext context = new fruteriashopContext())
                {
                    CategoriasRepository repos = new CategoriasRepository(context);
                    var categoria = repos.Get(c.Id);
                    repos.Delete(categoria);
                    return(RedirectToAction("Index"));
                }

                /* Modo lógico: marca el registro como eliminado, operación update.
                 * using (fruteriashopContext context = new fruteriashopContext())
                 * {
                 *  CategoriasRepository repos = new CategoriasRepository(context);
                 *  var categoria = repos.Get(c.Id);
                 *  categoria.Eliminado = true;
                 *  repos.Update(categoria);
                 *  return RedirectToAction("Index");
                 * } */
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View(c));
            }
        }
Beispiel #5
0
        /// <summary>
        /// Este método retorna um Categorias apartir de seu ID
        /// </summary>
        /// <param name="id">Id relativo a chave de busca para o Categorias</param>
        /// <returns>Retorna um Categorias</returns>
        public HttpResponseMessage Get(Guid id)
        {
            try
            {
                Categorias           categoriasModel      = null;
                CategoriasRepository categoriasRepository = new CategoriasRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
                CategoriasAplication categoriasAplication = new CategoriasAplication(categoriasRepository);

                ProjetoSistemasWeb.Domain.Entities.Categorias categorias = categoriasAplication.Procurar(id);

                if (categorias != null)
                {
                    categoriasModel = new Categorias()
                    {
                        Descricao = categorias.Descricao,
                        Id        = categorias.Id
                    };

                    return(Request.CreateResponse(HttpStatusCode.OK, categoriasModel));
                }
                else
                {
                    return(Request.CreateResponse(HttpStatusCode.NotFound));
                }
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
            }
        }
Beispiel #6
0
        public IActionResult Editar(Categorias nuevo)
        {
            try
            {
                using (fruteriashopContext context = new fruteriashopContext())
                {
                    CategoriasRepository repos = new CategoriasRepository(context);

                    var original = repos.Get(nuevo.Id);

                    if (original != null)
                    {
                        original.Nombre = nuevo.Nombre;
                        repos.Update(original);
                    }

                    return(RedirectToAction("Index"));
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View(nuevo));
            }
        }
Beispiel #7
0
        public IActionResult Eliminar(Categorias c)
        {
            //Fisica
            try
            {
                using (fruteriashopContext context = new fruteriashopContext())
                {
                    CategoriasRepository repos = new CategoriasRepository(context);
                    var categoria = repos.Get(c.Id);
                    repos.Delete(categoria);
                    return(RedirectToAction("Index"));
                }


                //Logico
                //using (fruteriashopContext context = new fruteriashopContext())
                //{

                //    CategoriasRepository repos = new CategoriasRepository(context);
                //    var categoria = repos.Get(c.Id);
                //    categoria.Eliminado = true;
                //    repos.Update(categoria);
                //    return RedirectToAction("Index");



                //}
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View(c));
            }
        }
Beispiel #8
0
        public HttpResponseMessage Post([FromBody] Categorias categorias)
        {
            try
            {
                //Inclusão do CLiente na base de dados
                //Essa inclusão retorna um Id
                //Id retorna para o requisitante do serviço
                CategoriasRepository categoriasRepository = new CategoriasRepository(ConfigurationManager.ConnectionStrings["conexao"].ToString());
                CategoriasAplication categoriasAplication = new CategoriasAplication(categoriasRepository);

                //Converter o model para uma entidade de dominio

                ProjetoSistemasWeb.Domain.Entities.Categorias categoriasDomain = new ProjetoSistemasWeb.Domain.Entities.Categorias()
                {
                    Id        = categorias.Id,
                    Descricao = categorias.Descricao
                };

                categoriasAplication.Inserir(categoriasDomain);

                return(Request.CreateResponse(HttpStatusCode.OK, Convert.ToString(categoriasDomain.Id)));
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
            }
        }
        public IActionResult EditarCategoria(CategoriasViewModel c)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    CategoriasRepository repos = new CategoriasRepository();
                    Regex regex     = new Regex(@"^[a-zA-ZáéíóúÁÉÍÓÚñÑ0-9 ]+$");
                    bool  resultado = regex.IsMatch(c.Nombre);

                    if (repos.GetCategoriasByNombre(c.Nombre) != null)
                    {
                        ModelState.AddModelError("", "Ya existe una categoria con este nombre");
                        return(View(c));
                    }
                    if (!resultado)
                    {
                        ModelState.AddModelError("", "El nombre de la categoria no puede y caracteres especiales.");
                        return(View(c));
                    }
                    repos.Update(c);
                    return(RedirectToAction("Index"));
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("", ex.Message);
                    return(View(c));
                }
            }
            else
            {
                return(View(c));
            }
        }
        public IActionResult Index()
        {
            CategoriasRepository    categoriasRepository = new CategoriasRepository();
            IEnumerable <Categoria> categoriaEnumerable  = categoriasRepository.GetAll();

            return(View(categoriaEnumerable));
        }
Beispiel #11
0
        public IEnumerable <Categorias> GetNombreCategorias()
        {
            CategoriasRepository categoriasRepository = new CategoriasRepository();
            var list = categoriasRepository.GetCategorias();

            return(list);
        }
        public IActionResult Eliminar(int id)
        {
            CategoriasRepository categoriasRepository = new CategoriasRepository();
            var categoriaResult = categoriasRepository.GetCategoriaById(id);

            return(View(categoriaResult));
        }
        public IActionResult EliminarCategoria(int id)
        {
            //ViewBag.Admin = 1;
            CategoriasRepository repos = new CategoriasRepository();
            EncuestasRepository  ER    = new EncuestasRepository();
            var v = repos.GetById(id);

            if (v != null)
            {
                if (ER.Context.Encuesta.Where(x => x.IdCategoria == id).Count() == 0)
                {
                    repos.BajaLogica(id);
                }
                else
                {
                    ViewBag.Eliminar = 1;
                }
                //ViewBag.Mensaje = "La categoria ha sido eliminada exitosamente.";
            }
            //else
            //{
            //    ViewBag.Mensaje = "La categoria no existe o ya ha sido eliminada.";
            //}
            return(RedirectToAction("Index"));
        }
        public IActionResult RecuperarCategoria(int id)
        {
            CategoriasRepository repos = new CategoriasRepository();

            repos.Recuperacion(id);
            return(RedirectToAction("Index"));
        }
Beispiel #15
0
        public IActionResult Agregar(ProductosViewModel vm)
        {
            fruteriashopContext context = new fruteriashopContext();

            if (vm.Archivo.ContentType != "image/jpeg" || vm.Archivo.Length > 1024 * 1024 * 2)
            {
                ModelState.AddModelError("", "Debe selecionar un archivo jpg de menos de 2mb");
                CategoriasRepository categoriasRepository = new CategoriasRepository(context);
                vm.Categorias = categoriasRepository.GetAll();

                return(View(vm));
            }
            try
            {
                ProductosRepository repos = new ProductosRepository(context);
                repos.Insert(vm.Producto);
                //Guardar archivo de inserción
                FileStream fs = new FileStream(Environment.WebRootPath + "/img_frutas/" + vm.Producto.Id + ".jpg", FileMode.Create);
                vm.Archivo.CopyTo(fs);
                fs.Close();

                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                CategoriasRepository categoriasRepository = new CategoriasRepository(context);
                vm.Categorias = categoriasRepository.GetAll();

                return(View(vm));
            }
        }
Beispiel #16
0
        public IActionResult Editar(int id)
        {
            fruteriashopContext context = new fruteriashopContext();
            ProductosViewModel  vm      = new ProductosViewModel();

            ProductosRepository pr = new ProductosRepository(context);

            vm.Producto = pr.Get(id);
            if (vm.Producto == null)
            {
                return(RedirectToAction("Index"));
            }
            CategoriasRepository cr = new CategoriasRepository(context);

            vm.Categorias = cr.GetAll();
            if (System.IO.File.Exists(Environment.WebRootPath + $"/img_frutas/{vm.Producto.Id}.jpg"))
            {
                vm.Imagen = vm.Producto.Id + ".jpg";
            }
            else
            {
                vm.Imagen = "no-disponible.png";
            }

            return(View(vm));
        }
Beispiel #17
0
        public IEnumerable <Categoria> GetNombreCategoria()
        {
            CategoriasRepository repos = new CategoriasRepository();
            var list = repos.GetCategoriasActivas();

            return(list);
        }
        public IActionResult Editar(CategoriaViewModel categoria)
        {
            if (categoria != null)
            {
                string error = Validar(categoria);

                if (error != "")
                {
                    ModelState.AddModelError("Error", error);
                    return(View(categoria));
                }

                try
                {
                    CategoriasRepository repos = new CategoriasRepository();
                    repos.UpdateCategoria(categoria);
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("Error", ex.Message);
                    return(View(categoria));
                }
            }
            return(RedirectToAction("Index", "Administrador/Categoria"));
        }
        public IActionResult Editar(CategoriaViewModel categoria_VM)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    CategoriasRepository categoriasRepository = new CategoriasRepository();
                    var categoriaResult = categoriasRepository.GetCategoriaByNombre(categoria_VM.Nombre.ToLower());

                    //Regex regex = new Regex(@"^[a-zA-ZñÑáéíóúÁÉÍÓÚ\s 0-9 ]+$");
                    Regex regex     = new Regex(@"^[a-zA-ZñÑáéíóúÁÉÍÓÚ\s ]+$");
                    bool  resultado = true;
                    resultado = regex.IsMatch(categoria_VM.Nombre);

                    if (!resultado)
                    {
                        ModelState.AddModelError("", "No se aceptan números y caracteres especiales en el nombre (Solo: a-z, A-Z).");
                        return(View(categoria_VM));
                    }
                    Regex  regexNoNumStart     = new Regex(@"[0-9]| $");
                    bool   resultadoNoNumStart = false;
                    string textoFirstChart     = categoria_VM.Nombre.Substring(0, 1);
                    resultadoNoNumStart = regexNoNumStart.IsMatch(textoFirstChart);
                    if (resultadoNoNumStart)
                    {
                        ModelState.AddModelError("", "No se permite iniciar con NÚMERO o con ESPACIO.");
                        return(View(categoria_VM));
                    }

                    if (categoriaResult == null)
                    {
                        categoriasRepository.UpdateCategoriaVM(categoria_VM);

                        return(RedirectToAction("Categoria", "Administrador"));
                    }
                    else if (categoriaResult.IdCategoria == categoria_VM.IdCategoria)
                    {
                        categoriaResult.Nombre = categoria_VM.Nombre;
                        categoriasRepository.Update(categoriaResult);

                        return(RedirectToAction("Categoria", "Administrador"));
                    }
                    else
                    {
                        ModelState.AddModelError("", "Ya existe esta categoría.");
                        return(View(categoria_VM));
                    }
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("", ex.Message);
                    return(View(categoria_VM));
                }
            }
            else
            {
                return(View(categoria_VM));
            }
        }
        public IActionResult Agregar(ProductosViewModel pvm)
        {
            fruteriashopContext context = new fruteriashopContext();

            //guardar el archivo de la imagen


            try
            {
                if (pvm.Archivo == null)
                {
                    ModelState.AddModelError("", "Debe seleccionar una imagen para el producto");
                    CategoriasRepository categoriasRepository = new CategoriasRepository(context);

                    pvm.Categorias = categoriasRepository.GetAll();

                    return(View(pvm));
                }
                else
                {
                    if (pvm.Archivo.ContentType != "image/jpeg" || pvm.Archivo.Length > 1024 * 1024 * 2)
                    {
                        ModelState.AddModelError("", "Debe seleccionar un archivo jpg de menos de 2MB.");
                        CategoriasRepository categoriasRepository = new CategoriasRepository(context);

                        pvm.Categorias = categoriasRepository.GetAll();

                        return(View(pvm));
                    }
                }


                ProductosRepository repos = new ProductosRepository(context);

                repos.Insert(pvm.Producto);

                if (pvm.Archivo != null)
                {
                    FileStream fs = new FileStream(Enviroment.WebRootPath + "/img_frutas/" + pvm.Producto.Id + ".jpg", FileMode.Create);
                    pvm.Archivo.CopyTo(fs);
                    fs.Close();
                }



                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                CategoriasRepository categoriasRepository = new CategoriasRepository(context);

                pvm.Categorias = categoriasRepository.GetAll();

                return(View(pvm));
            }
        }
Beispiel #21
0
        public IActionResult Agregar()
        {
            ProductosViewModel   vm      = new ProductosViewModel();
            fruteriashopContext  context = new fruteriashopContext();
            CategoriasRepository repos   = new CategoriasRepository(context);

            vm.Categorias = repos.GetAll().Where(x => x.Eliminado == false).OrderBy(x => x.Nombre);
            return(View(vm));
        }
Beispiel #22
0
        public IActionResult Agregar()
        {
            ProductosViewModel   vm      = new ProductosViewModel();
            fruteriashopContext  context = new fruteriashopContext();
            CategoriasRepository categoriasRepository = new CategoriasRepository(context);

            vm.Categorias = categoriasRepository.GetAll();
            return(View(vm));
        }
        public async Task <List <CategoriasContenidos> > ListarContenidoDeUnaCategoria(CategoriasContenidos categoriaContenidoParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository        categoriasRepo  = new CategoriasRepository(context);
                List <CategoriasContenidos> listaCategorias = await categoriasRepo.ListarContenidoDeUnaCategoria(categoriaContenidoParaListar);

                return(listaCategorias);
            }
        }
        public async Task <List <CategoriasGruposDTO> > ListarCategoriasDeUnGrupoPorIdioma(CategoriasGrupos categoriaGrupoParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository       categoriasRepo       = new CategoriasRepository(context);
                List <CategoriasGruposDTO> listaCategoriaEvento = await categoriasRepo.ListarCategoriasDeUnGrupoPorIdioma(categoriaGrupoParaListar);

                return(listaCategoriaEvento);
            }
        }
        public async Task <CategoriasRepresentantesDTO> BuscarCategoriaRepresentantePorConsecutivoAndIdioma(CategoriasRepresentantes categoriaRepresentantesParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository        categoriasRepo = new CategoriasRepository(context);
                CategoriasRepresentantesDTO categoriaRepresentanteBuscada = await categoriasRepo.BuscarCategoriaRepresentantePorConsecutivoAndIdioma(categoriaRepresentantesParaBuscar);

                return(categoriaRepresentanteBuscada);
            }
        }
        public async Task <List <CategoriasRepresentantesDTO> > ListarCategoriasDeUnRepresentantePorIdioma(CategoriasRepresentantes categoriaRepresentanteParaListar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository categoriasRepo = new CategoriasRepository(context);
                List <CategoriasRepresentantesDTO> listaCategoriasRepresentantes = await categoriasRepo.ListarCategoriasDeUnRepresentantePorIdioma(categoriaRepresentanteParaListar);

                return(listaCategoriasRepresentantes);
            }
        }
        public async Task <List <int> > ListarCodigoCategoriasDeUnRepresentante(int codigoPersona)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository categoriasRepo = new CategoriasRepository(context);
                List <int>           listaCategoriasRepresentante = await categoriasRepo.ListarCodigoCategoriasDeUnRepresentante(codigoPersona);

                return(listaCategoriasRepresentante);
            }
        }
        public async Task <Categorias> BuscarCategoria(Categorias categoriaParaBuscar)
        {
            using (SportsGoEntities context = new SportsGoEntities(false))
            {
                CategoriasRepository categoriasRepo   = new CategoriasRepository(context);
                Categorias           categoriaBuscada = await categoriasRepo.BuscarCategoria(categoriaParaBuscar);

                return(categoriaBuscada);
            }
        }
        public IActionResult Index(ProductosIndexViewModel vm)
        {
            fruteriashopContext  context         = new fruteriashopContext();
            CategoriasRepository categoriasRepos = new CategoriasRepository(context);
            ProductosRepository  productosRepos  = new ProductosRepository(context);

            vm.Categorias = categoriasRepos.GetAll();
            vm.Productos  = productosRepos.GetProductosByCategoria(vm.IdCategoria);
            return(View(vm));
        }
        public IActionResult AgregarCategoria(DACategoriasViewModel categoria)
        {
            //ViewBag.Admin = 1;
            if (ModelState.IsValid)
            {
                //try
                //{
                CategoriasRepository RepositorioCategorias = new CategoriasRepository();

                var   ResultNombre    = RepositorioCategorias.GetCategoriaByNombre(categoria.Nombre);
                Regex regexNombre     = new Regex(@"^[a-zA-ZáéíóúÁÉÍÓÚñÑ0-9 ]{6,}$");
                bool  resultNombreCat = regexNombre.IsMatch(categoria.Nombre);

                if (!resultNombreCat)
                {
                    ModelState.AddModelError("", "El nombre debe contener 6 o más caracteres, no puede iniciar con un número y no puede contener caracteres especiales.");
                    return(View(categoria));
                }

                Regex  regexIniciaNum       = new Regex(@"[0-9]| $");
                string expresion            = categoria.Nombre.Substring(0, 1);
                bool   resultRegexIniciaNum = regexIniciaNum.IsMatch(expresion);
                if (resultRegexIniciaNum)
                {
                    ModelState.AddModelError("", "El nombre de la categoria no puede iniciar con un numero.");
                    return(View(categoria));
                }
                if (ResultNombre == null)
                {
                    RepositorioCategorias.Insert(categoria);
                    return(RedirectToAction("Index"));
                }
                else
                {
                    ModelState.AddModelError("", "Ya existe una categoria con el mismo nombre.");
                    if (RepositorioCategorias.GetCategoriaByNombre(categoria.Nombre).Estatus == false)
                    {
                        ViewBag.Recuperacion = true;
                        ViewBag.IdEncRec     = RepositorioCategorias.GetCategoriaByNombre(categoria.Nombre).Id;
                    }
                    return(View(categoria));
                }

                //}
                //catch (Exception ex)
                //{
                //    ModelState.AddModelError("", ex.Message);
                //    return View(categoria);
                //}
            }
            else
            {
                return(View(categoria));
            }
        }