public void ReservaDto_a_Reserva()
{
DadaUnaReservaDto();
var reserva = ReservaMapper.Map(_unaReservaCreacionDTO);
reserva.PasajeroTitular.NombreCompleto.Should().Be(_pasajero.NombreCompleto);
reserva.PasajeroTitular.DniOPasaporte.Should().Be(_pasajero.DniOPasaporte);
reserva.PasajeroTitular.Email.Should().Be(_pasajero.Email);
reserva.PasajeroTitular.Telefono.Should().Be(_pasajero.Telefono);
reserva.PasajeroTitular.Pais.Should().Be(_pasajero.Pais);
reserva.PrimeraNoche.Should().Be(_desde);
reserva.UltimaNoche.Should().Be(_hasta.AddDays(-1));
reserva.HoraEstimadaDeLlegada.Should().Be(new TimeSpan(11, 0, 0));
reserva.Estado.Should().Be(ReservaEstadoEnum.HizoCheckout);
reserva.CantidadDePasajeros.Should().Be(3);
reserva.Canal.Should().Be(_unaReservaCreacionDTO.Canal);
reserva.ReservaCamas.Should().HaveCount(1);
reserva.ReservaHabitacionesPrivadas.Should().HaveCount(3);
reserva.ReservaCamas.Should().Contain(x => x.CamaId == UN_CAMA_ID);
reserva.ReservaHabitacionesPrivadas.Should().Contain(x => x.HabitacionPrivadaId == 100);
reserva.ReservaHabitacionesPrivadas.Should().Contain(x => x.HabitacionPrivadaId == 200);
reserva.ReservaHabitacionesPrivadas.Should().Contain(x => x.HabitacionPrivadaId == 400);
}
public async Task <int> Crear([FromBody] ReservaCreacionDTO creacionDTO)
{
if (creacionDTO.CamasIds != null && creacionDTO.CamasIds.Count == 0 && creacionDTO.HabitacionesPrivadasIds != null && creacionDTO.HabitacionesPrivadasIds.Count == 0)
{
throw new AppException("Se debe reservar al menos una habitación o cama");
}
if (creacionDTO.CamasIds != null && creacionDTO.CamasIds.Count() != creacionDTO.CamasIds.Distinct().Count())
{
throw new AppException("No puede reservarse dos veces la misma cama");
}
if (creacionDTO.HabitacionesPrivadasIds != null && creacionDTO.HabitacionesPrivadasIds.Count() != creacionDTO.HabitacionesPrivadasIds.Distinct().Count())
{
throw new AppException("No se puede reservar dos veces la misma habitación");
}
if (creacionDTO.DiaDeCheckin == creacionDTO.DiaDeCheckout)
{
throw new AppException("Se debe reservar al menos una noche");
}
var reserva = ReservaMapper.Map(creacionDTO);
await SiElPasajeroTitularYaExisteModificarloSinoCrearlo(reserva);
var id = await _service.Crear(reserva);
return(id);
}
private static void RefrescarCache()
{
cacheReservas = ReservaMapper.TraerReservas();
listaHoteles = HotelMapper.TraerHoteles();
listaClientes = ClienteServicio.TraerClientes();
listaHoteles.ForEach(x => x.Habitaciones.AddRange(HabitacionMapper.TraerHabitacionesPorId(x.Id)));
LlenarListas();
}
public async Task <int> Cancelar([FromBody] CancelarDTO dto)
{
var reserva = ReservaMapper.Map(dto);
await _service.Cancelar(reserva);
return(reserva.Id);
}
public async Task <int> HacerCheckOut([FromBody] HacerCheckOutDTO dto)
{
var reserva = ReservaMapper.Map(dto);
await _service.HacerCheckOut(reserva);
return(reserva.Id);
}
public async Task <ReservasDelPeriodoDTO> ListarVigentesEntre(string primeraNoche, int dias)
{
var primeraNocheDateTime = Utilidades.ConvertirFecha(primeraNoche);
var ultimaNoche = primeraNocheDateTime.AddDays(dias - 1);
var reservas = await _service.ListarVigentesEntre(primeraNocheDateTime, ultimaNoche);
return(ReservaMapper.Map(reservas, primeraNocheDateTime, ultimaNoche.AddDays(1)));
}
public void ReservaConHabPrivada_a_ReservaDTO()
{
var reserva = DadaUnaReservaQueTieneHabitacionPrivadaPeroNoCama();
var reservaDTO = ReservaMapper.MapDetalle(reserva);
reservaDTO.DiaDeCheckin.Should().Be(Utilidades.ConvertirFecha(_desde));
reservaDTO.DiaDeCheckout.Should().Be(Utilidades.ConvertirFecha(_hasta.AddDays(1)));
reservaDTO.Camas.Should().HaveCount(0);
reservaDTO.HabitacionesPrivadas.Should().HaveCount(1);
reservaDTO.HabitacionesPrivadas.First().Id.Should().Be(1);
}
public async Task <int> HacerCheckIn([FromBody] HacerCheckInDTO dto)
{
ValidarQueNoEsteDosVecesElMismoPasajero(dto);
var reserva = ReservaMapper.Map(dto);
await SiElPasajeroTitularYaExisteModificarloSinoCrearlo(reserva);
await SiAlgunPasajeroAnexoYaExisteModificarlo(reserva);
await _service.HacerCheckIn(reserva);
return(reserva.Id);
}
public HotelServicios()
{
_listahoteles = new List <Hotel>();
_listaHabitaciones = new List <Habitacion>();
_listaReservas = new List <Reserva>();
//Cache
_listaclientes = ClienteMapper.TraerTodos();
_listahoteles = HotelMapper.Hotel_getAll();
_listaReservas = ReservaMapper.Reserva_getAll();
foreach (Hotel a in _listahoteles)
{
_listaHabitaciones.AddRange(HabitacionMapper.Habitacion_getAllByHotel(a.Id));
}
}
public async Task <IEnumerable <ReservaResumenDTO> > Listar(ReservaEstadoEnum?estado, string checkInDesde, string checkInHasta, string checkOutDesde, string checkOutHasta)
{
var checkInDesdeDateTime = checkInDesde != null?Utilidades.ConvertirFecha(checkInDesde) : (DateTime?)null;
var checkInHastaDateTime = checkInHasta != null?Utilidades.ConvertirFecha(checkInHasta) : (DateTime?)null;
var checkOutDesdeDateTime = checkOutDesde != null?Utilidades.ConvertirFecha(checkOutDesde) : (DateTime?)null;
var checkOutHastaDateTime = checkOutHasta != null?Utilidades.ConvertirFecha(checkOutHasta) : (DateTime?)null;
var reservas = await _service.Listar(estado, checkInDesdeDateTime, checkInHastaDateTime, checkOutDesdeDateTime, checkOutHastaDateTime);
return(ReservaMapper.Map(reservas));
}
public int EliminarReserva(int id)
{
TransactionResult resultado = ReservaMapper.Delete(id);
if (resultado.IsOk)
{
ReservaCache();
return(resultado.Id);
}
else
{
throw new ReservasException(resultado.Error);
}
}
public int IngresarReserva(Reserva reserva, Habitacion hab)
{
if (reserva.CantidadHuespedes > hab.CantidadPlazas)
{
throw new ReservasException("Cantidad de huespedes superior a plaza.");
}
if (reserva.FechaIngreso.Date < DateTime.Today.Date)
{
throw new ReservasException("La fecha debe ser mayor o igual a hoy.");
}
if (reserva.FechaEgreso.Date - reserva.FechaIngreso.Date < TimeSpan.FromDays(1))
{
throw new ReservasException("Fecha de egreso debe ser mayor a ingreso.");
}
var reservas = _listaReservas.Where(o => o.IdHabitacion == reserva.IdHabitacion);
var cliente = _listaclientes.FirstOrDefault(o => o.Id == reserva.IdCliente);
if (cliente == null)
{
throw new ReservasException("El cliente no existe.");
}
for (DateTime i = reserva.FechaIngreso; i <= reserva.FechaEgreso; i = i.AddDays(1))
{
if (reservas.Where(t => i >= t.FechaIngreso & i < t.FechaEgreso).Any())
{
throw new ReservasException("La habitacion se encuentra reservada.");
}
}
TransactionResult resultado = ReservaMapper.Insert(reserva);
if (resultado.IsOk)
{
reserva.Id = resultado.Id;
SendMailAsync(reserva, cliente.Email);
ReservaCache();
return(resultado.Id);
}
else
{
throw new ReservasException(resultado.Error);
}
}
public void ListaReservas_a_ReservasDelPeriodoDTO()
{
DadaUnaListaDeReservas();
var desde = new DateTime(2020, 8, 1);
var hasta = new DateTime(2020, 8, 31);
var reservasDelPeriodoDTO = ReservaMapper.Map(_unaListaDeReservas, desde, hasta);
var primeraReserva = reservasDelPeriodoDTO.Reservas.First();
reservasDelPeriodoDTO.Desde.Should().Be(Utilidades.ConvertirFecha(desde));
reservasDelPeriodoDTO.Hasta.Should().Be(Utilidades.ConvertirFecha(hasta));
primeraReserva.DiaDeCheckin.Should().Be("2020-08-01");
primeraReserva.DiaDeCheckout.Should().Be("2020-08-31");
primeraReserva.CamasIds.Should().HaveCount(2);
primeraReserva.CamasIds.First().Should().Be(1);
primeraReserva.CamasIds.Skip(1).First().Should().Be(2);
}
public static void InsertarReserva(Reserva reserva)
{
if (ExisteReserva(reserva))
{
throw new ReservaExistenteException(reserva.Id);
}
else
{
LlenarListas();
ValidacionDeReserva(reserva);
TransactionResult result = ReservaMapper.Insert(reserva);
if (!result.IsOk)
{
throw new ErrorServidorException(result.Error);
}
else
{
RefrescarCache();
}
}
}
public ConsultarReservaResponse ConsultarReserva(ConsultarReservaRequest request)
{
var response = new ConsultarReservaResponse();
try
{
response = request.Validate();
if (!response.Error)
{
response.Reserva = ReservaMapper.MapperToConsultaDto(_reservaRepository.Consultar(request.Token, request.Cpf, request.Matricula, request.Senha));
}
}
catch (Exception ex)
{
response.Error = true;
response.ErrorMessages.Add(ex.Message);
}
return(response);
}
public IncluirReservaResponse IncluirReserva(IncluirReservaRequest request)
{
var response = new IncluirReservaResponse();
var retorno = new RetornoIncluirReservaDto();
try
{
response = request.Validate();
if (!response.Error)
{
response.Retorno = ReservaMapper.MapperToIncluirDto(_reservaRepository.Incluir(ReservaMapper.Mapper(request.Reserva)));
}
}
catch (Exception ex)
{
response.Error = true;
response.ErrorMessages.Add(ex.Message);
}
return(response);
}
public void ReservaConCamas_a_ReservaDTO()
{
DadaUnaListaDeReservas();
var reserva = _unaListaDeReservas.Skip(1).First();
var reservaDTO = ReservaMapper.MapDetalle(reserva);
reservaDTO.Estado.Should().Be(ReservaEstadoEnum.InHouse);
reservaDTO.HoraEstimadaDeLlegada.Should().Be("11:00");
reservaDTO.CantidadDePasajeros.Should().Be(1);
reservaDTO.Canal.Should().Be(reserva.Canal);
reservaDTO.DiaDeCheckin.Should().Be(Utilidades.ConvertirFecha(_desde));
reservaDTO.DiaDeCheckout.Should().Be(Utilidades.ConvertirFecha(_hasta.AddDays(1)));
reservaDTO.Camas.Should().HaveCount(2);
reservaDTO.Camas.First().Id.Should().Be(1);
reservaDTO.Camas.Skip(1).First().Id.Should().Be(2);
reservaDTO.PasajeroTitular.DniOPasaporte.Should().Be(_pasajero.DniOPasaporte);
reservaDTO.PasajeroTitular.NombreCompleto.Should().Be(_pasajero.NombreCompleto);
reservaDTO.PasajeroTitular.Email.Should().Be(_pasajero.Email);
reservaDTO.PasajeroTitular.Telefono.Should().Be(_pasajero.Telefono);
reservaDTO.PasajeroTitular.Pais.Should().Be(_pasajero.Pais);
}
private void ReservaCache()
{
_listaReservas = ReservaMapper.Reserva_getAll();
}
public async Task <ReservaDetalleDTO> ObtenerPorId(int id)
{
var reserva = await _service.ObtenerPorId(id);
return(ReservaMapper.MapDetalle(reserva));
}
public ReservaCrudFactory()
{
mapper = new ReservaMapper();
dao = SqlDao.GetInstance();
}