Esempio n. 1
0
        public async Task <ActionResult <Oferta> > Get(int id)
        {
            var oferta = await _repositorio.BuscarPorID(id);

            if (oferta == null)
            {
                return(NotFound(new { mensagem = "Id da Oferta não encontrado", Erro = true }));
            }
            return(oferta);
        }
Esempio n. 2
0
        public async Task <ActionResult <Oferta> > Get(int id)
        {
            var oferta = await _repositorio.BuscarPorID(id);

            if (oferta == null)
            {
                return(NotFound());
            }
            return(oferta);
        }
        public async Task <ActionResult <Oferta> > Get(int id)
        {
            //FindAsync = procurar algo especifico no banco
            //await espera acontecer
            var Oferta = await _repositorio.BuscarPorID(id);

            if (Oferta == null)
            {
                return(NotFound());
            }

            return(Oferta);
        }
        public async Task <ActionResult> Put(int id, [FromBody] AlterarReservaViewModel reserva)
        {
            ReservaRepository _reserva = new ReservaRepository();
            var ReservaUsuario         = await _reserva.BuscarPorID(id);

            if (ReservaUsuario == null)
            {
                return(NotFound(new {
                    Mensagem = "Reserva não encontrada",
                    Erro = true
                }));
            }

            OfertaRepository _oferta = new OfertaRepository();
            var QtdOferta            = await _oferta.BuscarPorID(ReservaUsuario.OfertaId.Value);


            if (QtdOferta != null)
            {
                QtdOferta.Quantidade = QtdOferta.Quantidade + ReservaUsuario.Quantidade;
                var RetornorOferta = await _oferta.Alterar(QtdOferta);
            }


            if (QtdOferta.Quantidade < reserva.Quantidade)
            {
                return(NotFound(new {
                    Mensagem = "Atenção! Quantidade desejada maior que a ofertada",
                    Erro = true
                }));
            }

            var ReservaAlterada = VerificaAlteracaoReserva(ReservaUsuario, reserva);

            QtdOferta.Quantidade = QtdOferta.Quantidade - ReservaAlterada.Quantidade;

            try {
                await _repositorio.Alterar(ReservaAlterada);

                await _oferta.Alterar(QtdOferta);

                return(Ok(new {
                    Mensagem = "Reserva Alterada Com Sucesso",
                    Erro = false
                }));
            } catch (DbUpdateConcurrencyException) {
                //Verificamos se o objeto realmente existe no banco
                var reserva_valido = await _repositorio.BuscarPorID(id);

                if (reserva_valido == null)
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }
        }
Esempio n. 5
0
        public async Task <ActionResult <Reserva> > Post(Reserva reserva)
        {
            try {
                await _repositorio.Salvar(reserva);

                var oferta = await _ofertaRepo.BuscarPorID(reserva.IdOferta);

                oferta.Quantidade = oferta.Quantidade - reserva.QuantidadeComprada;

                await _ofertaRepo.Alterar(oferta);

                oferta = await _ofertaRepo.BuscarPorID(reserva.IdOferta);

                if (oferta.Quantidade == 0)
                {
                    await _ofertaRepo.Excluir(oferta);
                }

                //    Alterar quantidade de ofertas disponiveis
            } catch (DbUpdateConcurrencyException) {
                throw;
            }
            return(reserva);
        }
        public async Task <ActionResult <Reserva> > Post([FromBody] CadastrarReservaViewModel reserva)
        {
            try {
                OfertaRepository _oferta = new OfertaRepository();
                var QtdOferta            = await _oferta.BuscarPorID(reserva.OfertaId);

                if (QtdOferta.Quantidade < reserva.Quantidade)
                {
                    return(Accepted(new {
                        Mensagem = "Quantidade desejada maior que a ofertada",
                        Erro = true
                    }));
                }

                Reserva NovoReserva = new Reserva();
                NovoReserva.DataReserva   = DateTime.Now.Date;
                NovoReserva.DataEspera    = NovoReserva.DataReserva.AddDays(5);
                NovoReserva.StatusReserva = "Aguardando";
                NovoReserva.UsuarioId     = PegarUsuarioLogadoId(); // Quanto fizer a pagina de login volta a função
                NovoReserva.OfertaId      = reserva.OfertaId;
                NovoReserva.Quantidade    = reserva.Quantidade;

                var RetornoReserva = await _repositorio.Salvar(NovoReserva);

                if (RetornoReserva != null)
                {
                    QtdOferta.Quantidade = QtdOferta.Quantidade - reserva.Quantidade;
                    var RetornorOferta = await _oferta.Alterar(QtdOferta);

                    if (RetornorOferta != null)
                    {
                        return(Ok(new {
                            Mensagem = "Reserva Cadastrada Com Sucesso",
                            Erro = false
                        }));
                    }
                }

                return(NotFound(new {
                    Mensagem = "Não Foi Possível Fazer a Reserva",
                    Erro = true
                }));
            } catch (DbUpdateConcurrencyException) {
                throw;
            }
        }
        public async Task <ActionResult <Reserva> > Delete(int id)
        {
            var reserva = await _repositorio.BuscarPorID(id);

            if (reserva == null)
            {
                return(NotFound());
            }

            OfertaRepository _oferta = new OfertaRepository();
            var oferta = await _oferta.BuscarPorID(reserva.OfertaId.Value);

            if (oferta.Validade.Date > DateTime.Now.Date)
            {
                oferta.Quantidade = oferta.Quantidade + reserva.Quantidade;
                await _oferta.Alterar(oferta);
            }


            await _repositorio.Excluir(reserva);

            return(reserva);
        }