public IActionResult Post([FromBody] ReservaDto reservaDto)
{
var trecho = trechoRepository.Obter(reservaDto.IdTrecho);
if (trecho == null)
{
return(BadRequest());
}
var classeDeVoo = classeDeVooRepository.Obter(reservaDto.IdClasseDeVoo);
if (classeDeVoo == null)
{
return(BadRequest());
}
List <Opcional> opcionais = new List <Opcional>();
var usuario = usuarioRepository.Obter(reservaDto.IdUsuario);
foreach (var item in reservaDto.IdOpcionais)
{
var opcionalCadastrado = opcionalRepository.Obter(item);
if (opcionalCadastrado == null)
{
return(BadRequest());
}
opcionais.Add(opcionalCadastrado);
}
var reserva = new Reserva(trecho, classeDeVoo, opcionais, usuario);
reserva.ValorTotalDoVoo = reserva.ValorTotal();
reservaRepository.SalvarReserva(reserva);
contexto.SaveChanges();
return(CreatedAtRoute("GetReserva", new { id = reserva.Id }, reserva));
}
public ActionResult Nueva(ReservaGrabarViewModel reserva)
{
try
{
if (ModelState.IsValid)
{
// Debemos codificar la reserva
reserva.ArreglarHoras();
ReservaDto reservaDto =
Mapper.Map <ReservaGrabarViewModel, ReservaDto>(reserva);
servicioReservas.Reservar(reservaDto);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
// reconstruir el objeto anterior <ReservaViewModel>
ModelState.AddModelError("", "Hubo Error en el Modelo");
return(View(builder.ReservaViewModel(reserva)));
}
catch (ErrorEnReserva ex)
{
ModelState.AddModelError("", ex.Message);
return(View(builder.ReservaViewModel(reserva)));
}
catch (Exception)
{
throw;
}
}
public void Modificar(ReservaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var ReservaMod = context.Reservas.FirstOrDefault(x => x.Id == dto.Id);
if (ReservaMod == null)
{
throw new Exception("No se encontro la Reserva");
}
ReservaMod.ClienteId = dto.ClienteId;
ReservaMod.Fecha = dto.Fecha;
ReservaMod.MesaId = dto.MesaId;
ReservaMod.MotivoReservaId = dto.MotivoReservaId;
ReservaMod.UsuarioId = dto.UsuarioId;
ReservaMod.Senia = dto.Senia;
ReservaMod.Id = dto.Id;
if (dto.EstadoReserva == EstadoReserva.Confirmada && ReservaMod.EstadoReserva
!= EstadoReserva.Confirmada)
{
var mesa = new ComprobanteMesaServicio();
mesa.Reservar(dto.MesaId, Entidad.Entidad.UsuarioId, dto.ClienteId, ReservaMod.Senia);
}
if (dto.EstadoReserva == EstadoReserva.Cancelada)
{
var mesa = new ComprobanteMesaServicio();
mesa.CancelarReserva(dto.MesaId);
}
ReservaMod.EstadoReserva = dto.EstadoReserva;
context.SaveChanges();
}
}
public override bool EjecutarComandoModificar()
{
if (!VerificarDatosObligatorios())
{
MessageBox.Show(@"Por favor ingrese los campos Obligatorios.", @"Atención", MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(false);
}
var reservaModificar = new ReservaDto()
{
Id = EntidadId.Value,
Fecha = dtpFecha.Value,
Senia = nudSeña.Value,
EstadoReserva = ((EstadoReserva)cmbEstado.SelectedItem),
MesaId = ((MesaDto)cmbMesa.SelectedItem).Id,
ClienteId = ((ClienteDto)cmbCliente.SelectedItem).Id,
MotivoReservaId = ((MotivoReservaDto)cmbMotivo.SelectedItem).Id,
UsuarioId = ((UsuarioDto)cmbUsuario.SelectedItem).Id
};
_reservaServicio.Modificar(reservaModificar);
return(true);
}
public IActionResult GetValorReserva([FromBody] ReservaDto reservaRequest)
{
var reserva = MapearReservaDtoParaDominio(reservaRequest);
var inconsistencias = ReservaService.Validar(reserva);
if (inconsistencias.Any())
{
return(Ok(0));
}
return(Ok(reserva.ValorTotal));
}
private Reserva MapearDtoParaDominio(ReservaDto reservaDto)
{
var trecho = contexto.Trechos.Include(t => t.LocalOrigem).Include(t => t.LocalDestino).FirstOrDefault(t => t.Id == reservaDto.IdTrecho);
var classeDeVoo = contexto.ClassesDeVoo.FirstOrDefault(t => t.Id == reservaDto.IdClasseDeVoo);
var opcionais = contexto.Opcionais
.Where(o => reservaDto.IdsOpcionais.Contains(o.Id))
.Select(o => o).ToList();
var reservaOpcional = opcionais.Select(o => new ReservaOpcional(o)).ToList();
return(new Reserva(trecho, classeDeVoo, reservaOpcional));
}
public void Modificar(ReservaDto dto)
{
using (var context = new ModeloGastronomiaContainer())
{
var ReservaModificar = context.Comprobantes.OfType <DAL.Reserva>()
.Single(x => x.Id == dto.Id);
ReservaModificar.CantidadComensales = dto.CantidadComensales;
ReservaModificar.FechaReserva = dto.Fecha;
ReservaModificar.Observacion = dto.Observacion;
context.SaveChanges();
}
}
private Reserva MapearReservaDtoParaDominio(ReservaDto reservaRequest)
{
var opcionais = new List <Opcional>();
foreach (var id in reservaRequest.IdOpcionais)
{
opcionais.Add(opcionalRepository.GetOpcional(id));
}
return(new Reserva(
trechoRepository.GetTrecho(reservaRequest.IdTrecho),
classeVooRepository.GetClasseVoo(reservaRequest.IdClasseVoo),
opcionais
));
}
public ActionResult <ReservaDto> GetReserva(int reservaId)
// public IActionResult GetReserva(int reservaId)
{
var reserva = _reservaRepository.GetReserva(reservaId);
var reservaDto = new ReservaDto()
{
Id = reserva.Id,
Id_menu = int.Parse(reserva.Id_menu),
Direccion = reserva.Direccion,
Email = reserva.Email,
Estado = reserva.Estado
};
return(reservaDto);
// return Ok(reservaDto);
}
public async Task <ActionResult> Post([FromBody] ReservaDto reservaCreated)
{
if (reservaCreated.Hora < 8 || reservaCreated.Hora > 22)
{
return(NotFound(new Result(404, false, "La hora pasada esta fuera del rango de horas de reservas").GetResultJson()));
}
var socio = await context.Socios.FirstOrDefaultAsync(x => x.Id == reservaCreated.SocioId);
if (socio == null)
{
return(NotFound(new Result(404, false, "No se ha introducido un id Socio válido").GetResultJson()));
}
var pista = await context.Pistas.FirstOrDefaultAsync(x => x.Id == reservaCreated.PistaId);
if (pista == null)
{
return(NotFound(new Result(404, false, "No se ha introducido un id Pista válido").GetResultJson()));
}
if (UtilReservas.GetReservasSocio(context, reservaCreated).Count() > 2)
{
return(NotFound(new Result(404, false, "No se permite más de 3 reservas al día para un socio").GetResultJson()));
}
if (UtilReservas.GetReservaPistaHora(context, reservaCreated).Any())
{
return(NotFound(new Result(404, false, "La pista esta reservada ya").GetResultJson()));
}
if (UtilReservas.GetReservaSocioHora(context, reservaCreated).Any())
{
return(NotFound(new Result(404, false, "El socio ya tiene una pista a esa hora").GetResultJson()));
}
var reserva = mapper.Map <Reserva>(reservaCreated);
context.Add(reserva);
await context.SaveChangesAsync();
var reservaViewModel = mapper.Map <ReservaViewModel>(reserva);
return(new CreatedAtRouteResult("ObtenerSocio", new { id = reserva.Id }, reservaViewModel));
}
public async Task <ActionResult <Reserva> > PostReserva(ReservaDto reserva)
{
var userId = User.Identity.Name;
if (reserva.FechaFin < reserva.FechaInicio)
{
return(BadRequest("Fecha de Fin de reserva pasada a la de Inicio"));
}
if (reserva.FechaInicio < DateTime.Now)
{
return(BadRequest("No hacemos reservas en el pasado"));
}
if (reserva.FechaInicio.AddDays(1).Date > reserva.FechaFin.Date)
{
return(BadRequest("La reserva debe durar al menos un dia"));
}
if (reserva.FechaFin > DateTime.Now.AddYears(1))
{
return(BadRequest("No hacemos reservas en un año"));
}
foreach (int id in reserva.Habitaciones)
{
try{
var f = new Reserva();
f.FechaInicio = reserva.FechaInicio;
f.FechaFin = reserva.FechaFin;
f.Estado = "Activa";
f.CreationDate = DateTime.Now;
f.UsuarioId = reserva.UsusarioId;
f.HabitacionId = id;
try{
f.CreationId = int.Parse(userId);
}catch (Exception e) {
f.CreationId = 0;
}
_context.Reserva.Add(f);
}catch (Exception e) {
return(BadRequest(e));
}
}
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult> Put(int id, [FromBody] ReservaDto reservaModificated)
{
if (reservaModificated.Hora < 8 || reservaModificated.Hora > 22)
{
return(NotFound(new Result(404, false, "La hora pasada esta fuera del rango de horas de reservas").GetResultJson()));
}
var socio = await context.Socios.FirstOrDefaultAsync(x => x.Id == reservaModificated.SocioId);
if (socio == null)
{
return(NotFound(new Result(404, false, "No se ha introducido un id Socio válido").GetResultJson()));
}
var pista = await context.Pistas.FirstOrDefaultAsync(x => x.Id == reservaModificated.PistaId);
if (pista == null)
{
return(NotFound(new Result(404, false, "No se ha introducido un id Pista válido").GetResultJson()));
}
if (UtilReservas.GetReservasSocio(context, reservaModificated).Count() > 2)
{
return(NotFound(new Result(404, false, "No se permite más de 3 reservas al día para un socio").GetResultJson()));
}
if (UtilReservas.GetReservaPistaHora(context, reservaModificated).Any())
{
return(NotFound(new Result(404, false, "La pista esta reservada ya").GetResultJson()));
}
if (UtilReservas.GetReservaSocioHora(context, reservaModificated).Any())
{
return(NotFound(new Result(404, false, "El socio ya tiene una pista a esa hora").GetResultJson()));
}
var reserva = mapper.Map <Reserva>(reservaModificated);
reserva.Id = id;
context.Entry(reserva).State = EntityState.Modified;
await context.SaveChangesAsync();
return(NoContent());
}
public IActionResult Post([FromBody] ReservaDto reservaRequest)
{
var usuario = usuarioRepository.ObterUsuarioPorEmail(User.Identity.Name);
var suite = suiteRepository.Obter(reservaRequest.IdSuite);
if (usuario == null)
{
return(NotFound("Nenhum usuário foi encontrado"));
}
var opcionais = new List <Opcional>();
foreach (var opcional in reservaRequest.IdOpcionais)
{
var opcionalCadastrado = opcionalRepository.Obter(opcional);
if (opcionalCadastrado == null)
{
return(NotFound("Nenhum opcional foi encontrado"));
}
opcionais.Add(opcionalCadastrado);
}
var reserva = new Reserva(usuario, suite, reservaRequest.NumeroPessoas, reservaRequest.DataInicio, reservaRequest.DataFim, opcionais);
var reservaCadastrada = reservaRepository.SalvarReserva(reserva);
var mensagem = reservaService.Validar(reservaCadastrada);
if (mensagem.Any())
{
return(BadRequest(mensagem));
}
reservaOpcionalRepository.SalvarReservaOpcional(reserva);
contexto.SaveChanges();
return(Ok(reserva));
}
public long Insertar(ReservaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var nuevaReserva = new AccesoDatos.Reserva
{
Fecha = dto.Fecha,
Senia = dto.Senia,
EstadoReserva = dto.EstadoReserva,
MesaId = dto.MesaId,
ClienteId = dto.MesaId,
UsuarioId = dto.UsuarioId,
MotivoReservaId = dto.MotivoReservaId
};
context.Reservas.Add(nuevaReserva);
context.SaveChanges();
return(nuevaReserva.Id);
}
}
public IActionResult Post(int idUsuario, [FromBody] ReservaDto reservaRequest)
{
var usuario = contexto.Usuarios.Include(u => u.Reservas).AsNoTracking().FirstOrDefault(u => u.Id == idUsuario);
if (usuario == null)
{
return(NotFound("Usuário não encontrado"));
}
var reserva = MapearDtoParaDominio(reservaRequest);
var mensagens = reservaService.Validar(usuario, reserva);
if (mensagens.Count > 0)
{
return(BadRequest(mensagens));
}
reservaRepository.SalvarReserva(idUsuario, reserva);
contexto.SaveChanges();
return(CreatedAtRoute("GetReserva", new { id = reserva.Id }, reserva));
}
public IActionResult Reservar(int idUsuario, [FromBody] ReservaDto reservaRequest)
{
var usuario = usuarioRepository.GetUsuario(idUsuario);
if (usuario == null)
{
return(NotFound("Usuário não encontrado."));
}
var reserva = MapearReservaDtoParaDominio(reservaRequest);
var inconsistencias = ReservaService.Validar(reserva);
if (inconsistencias.Any())
{
return(BadRequest(inconsistencias));
}
reservaRepository.Salvar(idUsuario, reserva);
context.SaveChanges();
return(Ok());
}
public void Modificar(ReservaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var reservarModificar = context.Reservas
.FirstOrDefault(x => x.Id == dto.Id);
if (reservarModificar == null)
{
throw new Exception("No se encotro la Reserva a Modificar");
}
reservarModificar.Fecha = dto.Fecha;
reservarModificar.Senia = dto.Senia;
reservarModificar.EstadoReserva = dto.EstadoReserva;
reservarModificar.MesaId = dto.MesaId;
reservarModificar.ClienteId = dto.ClienteId;
reservarModificar.UsuarioId = dto.UsuarioId;
reservarModificar.MotivoReservaId = dto.MotivoReservaId;
context.SaveChanges();
}
}
public void Crear(ReservaDto dto)
{
using (var context = new ModeloGastronomiaContainer())
{
var ReservaNueva = new DAL.Reserva
{
Fecha = DateTime.Now,
MesaId = dto.MesaId,
ClienteId = dto.CLienteId,
EmpleadoId = dto.EmpleadoId,
CantidadComensales = dto.CantidadComensales,
EstaEliminado = false,
FechaReserva = dto.Fecha,
Observacion = dto.Observacion,
EstadoReserva = EstadoReserva.Reservado,
Codigo = dto.Codigo,
};
context.Comprobantes.Add(ReservaNueva);
context.SaveChanges();
}
}
public long Agregar(ReservaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var reservaNueva = new Reserva
{
ClienteId = dto.ClienteId,
EstadoReserva = dto.EstadoReserva,
Fecha = dto.Fecha,
MesaId = dto.MesaId,
MotivoReservaId = dto.MotivoReservaId,
UsuarioId = dto.UsuarioId,
Senia = dto.Senia
};
context.Reservas.Add(reservaNueva);
if (dto.EstadoReserva == EstadoReserva.Confirmada)
{
var mesa = new ComprobanteMesaServicio();
mesa.Reservar(dto.MesaId, Entidad.Entidad.UsuarioId, dto.ClienteId, reservaNueva.Senia);
}
context.SaveChanges();
return(reservaNueva.Id);
}
}
public static IEnumerable <Reserva> GetReservaPistaHora(ApplicationDbContext context, ReservaDto reserva)
{
return(context.Reservas.Include(x => x.Pista).Include(x => x.Socio)
.Where(x => x.PistaId == reserva.PistaId)
.Where(x => x.Hora == reserva.Hora)
.Where(x => x.Fecha.Equals(reserva.Fecha))
.Where(x => x.Socio.Id == reserva.SocioId)
.ToList());
}
public static IEnumerable <Reserva> GetReservaSocioHora(ApplicationDbContext context, ReservaDto reserva)
{
return(context.Reservas.Include(x => x.Pista).Include(x => x.Socio)
.Where(x => x.Socio == reserva.Socio)
.Where(x => x.Hora == reserva.Hora)
.ToList());
}
public IActionResult GetValor([FromBody] ReservaDto reservaRequest)
{
var reserva = MapearDtoParaDominio(reservaRequest);
return(Ok(reserva.Valor));
}
