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

            if (oferta == null)
            {
                return(NotFound(new { mensagem = "Não foi possível deletar a oferta pois o ID informado não existe!" }));
            }
            await _repositorio.Excluir(oferta);

            return(oferta);
        }
Esempio n. 2
0
        public async Task <ActionResult <Oferta> > Delete(int id)
        {
            var oferta = await _repositorio.BuscarPorID(id);

            if (oferta == null)
            {
                return(NotFound());
            }
            await _repositorio.Excluir(oferta);

            return(oferta);
        }
        public async Task <ActionResult <Oferta> > Delete(int id)
        {
            var oferta = await repositorio.BuscarPorId(id);

            if (oferta == null)
            {
                return(NotFound(new{ mensagem = "Nenhuma oferta encontrada para o ID informado" }));
            }
            oferta = await repositorio.Excluir(oferta);

            return(oferta);
        }
Esempio n. 4
0
        private static async void RotinaOfertaExpirada()
        {
            using (CoorganicasContext _contexto = new CoorganicasContext()){
                OfertaRepository _oferta = new OfertaRepository();

                var Ofertas = await _oferta.Listar();

                foreach (var oferta in Ofertas)
                {
                    if (oferta.Validade.Date <= DateTime.Now.Date)
                    {
                        var Ret = await _oferta.Excluir(oferta);
                    }
                }
            }
        }
Esempio n. 5
0
        public async Task <ActionResult <Oferta> > Delete(int id)
        {
            var oferta = await _repositorio.BuscarPorID(id);

            if (oferta == null)
            {
                return(NotFound("Oferta não encontrada"));
            }
            try {
                await _repositorio.Excluir(oferta);
            } catch (System.Exception ex) {
                return(BadRequest(new {
                    mensagem = "Não foi possível excluir. Raw: " + ex
                }));
            }
            return(oferta);
        }
Esempio n. 6
0
        /// <summary>
        ///     Rotina para excluir reservas expiradas e ofertas vencidas
        /// </summary>
        /// <returns></returns>
        public static async void RotinaReservaExistente()
        {
            using (CoorganicasContext _contexto = new CoorganicasContext()){
                OfertaRepository  _oferta  = new OfertaRepository();
                ReservaRepository _reserva = new ReservaRepository();

                var Reservas = await _contexto.Reserva.Include("Oferta").ToListAsync();

                var Ofertas = await _contexto.Oferta.ToListAsync();

                if (Ofertas != null)
                {
                    foreach (var reserva in Reservas)
                    {
                        if (reserva.DataEspera <= DateTime.Now.Date)
                        {
                            var qtd = reserva.Quantidade;

                            foreach (var oferta in Ofertas)
                            {
                                if (oferta.OfertaId == reserva.Oferta.OfertaId)
                                {
                                    oferta.Quantidade = oferta.Quantidade + qtd;
                                    await _oferta.Alterar(oferta);

                                    await _reserva.Excluir(reserva);

                                    if (oferta.Validade.Date <= DateTime.Now.Date)
                                    {
                                        await _oferta.Excluir(oferta);
                                    }
                                }
                            }
                        }
                    }

                    RotinaOfertaExpirada();
                }
            }
        }
Esempio n. 7
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);
        }