Пример #1
0
        public IActionResult Alterar([FromBody] FilmeViewModel pFilme)
        {
            var filme = _mapper.Map <FilmeViewModel, Filme>(pFilme);

            if (filme.EhValido())
            {
                _filmeRepository.Atualizar(filme);
                _filmeRepository.SaveChanges();

                return(Response(true, filme));
            }
            return(Response(false, erros: filme.ValidationErrors));
        }
Пример #2
0
        public async Task Alugar(Locacao locacao)
        {
            if (locacao.ClienteId == Guid.Empty)
            {
                throw new Exception("Cliente não pode ser nulo");
            }
            if (locacao.FilmeId == Guid.Empty)
            {
                throw new Exception("Filme não pode ser nulo");
            }

            var filme = await _filmeRepository.ObterPorId(locacao.FilmeId);

            if (filme == null)
            {
                throw new Exception("Filme não encontrado");
            }

            var cliente = await _clienteRepository.ObterPorId(locacao.ClienteId);

            if (cliente == null)
            {
                throw new Exception("Cliente não encontrado");
            }

            if (_locacaoRepository.VerificarSeClienteJaLocouFilme(locacao.ClienteId, locacao.FilmeId).Result.Any())
            {
                throw new Exception("O Filme já foi locado anteriormente");
            }

            if (filme.QuantidadeDisponivel == 0)
            {
                throw new Exception("O Filme esta indisponivel");
            }



            locacao.Inicio = DateTime.Now;

            await _locacaoRepository.Adicionar(locacao);

            filme.QuantidadeDisponivel--;
            await _filmeRepository.Atualizar(filme);
        }
Пример #3
0
        public ActionResult <Usuario> Edit(Guid id, Filme filme)
        {
            //if (id != usuario.Id) return BadRequest();

            var resultado = _filmeRepository.Atualizar(filme);

            if (resultado == null)
            {
                BadRequest();
            }

            return(Ok(resultado));
        }
Пример #4
0
        public async Task <ActionResult <FilmeCadastro> > Atualizar(Guid id, FilmeCadastro filmeViewModel)
        {
            if (id != filmeViewModel.Id)
            {
                return(BadRequest());
            }

            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            await _repository.Atualizar(_mapper.Map <Filme>(filmeViewModel));

            return(CustomResponse(filmeViewModel));
        }
Пример #5
0
        public async Task <IActionResult> Edit(Guid id, Filme filme)
        {
            if (id != filme.Id)
            {
                return(NotFound());
            }

            if (!ModelState.IsValid)
            {
                return(View(filme));
            }

            await _filmeRepository.Atualizar(filme);

            // ViewData["UsuarioID"] = new SelectList(_context.Usuarios, "Id", "Nome", filme.UsuarioID);
            return(RedirectToAction("Index"));
        }
Пример #6
0
        public ICommandResult Handle(AtualizarFilmeCommand command)
        {
            try
            {
                if (!command.ValidarCommand())
                {
                    return(new CommandResult(false, "Por favor, corrija as inconsistências abaixo", command.Notifications));
                }

                int    id      = command.Id;
                string titulo  = command.Titulo;
                string diretor = command.Diretor;

                Filme filme = new Filme(id, titulo, diretor);

                if (filme.Id == 0)
                {
                    AddNotification("Id", "Id não está vinculado à operação solicitada");
                }

                if (!_repository.CheckId(filme.Id))
                {
                    AddNotification("Id", "Este Id não está cadastrado! Impossível prosseguir com este Id.");
                }

                if (Invalid)
                {
                    return(new CommandResult(false, "Por favor, corrija as inconsistências abaixo", Notifications));
                }

                _repository.Atualizar(filme);

                return(new CommandResult(true, "Filme atualizado com sucesso!", new
                {
                    Id = filme.Id,
                    Titulo = filme.Titulo,
                    Diretor = filme.Diretor
                }));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #7
0
        public IActionResult Atualizar(int id, Filme filmeAtualizado)
        {
            try
            {
                Filme filmeBuscado = _filmeRepository.BuscarPorId(id);

                if (filmeBuscado != null)
                {
                    _filmeRepository.Atualizar(id, filmeAtualizado);

                    return(StatusCode(204, filmeAtualizado));
                }

                return(NotFound("Nenhum filme encontrado para o ID informado."));
            }
            catch (Exception error)
            {
                return(BadRequest(error));
            }
        }
Пример #8
0
        public Filme Atualizar(Filme filme)
        {
            if (filme == null)
            {
                return(null);
            }

            if (!filme.IsValid())
            {
                return(filme);
            }

            var regrasFilme = new FilmeAptoParaAtualizacaoValidation(_filmeRepository).Validate(filme);

            foreach (var item in regrasFilme.Errors)
            {
                filme.ValidationResult.Errors.Add(item);
            }

            filme = _filmeRepository.Atualizar(filme);
            return(filme);
        }
 public Filme Atualizar(Filme filme)
 {
     return(_filmeRepository.Atualizar(filme));
 }