public JsonResult ReservarPropiedad(int idPropiedad, string fecha)
{
var sesionUser = (ClienteViewModel)Session["ClienteActual"];
ReservaViewModel reservaNueva = new ReservaViewModel();
reservaNueva.IdPropiedad = idPropiedad;
reservaNueva.IdCliente = sesionUser.IdCliente;
reservaNueva.FechaReserva = fecha;
reservaNueva.Credito = true;
var mensaje = this.reservaService.AgregarReserva(reservaNueva);
if (mensaje != "OK")
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else
{
this.creditoService.DescontarCreditoCliente(sesionUser.IdCliente, DateTime.Parse(reservaNueva.FechaReserva).Year);
if (this.reservaService.CancelarSubastasDePropiedadReservada(reservaNueva))
{
mensaje = string.Format("Se ha confirmado la reserva, se ha descontado un crédito para el año {0} y se han cancelado las subastas definidas en el rango de fechas de la reserva.", DateTime.Parse(fecha).Year);
}
else
{
mensaje = string.Format("Se ha confirmado la reserva y se ha descontado un crédito para el año {0}.", DateTime.Parse(fecha).Year);
}
}
return(Json(mensaje, JsonRequestBehavior.AllowGet));
}
public JsonResult ReservarHotSale(int idHotSale)
{
var sesionUser = (ClienteViewModel)Session["ClienteActual"];
var hotSalesActuales = this.servicioHotSale.ObtenerHotSalesFuturos();
var hotSale = hotSalesActuales.Where(t => t.IdHotSale == idHotSale).SingleOrDefault();
ReservaViewModel nuevaReserva = new ReservaViewModel();
nuevaReserva.IdCliente = sesionUser.IdCliente;
nuevaReserva.IdPropiedad = hotSale.IdPropiedad;
nuevaReserva.FechaReserva = hotSale.FechaDisponible;
nuevaReserva.Credito = false;
var mensaje = this.reservaService.AgregarReservaDesdeHotSale(nuevaReserva);
if (mensaje != "OK")
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else
{
this.servicioHotSale.OcuparHotSale(idHotSale);
mensaje = string.Format("Se ha efectuado satisfactoriamente la reserva de la residencia");
}
return(Json(mensaje, JsonRequestBehavior.AllowGet));
}
public ActionResult Nueva()
{
//TODO: traer data Real
ReservaViewModel reserva = builder.ReservaViewModel();
return(View(reserva));
}
internal ReservaViewModel ReservaViewModel()
{
var reserva = new ReservaViewModel();
ConfigurarListas(reserva);
return(reserva);
}
public ActionResult Reservar(ReservaViewModel model)
{
var paquete = _paqueteServicio.Get(model.IdPaquete);
if (paquete == null)
{
return(View("_notFound"));
}
if (DateTime.Now > paquete.FechaInicio)
{
ModelState.AddModelError("paquete_fechas", "La fecha de inicio del paquete debe ser menor o igual a la fecha actual");
}
if (paquete.LugaresDisponibles != null && paquete.LugaresDisponibles < model.CantPersonas)
{
ModelState.AddModelError("paquete_disponibles", "La cantidad de pasajeros supera los lugares disponibles");
}
if (ModelState.IsValid)
{
_reservaServicio.Create(model.Map(User.Identity.ToPw3User().Id));
return(Redirect(Url.Action("Index", "Home")));
}
model.PaqueteViewModel = paquete.Map();
return(View(model));
}
public ActionResult Edit(int id)
{
Reservas reservaEntity;
using (UnidadDeTrabajo <Reservas> unidad = new UnidadDeTrabajo <Reservas>(new BDContext()))
{
reservaEntity = unidad.genericDAL.Get(id);
}
ReservaViewModel reservas = this.Convertir(reservaEntity);
Usuarios usuario;
List <Usuarios> usuarios;
using (UnidadDeTrabajo <Usuarios> unidad = new UnidadDeTrabajo <Usuarios>(new BDContext()))
{
usuarios = unidad.genericDAL.GetAll().ToList();
usuario = unidad.genericDAL.Get(reservas.Usuario_ID);
}
usuarios.Insert(0, usuario);
reservas.Usuarios = usuarios;
Servicio servicio;
List <Servicio> servicios;
using (UnidadDeTrabajo <Servicio> unidad = new UnidadDeTrabajo <Servicio>(new BDContext()))
{
servicios = unidad.genericDAL.GetAll().ToList();
servicio = unidad.genericDAL.Get(reservas.Servicio_ID);
}
servicios.Insert(0, servicio);
reservas.Servicios = servicios;
return(View(reservas));
}
public string AgregarReservaDesdeHotSale(ReservaViewModel reservaModelo)
{
var reservasCliente = this.ObtenerReservasCliente(reservaModelo.IdCliente);
if (reservasCliente.Any(t => (Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0) ||
(Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0)))
{
return(string.Format("Ya posee una reserva en la misma semana en otra propiedad."));
}
RESERVA nuevaReserva = new RESERVA();
nuevaReserva.IdCliente = reservaModelo.IdCliente;
nuevaReserva.Fecha = Convert.ToDateTime(reservaModelo.FechaReserva);
nuevaReserva.IdPropiedad = reservaModelo.IdPropiedad;
nuevaReserva.Credito = reservaModelo.Credito;
this.HomeSwitchDB.RESERVA.Add(nuevaReserva);
this.HomeSwitchDB.SaveChanges();
CacheHomeSwitchHome.RemoveOnCache("Reservas");
return("OK");
}
public async Task <ReservaViewModel> UpdateReservaAsync(ReservaViewModel reserva)
{
try
{
_repository.ModifyEntity(_mapper.Map <ReservaViewModel, Reserva>(reserva));
await _repository.SaveAllAsync();
}
catch (DbUpdateConcurrencyException e)
{
if (!await ReservaExistsAsync(reserva.Id))
{
_logger.LogError($"Failed to update Reserva {reserva.Id}. Not found: {e}");
return(null);
}
else
{
_logger.LogError($"Failed to update Reserva {reserva.Id}. Unknown Problem: {e}");
throw new Exception("Unknown problem with the database", e);
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to Update Reserva: {ex}");
return(null);
}
return(reserva);
}
public JsonResult ConfirmarReservaDeSubasta(int idSubasta)
{
var subastaAceptada = this.servicioSubasta.ObtenerSubastasFinalizadas().SingleOrDefault(t => t.IdSubasta == idSubasta);
var reservaSubasta = new ReservaViewModel();
reservaSubasta.IdCliente = Convert.ToInt32(subastaAceptada.IdCliente);
reservaSubasta.IdPropiedad = subastaAceptada.IdPropiedad;
reservaSubasta.FechaReserva = subastaAceptada.FechaReserva;
reservaSubasta.Credito = true;
var mensaje = this.servicioReserva.AgregarReserva(reservaSubasta);
if (mensaje != "OK")
{
return(this.CambiarGanadorPuja(idSubasta));
}
else
{
this.servicioSubasta.ConfirmarSubasta(idSubasta);
this.servicioCredito.DescontarCreditoCliente(reservaSubasta.IdCliente, DateTime.Parse(reservaSubasta.FechaReserva).Year);
var subastaActual = this.servicioSubasta.ObtenerSubasta(idSubasta);
this.servicioMail.EnviarMailGanoSubasta(subastaActual);
return(Json(string.Format("Se ha confirmado la subasta para el cliente y se ha generado la reserva correspondiente.")));
}
}
public IActionResult Index()
{
ReservaViewModel rvm = new ReservaViewModel();
rvm.Eventos = eventoRepository.ObterTodos();
var emailCliente = ObterUsuarioSession();
if (!string.IsNullOrEmpty(emailCliente))
{
rvm.Cliente = clienteRepository.ObterPor(emailCliente);
}
var nomeUsuario = ObterUsuarioNomeSession();
if (!string.IsNullOrEmpty(nomeUsuario))
{
rvm.NomeCliente = nomeUsuario;
}
rvm.NomeView = "Reserva";
rvm.UsuarioEmail = emailCliente;
rvm.UsuarioNome = nomeUsuario;
return(View(rvm));
}
public void GivenTheUserDidntCompleteTheInformation()
{
NoInfoReservation = new ReservaViewModel
{
Observaciones = "Realizo el pago",
Vehiculo = "ABC123",
Estado = "En proceso",
};
}
public ActionResult Delete(ReservaViewModel reservaViewModel)
{
using (UnidadDeTrabajo <Reservas> unidad = new UnidadDeTrabajo <Reservas>(new BDContext()))
{
unidad.genericDAL.Remove(this.Convertir(reservaViewModel));
unidad.Complete();
}
return(RedirectToAction("Index"));
}
private static void ConfigurarListas(ReservaViewModel reservaViewModel)
{
var listaVacia = new List <String>()
{
"Seleccione.."
};
reservaViewModel.Salas = new SelectList(listaVacia);
reservaViewModel.Locales = new SelectList(listaVacia);
}
public void GivenTheUserDidntCompleteTheInformationDonTSpecifyTheLocal()
{
NoLocalReservation = new ReservaViewModel
{
Fecha = "12 Marzo",
Hora = "12:00",
Observaciones = "Realizo el pago",
Vehiculo = "ABC123",
Estado = "En proceso",
};
}
public List <ReservaViewModel> LerTodosViewModel()
{
string stringDeConexao = @"Data Source = (LocalDB)\MSSQLLocalDB; AttachDbFilename = C:\Users\moc\Documents\SistemaParkHotel.mdf; Integrated Security = True; Connect Timeout = 30";
SqlConnection connection = new SqlConnection(stringDeConexao);
SqlCommand command = new SqlCommand();
command.CommandText = @"
SELECT R.ID 'Reserva',
C.ID 'IDCliente',
C.NOME 'Cliente',
C.CPF 'CPF',
R.DATAPREVISAOENTRADA 'DataEntrada',
R.DATAPREVISAOSAIDA 'DataPrevisaoSaida',
Q.ID 'Quarto',
Q.PRECO 'ValorQuarto',
Q.TIPO 'Tipo'
FROM RESERVAS R INNER JOIN CLIENTES C ON R.IDCLIENTE = C.ID
INNER JOIN QUARTOS Q ON Q.ID = R.IDQUARTO";
command.Connection = connection;
List <ReservaViewModel> reservas = new List <ReservaViewModel>();
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
ReservaViewModel r = new ReservaViewModel()
{
Cliente = (string)reader["Cliente"],
CPF = (string)reader["CPF"],
DataEntrada = (DateTime)reader["DataEntrada"],
DataPrevisaoSaida = (DateTime)reader["DataPrevisaoSaida"],
IDCliente = (int)reader["IDCliente"],
Quarto = (int)reader["Quarto"],
Reserva = (int)reader["Reserva"],
Tipo = (string)reader["Tipo"],
ValorQuarto = Convert.ToDouble(reader["ValorQuarto"])
};
reservas.Add(r);
}
return(reservas);
}
catch (Exception)
{
}
finally
{
connection.Dispose();
}
return(null);
}
public void GivenTheUserCompleteTheRequirementsWithAnIncorrectData()
{
IncorrectReservation = new ReservaViewModel
{
Fecha = "12 Marzo",
Hora = "12:00",
Observaciones = "Realizo el pago",
Vehiculo = "XYZ123",
Local = "Av. La molina",
Estado = "En proceso",
};
}
public async Task <IActionResult> Index(string idVeiculo)
{
if (_reservaViewModel == null)
{
_reservaViewModel = new ReservaViewModel();
}
//recupera o tempdata
_reservaViewModel.Veiculo = await ObterVeiculoPorId(idVeiculo);
return(View(_reservaViewModel));
}
public ActionResult <ReservaViewModel> Get(int identificacion)
{
var reserva = _reservaService.BuscarxIdentificacion(identificacion);
if (reserva == null)
{
return(NotFound());
}
var reservaViewModel = new ReservaViewModel(reserva);
return(reservaViewModel);
}
public ActionResult Delete(ReservaViewModel view)
{
try
{
// TODO: Add delete logic here
new ReservaCEN().Destroy(view.id);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(ReservaViewModel v)
{
try
{
// TODO: Add update logic here
ReservaCEN rescen = new ReservaCEN();
rescen.Modify(v.id, v.comensales, v.estado, v.finalizada, v.fecha_hora, v.fecha_solicitud);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Reservar(ReservaViewModel re)
{
TurismoAEGLContext db2 = new TurismoAEGLContext();
Reserva r = logicaReserva.GenerarReserva(re.IdPaquete, re.CPersonas, re.IdUsuario);
Paquete pp = db2.Paquete.Find(re.IdPaquete);
if (pp.LugaresDisponibles < re.CPersonas)
{
return(View("ErrorCantidad"));
}
logicaReserva.GuardarReserva(r);
return(RedirectToAction("Listar", "Reserva"));
}
private ReservaViewModel toViewModelReserva(Reserva objModel)
{
ReservaViewModel vmReserva = new ReservaViewModel();
vmReserva.ID = objModel.ID;
vmReserva.Curso = objModel.Cursos.Nombre;
vmReserva.Tutor = objModel.Tutor.Usuario.Nombres + " " + objModel.Tutor.Usuario.Apellidos;
vmReserva.Alumno = objModel.Usuario.Nombres + " " + objModel.Usuario.Apellidos;
vmReserva.Fecha = objModel.Fecha.ToShortDateString();
vmReserva.Hora_Inicio = objModel.Hora_Inicio;
vmReserva.Hora_Final = objModel.Hora_Final;
vmReserva.Estado = objModel.Estado_Reserva.Nombre;
return(vmReserva);
}
public ActionResult Create()
{
ReservaViewModel reserva = new ReservaViewModel {
};
using (UnidadDeTrabajo <Usuarios> unidad = new UnidadDeTrabajo <Usuarios>(new BDContext()))
{
reserva.Usuarios = unidad.genericDAL.GetAll().ToList();
}
using (UnidadDeTrabajo <Servicio> unidad = new UnidadDeTrabajo <Servicio>(new BDContext()))
{
reserva.Servicios = unidad.genericDAL.GetAll().ToList();
}
return(View(reserva));
}
public List <ReservaViewModel> lerReservasPendentes()
{
string stringConexao = StringConexao.GetStringConexao();
SqlConnection connection = new SqlConnection(stringConexao);
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandText =
@"SELECT R.ID 'Reserva',
C.ID 'IdCliente',
C.Nome 'NomeCliente',
F.ID 'Funcionario',
F.Nome 'NomeFuncionario',
R.DATA_PREVISAO_CHEGADA 'DataEntrada',
R.DATA_PREVISAO_SAIDA 'DataSaidaPrevista',
Q.ID 'NumeroQuarto',
Q.VALOR_DIARIA 'ValorDiaria',
Q.Tipo 'Tipo'
FROM RESERVAS R INNER JOIN CLIENTES C ON
R.CLIENTE_ID = C.ID
INNER JOIN USUARIOS F ON
F.ID = R.USUARIO_ID
INNER JOIN QUARTOS Q ON R.ID_QUARTO=Q.ID
WHERE R.PENDENTE_CHECKIN=1";
List <ReservaViewModel> listReserva = new List <ReservaViewModel>();
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
ReservaViewModel viewModel = new ReservaViewModel();
listReserva.Add(instanciarReservaViewModel(reader));
}
return(listReserva);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
connection.Close();
}
}
public string AgregarReserva(ReservaViewModel reservaModelo)
{
var creditoService = new CreditoService();
var clienteCreditos = creditoService.ObtenerCreditosAnio(DateTime.Parse(reservaModelo.FechaReserva).Year, reservaModelo.IdCliente);
var reservasCliente = this.ObtenerReservasCliente(reservaModelo.IdCliente);
var propiedadReservas = this.ObtenerReservasPropiedad(reservaModelo.IdPropiedad);
var servicioSubasta = new SubastaService();
var propiedadSubastas = servicioSubasta.ObtenerSubastasDePropiedad(reservaModelo.IdPropiedad).Where(t => Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaComienzo)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaComienzo).AddDays(10)) <= 0);
if (clienteCreditos.Credito <= 0)
{
return(string.Format("Ya dispone de dos reservas en el año {0}, no posee de más créditos para acceder a una nueva.", clienteCreditos.Anio));
}
if (propiedadReservas.Any(t => (Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0) ||
(Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0)))
{
return(string.Format("La semana elegida no está disponible para la propiedad seleccionada."));
}
if (reservasCliente.Any(t => (Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0) ||
(Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva)) >= 0 &&
Convert.ToDateTime(reservaModelo.FechaReserva).AddDays(7).CompareTo(Convert.ToDateTime(t.FechaReserva).AddDays(7)) <= 0)))
{
return(string.Format("Ya posee una reserva en la misma semana en otra propiedad."));
}
RESERVA nuevaReserva = new RESERVA();
nuevaReserva.IdCliente = reservaModelo.IdCliente;
nuevaReserva.Fecha = Convert.ToDateTime(reservaModelo.FechaReserva);
nuevaReserva.IdPropiedad = reservaModelo.IdPropiedad;
nuevaReserva.Credito = reservaModelo.Credito;
this.HomeSwitchDB.RESERVA.Add(nuevaReserva);
this.HomeSwitchDB.SaveChanges();
CacheHomeSwitchHome.RemoveOnCache("Reservas");
return("OK");
}
public async Task <ActionResult <ReservaViewModel> > Put(string Cedula, ReservaInputModel reservaInput)
{
var reserva = _reservaService.Actualizar(MapearReserva(reservaInput));
if (reserva.Error)
{
ModelState
.AddModelError("Error al guardar la Reserva", reserva.Mensaje);
var detallesproblemas = new ValidationProblemDetails(ModelState);
detallesproblemas.Status = StatusCodes.Status500InternalServerError;
return(BadRequest(detallesproblemas));
}
var reservaview = new ReservaViewModel(reserva.Reserva);
await _hubContext.Clients.All.SendAsync("reservaRegistrada", reservaview);
return(Ok(reservaview));
}
// GET: Reserva
private ReservaViewModel Convertir(Reservas reserva)
{
ReservaViewModel reservaViewModel = new ReservaViewModel {
Reserva_ID = reserva.Reserva_ID,
Usuario_ID = (int)reserva.Usuario_ID,
Fecha = (DateTime)reserva.Fecha,
Servicio_ID = reserva.Servicio_ID,
Consentimiento = reserva.Consentimiento,
Horario = (DateTime)reserva.Horario,
Cantidad_Personas = (int)reserva.Cantidad_Personas,
Tipo_Pago = reserva.Tipo_Pago,
Total = (double)reserva.Total,
Observacion = reserva.Observacion
};
return(reservaViewModel);
}// FIN DE CONVERTIR
public async Task <ReservaViewModel> CreateReservaAsync(ReservaViewModel reserva)
{
try
{
Reserva p = _mapper.Map <ReservaViewModel, Reserva>(reserva);
_repository.AddEntity(p);
await _repository.SaveAllAsync();
reserva.Id = p.Id;
return(reserva);
}
catch (Exception ex)
{
_logger.LogError($"Failed to Create Pista: {ex}");
return(null);
}
}
internal ReservaViewModel ReservaViewModel(ReservaGrabarViewModel reserva)
{
var reservaViewModel = new ReservaViewModel();
reservaViewModel.ClienteId = reserva.ClienteId;
reservaViewModel.FechaFinal = reserva.FechaFinal;
reservaViewModel.FechaInicio = reserva.FechaInicio;
reservaViewModel.HoraFin = reserva.HoraFin;
reservaViewModel.HoraInicio = reserva.HoraInicio;
reservaViewModel.Indicaciones = reserva.Indicaciones;
reservaViewModel.Participantes = reserva.Participantes;
reservaViewModel.SalaId = reserva.SalaId;
ConfigurarListas(reservaViewModel);
return(reservaViewModel);
}
}// FIN DE CONVERTIR
private Reservas Convertir(ReservaViewModel reservaViewModel)
{
Reservas ReservaViewModel = new Reservas
{
Reserva_ID = reservaViewModel.Reserva_ID,
Usuario_ID = reservaViewModel.Usuario_ID,
Fecha = reservaViewModel.Fecha,
Servicio_ID = reservaViewModel.Servicio_ID,
Consentimiento = reservaViewModel.Consentimiento,
Horario = reservaViewModel.Horario,
Cantidad_Personas = reservaViewModel.Cantidad_Personas,
Tipo_Pago = reservaViewModel.Tipo_Pago,
Total = reservaViewModel.Total,
Observacion = reservaViewModel.Observacion
};
return(ReservaViewModel);
}
