public ActionResult Cadastrar(GeneroViewModel view)
        {
            var retorno = new RetornoMensagem();

            try
            {
                var genero = new ProjetoBibliotecaDeFilme.Library.BibliotecadeFilme.Model.Genero
                {
                    GeneroId  = view.GeneroId,
                    Descricao = view.Descricao
                };

                _generoBLONovo.Salvar(genero);

                retorno.Mensagem
                    = string.Format("Genero {0} Cadastrado com Sucesso. <br />", view.Descricao);
                retorno.TipoMensagem = TipoMensagem.Sucesso;
                retorno.Resultado    = true;
            }
            catch (ProjetoBibliotecaDeFilme.Library.BibliotecadeFilme.Utils.ProjetoException ex)
            {
                retorno.Mensagem     = ex.Message;
                retorno.TipoMensagem = TipoMensagem.Alerta;
                retorno.Resultado    = false;
            }
            catch (Exception ex)
            {
                retorno.Mensagem     = "Erro ao Cadastrar.<br />";
                retorno.TipoMensagem = TipoMensagem.Erro;
                retorno.Resultado    = false;
            }
            return(Json(retorno));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Descricao")] GeneroViewModel generoViewModel)
        {
            if (id != generoViewModel.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var genero = Mapper.Map <GeneroViewModel, Genero>(generoViewModel);
                    _context.Update(genero);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!GeneroViewModelExists(generoViewModel.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(generoViewModel));
        }
Exemple #3
0
        public ActionResult Edit(int id, GeneroViewModel model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    GeneroRepository repository = new GeneroRepository(context);

                    #region Validaciones
                    //validar nombre unico

                    bool existeGenero = repository.Query(x => x.Nombre == model.Nombre && x.GeneroId != model.GeneroId).Count > 0;
                    if (existeGenero)
                    {
                        ModelState.AddModelError("Name", "El nombre del genero ya existe.");
                        return(View(model));
                    }
                    #endregion

                    Genero genero = MapHelper.Map <Genero>(model);

                    repository.Update(genero);
                    context.SaveChanges();
                }


                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        public ActionResult Editar(int id)
        {
            var genero = _generoBLONovo.BuscarPorId(id);
            var view   = new GeneroViewModel(genero);

            return(View(view));
        }
Exemple #5
0
        public ActionResult Delete(int id, GeneroViewModel model)
        {
            try
            {
                GeneroRepository repository = new GeneroRepository(context);
                var genero = repository.Query(e => e.GeneroId == id).First();
                context.Entry(genero).Collection(g => g.Medias).Load();

                if (genero.Medias.Count() == 0)
                {
                    genero.Activo = false;
                    repository.Update(genero);
                    context.SaveChanges();
                    return(RedirectToAction("Index"));
                }
                else
                {
                    return(RedirectToAction("Index"));
                }
            }
            catch
            {
                return(View());
            }
        }
Exemple #6
0
        public ActionResult Create(GeneroViewModel model)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    GeneroRepository repository = new GeneroRepository(context);
                    repository.Query(g => g.Activo == true);
                    #region Validaciones
                    //validar nombre unico
                    var geneQry = new Genero {
                        Nombre = model.Nombre
                    };
                    bool existeGenero = repository.QueryByExample(geneQry).Count > 0;
                    if (existeGenero)
                    {
                        ModelState.AddModelError("Nombre", "El nombre del genero ya existe.");
                        return(View(model));
                    }
                    #endregion
                    Genero genero = MapHelper.Map <Genero>(model);
                    genero.Activo = true;
                    repository.Insert(genero);
                    context.SaveChanges();
                }

                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                ModelState.AddModelError("", ex.Message);
                return(View());
            }
        }
        // GET: Generoes/Create
        public ActionResult Create()
        {
            var generoVm = new GeneroViewModel();

            ViewBag.Title = "Nova Categoria";
            return(View("GeneroEditForm", generoVm));
        }
Exemple #8
0
        public ActionResult Editar(GeneroViewModel view)
        {
            var retorno = new RetornoMensagem();

            try
            {
                var genero = new Genero()
                {
                    GeneroId  = view.GeneroId,
                    Descricao = view.Descricao
                };

                _generoBLO.Editar(genero);

                retorno.Mensagem
                    = string.Format("Genero {0} - {1} Editado com Sucesso. <br />", view.GeneroId, view.Descricao);
                retorno.TipoMensagem = TipoMensagem.Sucesso;
                retorno.Resultado    = true;
            }
            catch (ProjetoException ex)
            {
                retorno.Mensagem     = ex.Message;
                retorno.TipoMensagem = TipoMensagem.Alerta;
                retorno.Resultado    = false;
            }
            catch (Exception ex)
            {
                retorno.Mensagem     = "Erro ao Editar.<br />";
                retorno.TipoMensagem = TipoMensagem.Erro;
                retorno.Resultado    = false;
            }

            return(Json(retorno));
        }
Exemple #9
0
        public async Task <GeneroViewModel> Adicionar(GeneroViewModel generoViewModel)
        {
            var genero = new Genero(generoViewModel.IdGenero, generoViewModel.Nome, generoViewModel.Ativo,
                                    generoViewModel.IdCriadoPor, generoViewModel.IdCriadoPor, generoViewModel.IdExcluidoPor);

            BeginTransaction();
            var generoServiceRetorno = await _generoService.Adicionar(genero);

            generoViewModel = _generoServiceMapper.MapToGeneroViewModel(generoServiceRetorno);
            if (!generoViewModel.ValidationResult.IsValid)
            {
                return(generoViewModel);
            }

            var sucessoCommit = await Commit();

            if (!sucessoCommit)
            {
                if (!sucessoCommit)
                {
                    generoViewModel.ValidationResult.Errors.Add(new ValidationFailure("Commit", "Ocorreu um erro ao salvar as informações no banco de dados. Por favor, tente novamente"));
                }
            }

            return(generoViewModel);
        }
        public GeneroViewModel Atualizar(GeneroViewModel genero)
        {
            var index = generos.FindIndex(e => e.IdGenero == genero.IdGenero);

            generos[index] = genero;
            return(genero);
        }
        public JsonResult ConsultaGenero(string[] data)
        {
            GeneroDALImpl generoDAL = new GeneroDALImpl();
            Genero        genero_temporal;

            GeneroViewModel generoViewModel;

            if (data != null)
            {
                int data1 = int.Parse(data[0]);

                genero_temporal = generoDAL.GetGeneroById(data1);


                generoViewModel = new GeneroViewModel
                {
                    id_genero = genero_temporal.id_genero,
                    genero1   = genero_temporal.genero1
                };

                return(Json(generoViewModel));
            }
            else
            {
                return(Json(String.Format("'Success':'false','Error':'Ha habido un error al mapear los datos.'")));
            }
        }
        public GeneroViewModel Novo(GeneroViewModel auto)
        {
            var model = _mapper.Map <GeneroViewModel, Genero>(auto);

            model = _repository.Novo(model);
            _repository.SaveChanges();
            return(_mapper.Map <Genero, GeneroViewModel>(model));
        }
        public GeneroViewModel Atualizar(GeneroViewModel genero)
        {
            var model = _mapper.Map <GeneroViewModel, Genero>(genero);

            model = _repository.Atualizar(model);
            _repository.SaveChanges();
            return(_mapper.Map <Genero, GeneroViewModel>(model));
        }
        public void Destroy(GeneroViewModel obj)
        {
            var entity = entities.Generos.FirstOrDefault(c => c.Id == obj.Id);

            if (entity != null)
            {
                entities.Delete(entity);
                entities.SaveChanges();
            }
        }
        public IActionResult NovoGenero(GeneroViewModel genero)
        {
            var res = _api.PostAsJsonAsync(genero);

            if (res.IsSuccessStatusCode)
            {
                return(RedirectToAction(ACTION_INDEX));
            }

            return(View());
        }
        public void Update(GeneroViewModel obj)
        {
            var entity = entities.Generos.FirstOrDefault(c => c.Id == obj.Id);

            if (entity != null)
            {
                entity.Nombre = obj.Nombre;

                entities.SaveChanges();
            }
        }
        public async Task <IActionResult> Post([FromBody] GeneroViewModel viewModel)
        {
            var generoGerenciamento = _provider.GetRequiredService <GeneroGerenciamento> ();

            if (!await generoGerenciamento.Insert(viewModel.MapTo(new Genero())))
            {
                return(new GeneroErrorJson(generoGerenciamento));
            }

            return(Created());
        }
        public void Create(GeneroViewModel obj)
        {
            var entity = new Genero();

            entity.Nombre        = obj.Nombre;
            entity.Fechacreacion = DateTime.Now;

            entities.Add(entity);
            entities.SaveChanges();
            obj.Id = entity.Id;
        }
        public async Task <CustomResponse <GeneroViewModel> > PutGeneroAsync(int id, GeneroViewModel generoViewModel)
        {
            var genero = JsonSerializer.Serialize(generoViewModel, JsonSerializerOptions);

            var conteudo = new StringContent(genero, Encoding.UTF8, "application/json");
            var resposta = await _httpClient.PutAsync($"{id}", conteudo);

            var json = await resposta.Content.ReadAsStringAsync();

            return(JsonSerializer.Deserialize <CustomResponse <GeneroViewModel> >(json, JsonSerializerOptions));
        }
        public IActionResult Editar(int id, GeneroViewModel genero)
        {
            var res = _api.PutAsJsonAsync(id, genero);

            if (res.IsSuccessStatusCode)
            {
                return(RedirectToAction(ACTION_INDEX));
            }

            return(View());
        }
        public async Task <ActionResult <GeneroViewModel> > Add(GeneroViewModel generoViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            await _generoService.Adicionar(_mapper.Map <Genero>(generoViewModel));

            return(CustomResponse(generoViewModel));
        }
        public ActionResult Edit(GeneroViewModel generoViewModel)
        {
            if (ModelState.IsValid)
            {
                var genero = Mapper.Map <Genero>(generoViewModel);
                generoService.Update(genero);

                return(RedirectToAction("Index"));
            }

            return(View(generoViewModel));
        }
Exemple #23
0
 public ActionResult Delete(int id, GeneroViewModel generoViewModel)
 {
     try
     {
         _generoService.RemoverGenero(generoViewModel.GeneroViewModelToGenero());
         return(RedirectToAction("Index"));
     }
     catch
     {
         return(View());
     }
 }
        public async Task <GeneroViewModel> Remover(Guid id)
        {
            var genero   = new GeneroViewModel();
            var response = await _httpClient.DeleteAsync($"generos/{id}");

            if (!TratarErrosResponse(response))
            {
                genero.ResponseResult = await DeserializarResponse <ResponseResult>(response);
            }

            return(genero);
        }
Exemple #25
0
 public ActionResult Create(GeneroViewModel generoViewModel)
 {
     try
     {
         _generoService.IncluirGenero(generoViewModel.GeneroViewModelToGenero());
         return(RedirectToAction("Index"));
     }
     catch (Exception e)
     {
         return(View());
     }
 }
        public async Task <IActionResult> Create([Bind("Id,Descricao")] GeneroViewModel generoViewModel)
        {
            if (ModelState.IsValid)
            {
                var genero = Mapper.Map <GeneroViewModel, Genero>(generoViewModel);
                _context.Add(genero);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(generoViewModel));
        }
Exemple #27
0
        public IActionResult Alterar([FromBody] GeneroViewModel pGenero)
        {
            var genero = _mapper.Map <GeneroViewModel, Genero>(pGenero);

            if (genero.EhValido())
            {
                _generoRepository.Atualizar(genero);
                _generoRepository.SaveChanges();

                return(Response(true, pGenero));
            }
            return(Response(false, erros: genero.ValidationErrors));
        }
 public ActionResult Excluir(GeneroViewModel viewModel)
 {
     try
     {
         var genero = Mapper.Map <Genero>(viewModel);
         _generoService.Remove(genero);
         return(RedirectToAction("Index"));
     }
     catch (Exception ex)
     {
         throw;
     }
 }
        public async Task <IActionResult> Adicionar(GeneroViewModel generoViewModel)
        {
            await _generoService.Adicionar(_mapper.Map <Genero>(generoViewModel));

            await Commit(_generoRepository);

            if (!OperacaoValida())
            {
                return(CustomBadRequest());
            }

            return(CreatedAtRoute("GeneroPorId", new { id = generoViewModel.Id }, generoViewModel));
        }
        public async Task <GeneroViewModel> Atualizar(Guid id, GeneroViewModel generoViewModel)
        {
            var genero        = new GeneroViewModel();
            var generoContent = ObterConteudo(generoViewModel);

            var response = await _httpClient.PutAsync($"generos/{id}", generoContent);

            if (!TratarErrosResponse(response))
            {
                genero.ResponseResult = await DeserializarResponse <ResponseResult>(response);
            }

            return(genero);
        }