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;
}
}
}
public async Task <ActionResult> Put(int id, Oferta oferta)
{
if (id != oferta.IdOferta)
{
return(BadRequest());
}
_contexto.Entry(oferta).State = EntityState.Modified;
try {
var arquivo = Request.Form.Files[0];
oferta.IdProduto = Convert.ToInt32(Request.Form["IdProduto"]);
oferta.IdUsuario = Convert.ToInt32(Request.Form["IdUsuario"]);
oferta.Quantidade = Convert.ToInt32(Request.Form["Quantidade"]);
oferta.Preco = Request.Form["Preco"];
oferta.FotoUrlOferta = _Upload.Upload(arquivo, "Ofertas");
await _repositorio.Alterar(oferta);
} catch (DbUpdateConcurrencyException) {
var oferta_valido = await _repositorio.BuscarPorID(id);
if (oferta_valido == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//[Authorize (Roles = "Fornecedor")]
public async Task <ActionResult> Put(int id, [FromForm] Oferta oferta)
{
if (id != oferta.IdOferta)
{
return(BadRequest(new { mensagem = "Oferta não encontrado", Erro = true }));
}
try {
var arquivo = Request.Form.Files[0];
oferta.NomeOferta = Request.Form["nomeOferta"].ToString();
oferta.Marca = Request.Form["marca"].ToString();
oferta.Preco = decimal.Parse(Request.Form["Preco"]);
oferta.Validade = DateTime.Parse(Request.Form["Validade"]);
oferta.QuantVenda = int.Parse(Request.Form["quantVenda"]);
oferta.Descricao = Request.Form["descricao"].ToString();
oferta.Imagem = _uploadRepo.Upload(arquivo, "imgOferta");
await _repositorio.Alterar(oferta);
} catch (DbUpdateConcurrencyException) {
var oferta_valido = await _repositorio.BuscarPorID(id);
if (oferta_valido == null)
{
return(NotFound(new { mensagem = "Oferta não encontrado", Erro = true }));
}
else
{
throw;
}
}
return(Ok("Oferta atualizada com sucesso!!!"));
}
public async Task <ActionResult> Put(int id, Oferta oferta)
{
// Se o id do objeto não existir, ele retorna erro 400
if (id != oferta.IdOferta)
{
return(BadRequest());
}
try
{
await _repositorio.Alterar(oferta);
}
catch (DbUpdateConcurrencyException)
{
// Verificamos se o objeto inserido realmente existe no banco
var oferta_valido = await _repositorio.BuscarPorId(id);
if (oferta_valido == null)
{
return(NotFound(new { mensagem = "Nenhuma Oferta foi encontrada!" }));
}
else
{
throw;
}
}
// NoContent = retorna 204, sem nada
return(NoContent());
}
public async Task <ActionResult <Oferta> > Put(int id, [FromForm] Oferta oferta)
{
if (id != oferta.IdOferta)
{
return(BadRequest());
}
try {
var arquivo = Request.Form.Files[0];
oferta.Quantidade = int.Parse(Request.Form["quantidade"]);
oferta.Foto = _uploadRepo.Upload(arquivo, "imgOferta");
oferta.Cor = Request.Form["cor"].ToString();
oferta.Preco = double.Parse(Request.Form["preco"]);
oferta.Descricao = Request.Form["descricao"].ToString();
oferta.DataValidade = DateTime.Parse(Request.Form["dataValidade"]);
oferta.IdProduto = int.Parse(Request.Form["idProduto"]);
oferta.IdUsuario = int.Parse(Request.Form["idUsuario"]);
await _repositorio.Alterar(oferta);
} catch (DbUpdateConcurrencyException) {
var oferta_valida = await _repositorio.BuscarPorID(id);
if (oferta_valida == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(oferta);
}
public async Task <ActionResult> Put(int id, Oferta oferta)
{
if (id != oferta.OfertaId)
{
return(BadRequest(new{ mensagem = "Erro na validação da oferta por ID" }));
}
try
{
await repositorio.Alterar(oferta);
}
catch (DbUpdateConcurrencyException ex)
{
var oferta_valido = await repositorio.BuscarPorId(id);
if (oferta_valido == null)
{
return(NotFound(new{ mensagem = "Nenhuma oferta encontrada para o ID informado" }));
}
else
{
return(BadRequest(new{ mensagem = "Erro na alteração de dados por ID" + ex }));
}
}
return(Accepted());
}
public async Task <ActionResult> Put(int id, [FromForm] AlterarOfertaViewModel oferta)
{
//Se o Id do objeto não existir
//ele retorna o erro 400
if (oferta.Cidade == null && oferta.preco == 0 && oferta.Regiao == null && oferta.Quantidade == 0 && oferta.Descricao == null && oferta.Validade == null)
{
return(NoContent());
}
var ofertaUsuario = await _repositorio.BuscarPorID(id);
if (ofertaUsuario == null)
{
return(NotFound(
new {
Mensagem = "Oferta Não Encontrada",
Erro = true
}
));
}
var OfertaAlterada = VerificaAlteracaoOferta(ofertaUsuario, oferta);
try {
await _repositorio.Alterar(OfertaAlterada);
return(Ok(
new{
Mensagem = "Oferta alterada com sucesso",
Erro = false
}
));
} catch (DbUpdateConcurrencyException) {
//Verificamos se o objeto realmente existe no banco
var Oferta_valido = await _repositorio.BuscarPorID(id);
if (Oferta_valido == null)
{
return(NoContent());
}
else
{
throw;
}
}
}
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;
}
}
/// <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();
}
}
}
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);
}
//[Authorize (Roles = "3")]
//[Authorize (Roles = "2")]
public async Task <ActionResult> Put(int id, Oferta oferta)
{
if (id != oferta.IdOferta)
{
return(BadRequest());
}
_contexto.Entry(oferta).State = EntityState.Modified;
try {
var arquivo = Request.Form.Files[0];
oferta.IdOferta = Convert.ToInt32(Request.Form["IdOferta"]);
oferta.IdProduto = Convert.ToInt32(Request.Form["IdProduto"]);
oferta.IdUsuario = Convert.ToInt32(Request.Form["IdUsuario"]);
oferta.Quantidade = (Request.Form["Quantidade"]);
oferta.NomeProduto = Request.Form["NomeProduto"];
oferta.Preco = decimal.Parse(Request.Form["Preco"]);
oferta.DescricaoDoProduto = Request.Form["DescricaoDoProduto"];
oferta.Validade = DateTime.Parse(Request.Form["Validade"]);
oferta.FotoUrlOferta = _Upload.Upload(arquivo, "Ofertas");
await _repositorio.Alterar(oferta);
} catch (DbUpdateConcurrencyException) {
var oferta_valido = await _repositorio.BuscarPorID(id);
if (oferta_valido == null)
{
return(NotFound(new { mensagem = "Oferta não encontrado", Erro = true }));
}
else
{
throw;
}
}
return(Ok("Oferta atualizada com sucesso!!!"));
}
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);
}