public Reserva_Nova_Criada_Corretamente()
{
local = new Local("Um Local");
data = DateTime.Now.Date;
reserva = new Reserva(local, data, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
}
public Reserva_AlterarHorario()
{
local = MockRepository.GenerateStub<Local>();
data = DateTime.Now.Date;
reserva = new Reserva(local, data, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
}
public DetallePrograma(Programa programa, Deporte deporte, int item, Diagramacion diagramacion, Reserva reserva,
Estado estado)
{
Programa = programa;
Deporte = deporte;
Item = item;
Diagramacion = diagramacion;
Reserva = reserva;
Estado = estado;
}
public void QuandoNaoMudaNada_ReservasPermanecemInalteradas()
{
Evento evento = CriarEventoComReserva();
var reservasAlteradas = new List<Reserva> { new Reserva(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Manha }) };
evento.AlterarReservasDeLocais(reservasAlteradas);
Assert.Equal(1, evento.Reservas.Count());
var reservaEsperada = new Reserva(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
Assert.Equal(reservaEsperada, evento.Reservas.First());
}
public ItemReerva(int idItemReserva, Reserva reserva, Recurso recurso, string situacao, DateTime dataCancelamento, string observacao, DateTime dataRetirada, DateTime dataDevolucao)
{
this.idItemReserva = idItemReserva;
this.reserva = reserva;
this.recurso = recurso;
this.situacao = situacao;
this.dataCancelamento = dataCancelamento;
this.observacao = observacao;
this.dataRetirada = dataRetirada;
this.dataDevolucao = dataDevolucao;
}
public void QuandoAlteraHorario_ReservaFicaComNovoHorario()
{
Evento evento = CriarEventoComReserva();
var reservasAlteradas = new List<Reserva> { new Reserva(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Tarde }) };
evento.AlterarReservasDeLocais(reservasAlteradas);
Assert.Equal(1, evento.Reservas.Count());
var reservaEsperada = new Reserva(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Tarde });
Assert.Equal(reservaEsperada, evento.Reservas.First());
}
public void AoReservarComSucesso_ReservaEstahAssociadoAEvento()
{
Local local = MockRepository.GenerateStub<Local>();
DateTime dataInicioEvento = DateTime.Now;
DateTime dataFimEvento = dataInicioEvento.AddHours(4);
Evento evento = CriarEvento(dataInicioEvento, dataFimEvento);
evento.Reservar(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
Assert.Equal(1, evento.Reservas.Count());
Reserva reservaEsperada = new Reserva(local, dataInicioEvento.Date, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
Assert.Equal(reservaEsperada, evento.Reservas.First());
}
public RegistrarIngresoEgreso(Usuario user, Reserva reserv, ModoApertura modoApert, Hotel hotelSelecc)
{
InitializeComponent();
usuario = user;
reserva = reserv;
modoApertura = modoApert;
hotelSeleccionado = hotelSelecc;
precio = 0;
PopularGrillas();
ModificarBotonesSegunTipoRegistro();
if (ModoApertura.CHECKIN == modoApertura)
MessageBox.Show("Recuerde ingresar los datos de todos los huéspedes.", "Atención", MessageBoxButtons.OK);
}
protected void btnresservar_Click(object sender, EventArgs e)
{
DatosReserva dr = new DatosReserva();
Reserva r = new Reserva();
dr.Cod = r.autogeneracodreserva();
dr.Motivo = txtdescripreserva.Text;
dr.Fecha = DateTime.Parse(txtfechareserva.Text.ToString());
dr.Idlocal = int.Parse(cbodistritos.SelectedValue.ToString());
lblMensaje.Text = r.ReservarLocal(dr);
//if (r.ValidaReservaLocal(dr.Idlocal) < 1)
//lblaviso.Text = "La reserva se anulara si el cliente no se presenta hasta 30 min. despues de la hora acordada para el evento";
//lblaviso.Text = "Los locales alquilados estaran disponibles pasadas 32 horas despues de la reserva";
}
public ActionResult Put(int id, [FromBody] Reserva reserva)
{
try
{
if (reserva.Id == id)
{
reserva.Importe = 0;
context.Entry(reserva).State = EntityState.Modified;
context.SaveChanges();
return(Ok());
}
else
{
return(BadRequest());
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Details(Reserva al)
{
try
{
using (var db = new ReservacionesEntities())
{
Reserva alu = db.Reservas.Find(al.Id);
var K = db.Usuarios.Single(u => u.Estado == "1");
if (K != null)
{
Auditoria(K.Cedula, "Reserva", "DETALLE DE UNA RESERVA");
}
return(View(alu));
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error al Encontrar Reserva", ex);
return(View());
}
}
public void AddReserva(List <DtoProducto> colProductosPedidos, Pedido nuevoPedido, AliyavaEntities context)
{
Stock stockByPro = new Stock();
foreach (DtoProducto dto in colProductosPedidos)
{
Reserva nuevaReserva = new Reserva();
Producto pro = context.Producto.FirstOrDefault(f => f.codigo_barras == dto.codigoBarras);
string ubicacionP = context.Stock.Include("Producto").FirstOrDefault(f => f.Producto.codigo_barras == pro.codigo_barras).Ubicacion;
nuevaReserva.Ubicacion = ubicacionP;
nuevaReserva.Estado = "Activo";
nuevaReserva.Cantidad = dto.CantidadPreparar;
//Reservar stock por cada producto de la lista.
stockByPro = context.Stock.FirstOrDefault(f => f.idProducto == dto.Codigo);
stockByPro.Cantidad = stockByPro.Cantidad - dto.CantidadPreparar;
nuevoPedido.Reserva.Add(nuevaReserva);
}
}
public Reserva ObterPeloId(int id)
{
Reserva reserva = null;
SqlCommand command = new BancoDados().ObterConexcao;
command.CommandText = "SELECT nome, celular, cpf, pagamento FROM Reservas WHERE id = @ID";
command.Parameters.AddWithValue("@ID", id);
DataTable tabela = new DataTable();
tabela.Load(command.ExecuteReader());
if (tabela.Rows.Count == 1)
{
reserva = new Reserva();
reserva.Id = id;
reserva.Nome = tabela.Rows[0][0].ToString();
reserva.Celular = tabela.Rows[0][1].ToString();
reserva.CPF = tabela.Rows[0][2].ToString();
reserva.Pagamento = tabela.Rows[0][3].ToString();
}
return(reserva);
}
public IHttpActionResult CancelarReserva([FromUri] string codigoReserva)
{
try
{
var client = new ServiceReference1.WCFReservaVehiculosClient();
var credentials = Credenciales();
var request = new ServiceReference1.CancelarReservaRequest();
request.CodigoReserva = codigoReserva;
var valor = client.CancelarReserva(credentials, request);
Reserva reserva = db.Reserva.Where(x => x.CodigoReserva == codigoReserva).FirstOrDefault();
db.Reserva.Remove(reserva);
db.SaveChanges();
return(Ok(reserva.CodigoReserva));
}
catch (Exception ex)
{
return(NotFound());
}
}
public ActionResult GuardarReserva(Reserva Reserva, string MetodoPago)
{
ViewBag.Encargado = context.Encargados.ToList();
ViewBag.Servicio = context.Servicios.ToList();
ViewBag.Horarios = context.Horarios.Include(o => o.Encargado);
Reserva.Detalle.IdServicio = Reserva.IdServicio;
Reserva.Detalle.costo = Costo(Reserva.IdServicio);
Reserva.Detalle.Duracion = Duracion(Reserva.IdServicio);
var HorarioAfectado = context.Horarios.Where(o => o.EncargadoId == Reserva.IdEncargado && o.Horas == Reserva.HoraInicio && o.Fecha == Reserva.Fecha).FirstOrDefault();
if (HorarioAfectado.Disponibilidad == false)
{
return(View("Index"));
}
HorarioAfectado.Disponibilidad = false;
context.Reservas.Add(Reserva);
context.SaveChanges();
return(RedirectToAction("Index", "Panel"));
}
public void ActualizarReservaOk()
{
var options = new DbContextOptionsBuilder <ObligatorioContext>()
.UseInMemoryDatabase(databaseName: "TestDB")
.Options;
using (var context = new ObligatorioContext(options))
{
var repository = new Repository <Reserva>(context);
Reserva reserva = new Reserva();
reserva.NombreTurista = "Test22";
repository.Create(reserva);
repository.Save();
reserva.NombreTurista = "Prueba";
repository.Update(reserva);
repository.Save();
Assert.AreEqual("Prueba", repository.GetAll().First().NombreTurista);
context.Set <Reserva>().Remove(reserva);
context.SaveChanges();
}
}
public ValidationModel Valida(Reserva item)
{
//inicializa objeto
var validation = new ValidationModel();
//executa as validacoes
if (item.IdGuia == 0)
{
validation.Valido = false;
validation.Erros.Add("Informe o guia");
}
if (item.IdTurista == 0)
{
validation.Valido = false;
validation.Erros.Add("Informe o turista");
}
// retorna o resultado
return(validation);
}
public ActionResult Create(ReservaModel EmpDet)
{
var reserva = new Reserva()
{
Fecha_Inicio = EmpDet.Fecha_Fin,
Fecha_Fin = EmpDet.Fecha_Inicio,
IdItinerario = EmpDet.IdItinerario,
IdCliente = EmpDet.IdCliente,
Costo = EmpDet.Costo
};
var val = _unit.Reservas.GuardarReserva(reserva);
if (val)
{
return(RedirectToAction("Index"));
//return Json("Records added Successfully.");
}
return(PartialView("_Reserva", EmpDet));
//return Json("Records not added,");
}
private void button1_Click(object sender, EventArgs e)
{
if (textBox1.Text.Equals(""))
{
MessageBox.Show("Debe ingresar un código de reserva!", "ERROR");
return;
}
Reserva reserva = new ReservaDAO().ObtenerReserva(Convert.ToInt32(textBox1.Text));
if (reserva.Id == -1)
{
MessageBox.Show("Lo sentimos, es posible que el código de reserva sea inválido, que se "
+ "haya efectivizado por medio de una estadía en curso/finalizada, "
+ "o que el período de modificación (hasta un día antes de su inicio) haya finalizado", "INFO");
return;
}
this.Reserva = reserva;
this.DialogResult = DialogResult.OK;
}
private void btnAgregarReserva_Click(object sender, EventArgs e)
{
Reserva reserva = new Reserva();
reserva.FechaReserva = datePickerReserva.Text;
reserva.FechaIngreso = datePickerIngreso.Text;
reserva.FechaSalida = datePickerSalida.Text;
reserva.IdCliente = Convert.ToInt32(cboboxCliente.SelectedValue);
reserva.IdHabitacion = Convert.ToInt32(cboboxHabitacion.SelectedValue);
reserva.IdFormaPago = Convert.ToInt32(cboboxFormaPago.SelectedValue);
int resultado = ReservaDAL.Agregar(reserva);
if (resultado > 0)
{
MessageBox.Show("Reserva guardado Con Exito!!", "Guardado", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("No se pudo guardar la reserva", "Fallo!!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public bool Cadastrar(Reserva r)
{
if (r.DataEntrada < r.DataSaida && r.DataEntrada >= DateTime.Now)
{
if (_context.Reservas.Include(x => x.Quarto).Any(x => x.DataSaida >= r.DataEntrada && x.DataEntrada <= r.DataSaida &&
x.Quarto.IdQuarto == r.Quarto.IdQuarto) == true)
{
return(false);
}
else
{
_context.Reservas.Add(r);
_context.SaveChanges();
return(true);
}
}
else
{
return(false);
}
}
public void Crear(long mesaId, ComprobanteReservaDto dto)
{
using (var context = new ModeloGastronomiaContainer())
{
var nuevoComprobane = new Reserva
{
Fecha = DateTime.Now,
ClienteId = dto.ClienteId,
CantidadComensales = dto.CantidadComensales,
EmpleadoId = dto.EmpleadoId,
EstadoReserva = EstadoReserva.Reservado,
FechaReserva = dto.FechaReserva,
MontoSenia = dto.MontoSenia,
Observacion = dto.Observacion,
TipoComprobante = TipoComprobante.Impaga
};
context.Comprobantes.Add(nuevoComprobane);
context.SaveChanges();
}
}
public Reserva FindById(int id)
{
string cadenaFind = "SELECT fecha_ini, fecha_fin FROM Reserva WHERE id = @id";
Reserva unaR = null;
using (SqlConnection cn = BdSQL.Conectar())
{
using (SqlCommand cmd = new SqlCommand(cadenaFind, cn))
{
cmd.Parameters.AddWithValue("@id", id);
cn.Open();
SqlDataReader reader = cmd.ExecuteReader();
if (reader != null && reader.Read())
{
unaR = new Reserva();
unaR.Load(reader);
}
}
}
return(unaR);
}
public IActionResult CartaoCredito(Reserva reserva, string txtHrAluguel, string nroCartaoCredito, string valorTotalPagamento, DateTime dtVeicDevolvido)
{
Reserva r = new Reserva();
r = GetReserva();
DateTime aux = DateTime.Now;
if (string.IsNullOrWhiteSpace(nroCartaoCredito))
{
TempData["MsgCartaoCredito"] = "Preencha o número do cartão de crédito";
TempDataValores(txtHrAluguel, valorTotalPagamento, dtVeicDevolvido);
return(RedirectToAction("Pagamento"));
}
aux = ValidaData(txtHrAluguel, dtVeicDevolvido, aux);
reserva.DataVeiculoDevolvido = aux;
_pagamentoDAO.PagamentoCartaoCredito(reserva, nroCartaoCredito, r, valorTotalPagamento);
return(RedirectToAction("Index", "Cliente"));
}
public IActionResult Cadastrar(Reserva r,
int drpQuartos)
{
ViewBag.Quartos =
new SelectList(_quartoDAO.ListarTodos(),
"IdQuarto", "NomeQuarto");
if (ModelState.IsValid)
{
r.Quarto =
_quartoDAO.BuscarPorId(drpQuartos);
if (_reservaDAO.Cadastrar(r))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError
("", "Esta reserva já existe!");
}
return(View(r));
}
private void button1_Click(object sender, EventArgs e)
{
if (textBox1.Text.Equals(""))
{
MessageBox.Show("Debe ingresar un código de reserva válido para poder avanzar", "ERROR");
return;
}
Tuple <Estadia, Reserva> Data = new EstadiaDAO().ObtenerDatosEstadiaFacturacion(
Convert.ToInt32(textBox1.Text));
if (Data.Item1 == null || Data.Item2 == null)
{
MessageBox.Show("No se puede iniciar el proceso de facturación. Esto puede deberse a que "
+ "el código es inválido, la factura ya se haya realizado, la estadía esté en curso o "
+ "que los consumos no hayan sido cerrados", "ERROR");
return;
}
this.estadia = Data.Item1;
this.reserva = Data.Item2;
textBox5.Text = estadia.Fecha_Inicio.Value.ToString("dd/MM/yyyy");
textBox5.Tag = estadia.Fecha_Inicio;
textBox4.Text = estadia.Fecha_Fin.Value.ToString("dd/MM/yyyy");
textBox4.Tag = estadia.Fecha_Fin;
textBox2.Text = reserva.Fecha_Inicio.ToString("dd/MM/yyyy");
textBox2.Tag = reserva.Fecha_Inicio;
textBox3.Text = reserva.Fecha_Fin.ToString("dd/MM/yyyy");
textBox3.Tag = reserva.Fecha_Fin;
PopularItemsFacturas();
button3.Enabled = true;
button2.Enabled = true;
comboBox1.Enabled = true;
comboBox1.SelectedIndex = 0;
textBox7.Enabled = true;
textBox7.Text = "";
}
public List <Reserva> ListarReservaXUsuario(int usuario)
{
List <Reserva> reservas = null;
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "sp_ListarReservaXUsuario";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = conexion;
conexion.Open();
cmd.Parameters.AddWithValue("@usuario", usuario);
SqlDataReader lector = cmd.ExecuteReader();
if (lector.HasRows)
{
reservas = new List <Reserva>();
Reserva reserva;
Habitacion _habitacion;
while (lector.Read())
{
reserva = new Reserva();
_habitacion = new Habitacion();
reserva.codigo = int.Parse(lector["CODIGO_RESERVA"].ToString());
reserva.estado = int.Parse(lector["ESTADO"].ToString());
reserva.fechaInicio = DateTime.Parse(lector["FECHA_INICIO"].ToString());
reserva.total = decimal.Parse(lector["TOTAL"].ToString());
reserva.estado = int.Parse(lector["ESTADO"].ToString());
_habitacion.codigo = int.Parse(lector["CODIGO_HABITACION"].ToString());
_habitacion.descripcion = lector["DESCRIPCION_HABITACION"].ToString();
reserva.habitacion = _habitacion;
reservas.Add(reserva);
}
}
conexion.Close();
return(reservas);
}
public void TestGenerarReporteConEstadoInvalido()
{
List <CantReservasPorHospedaje> lista = new List <CantReservasPorHospedaje>();
var logicaReservaMock = new Mock <IReserva>(MockBehavior.Strict);
IGenerarReporte generador = new GenerarReporteConcretoA(logicaReservaMock.Object);
PuntoTuristico punto = new PuntoTuristico()
{
Id = 0, Nombre = "Test"
};
DateTime inicio = new DateTime(2020, 10, 9);
DateTime fin = new DateTime(2020, 10, 19);
DatosReporte datos = new DatosReporte()
{
PuntoId = punto.Id, Inicio = inicio, Fin = fin
};
Hospedaje hospedaje1 = new Hospedaje()
{
NombreHospedaje = "Hospedaje1", PuntoTuristico = punto
};
Reserva reserva1 = new Reserva()
{
Hospedaje = hospedaje1, CheckIn = inicio, CheckOut = fin, Estado = EstadoReserva.Aceptada
};
Reserva reserva2 = new Reserva()
{
Hospedaje = hospedaje1, CheckIn = inicio, CheckOut = fin, Estado = EstadoReserva.Expirada
};
List <Reserva> reservas = new List <Reserva>();
reservas.Add(reserva1);
reservas.Add(reserva2);
logicaReservaMock.Setup(x => x.ObtenerTodos()).Returns(reservas);
lista = generador.GenerarReporte(datos);
Assert.AreEqual(1, lista.Count);
}
static void Main(string[] args)
{
try
{
Console.Write("Quarto: ");
int quarto = int.Parse(Console.ReadLine());
Console.Write("Data de Entrada (dd/MM/aaaa): ");
DateTime dataEntrada = DateTime.Parse(Console.ReadLine());
Console.Write("Data de Saida (dd/MM/aaaa): ");
DateTime dataSaida = DateTime.Parse(Console.ReadLine());
Reserva reserva = new Reserva(quarto, dataEntrada, dataSaida);
Console.WriteLine("RESERVA: ");
Console.WriteLine(reserva);
Console.WriteLine();
Console.WriteLine("Entre com as novas datas de Atualização:");
Console.Write("Data de Entrada (dd/MM/yyyy): ");
dataEntrada = DateTime.Parse(Console.ReadLine());
Console.Write("Data de Saída (dd/MM/yyyy): ");
dataSaida = DateTime.Parse(Console.ReadLine());
reserva.Atualizando(dataEntrada, dataSaida);
Console.WriteLine("NOVA RESERVA: ");
Console.WriteLine(reserva);
}
catch (DominioExcecao e)
{
Console.WriteLine("Erro de ATUALIZAÇÃO de reservas: " + e.Message);
}
catch (FormatException e)
{
Console.WriteLine("Erro de FORMATO: " + e.Message);
}
catch (Exception e)
{
Console.WriteLine("Erro INSPERADO! " + e.Message);
}
}
public IActionResult Registrar(IFormCollection form)
{
ViewData["Action"] = "Reserva";
Reserva reserva = new Reserva();
var nomeEvento = form["evento"];
Evento evento = new Evento(nomeEvento, eventoRepository.ObterPrecoDe(nomeEvento));
reserva.Evento = evento;
Cliente cliente = new Cliente();
cliente.Nome = form["nome"];
cliente.Cpf = form["cpf"];
cliente.Telefone = form["telefone"];
cliente.Email = form["email"];
reserva.Cliente = cliente;
reserva.DataDaReserva = DateTime.Now;
reserva.PrecoTotal = evento.Preco;
if (reservaRepository.Inserir(reserva))
{
return(View("Sucesso", new RespostaViewModel()
{
NomeView = "Reserva",
Mensagem = $"{cliente.Nome} sua reserva foi concluida!"
}));
}
else
{
return(View("Erro", new RespostaViewModel()
{
NomeView = "Reserva",
Mensagem = $"{cliente.Nome} sua reserva nao foi concluida!"
}));
}
}
public IActionResult Solicitar(IFormCollection form)
{
ViewData["Action"] = "Reserva";
Reserva reserva = new Reserva();
Cliente cliente = new Cliente()
{
Nome = form["nome"],
Email = form["email"]
};
reserva.Cliente = cliente;
reserva.Nome_evento = form["nome_evento"];
reserva.Quantidade = int.Parse(form["quantidade"]);
reserva.Servicos = form["servicos"];
reserva.Tipo_evento = form["tipo_evento"];
reserva.Pagamento = form["pagamento"];
reserva.Data_evento = DateTime.Parse(form["data_evento"]);
if (reservaRepository.Inserir(reserva))
{
return(View("Sucesso", new RespostaViewModel()
{
Mensagem = "Aguarde aprovação dos nossos administradores!",
NomeView = "Sucesso",
UsuarioEmail = ObterUsuarioSession(),
UsuarioNome = ObterUsuarioNomeSession()
}));
}
else
{
return(View("Erro", new RespostaViewModel()
{
Mensagem = "Houve um erro ao processsar seu agendamento. Tente novamente!",
NomeView = "Erro",
UsuarioEmail = ObterUsuarioSession(),
UsuarioNome = ObterUsuarioNomeSession()
}));
}
}
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 List <Reserva> LerTodos()
{
string ConnectionString = Parametros.GetConnectionString();
SqlConnection connection = new SqlConnection();
connection.ConnectionString = ConnectionString;
SqlCommand command = new SqlCommand();
command.CommandText = "SELECT * FROM RESERVAS";
command.Connection = connection;
List <Reserva> list = new List <Reserva>();
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
int id = (int)reader["ID"];
int idCliente = (int)reader["ID_CLIENTES"];
DateTime entrada = (DateTime)reader["DATA_ENTRADA"];
DateTime saidaP = (DateTime)reader["DATA_SAIDA_PREVISTA"];
int idF = (int)reader["ID_FUNCIONARIO"];
int idQ = (int)reader["ID_QUARTO"];
Reserva rsv = new Reserva(id, idCliente, entrada, saidaP, idF, idQ);
list.Add(rsv);
}
}
catch (Exception)
{
}
finally
{
connection.Dispose();
}
return(list);
}
public async Task <IActionResult> Create([Bind("CanchaId,UsuarioId,FechaReserva,Comentarios,TurnoId")] Reserva reserva)
{
CanchaReservada(reserva);
ValidaFecha(reserva.FechaReserva);
/* var tipoCancha = _context
* .TipoCancha
* .Include(x => x.Canchas).ThenInclude(x => x.TipoCancha)
* .FirstOrDefault(x => x.Id == reserva.Cancha.TipoCancha.Id);*/
if (ModelState.IsValid)
{
reserva.EstadoId = 1;
// Buscamos en el contexto de Cancha el precio
var cancha = await _context.Cancha
.Include(c => c.TipoCancha)
.FirstOrDefaultAsync(m => m.Id == reserva.CanchaId);
//se asigna el precio a la Reserva
reserva.Monto = cancha.Precio;
reserva.UsuarioId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); //Asigno la reserva al usuario logueado.
_context.Add(reserva);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(ListadoReserva)));
}
ViewData["CanchaId"] = new SelectList(_context.Cancha, "Id", "Nombre", reserva.CanchaId);
ViewData["EstadoId"] = new SelectList(_context.EstadoReserva, "Id", "Descripcion", reserva.EstadoId);
ViewData["TurnoId"] = new SelectList(_context.Turno, "Id", "Descripcion", reserva.TurnoId);
ViewData["UsuarioId"] = new SelectList(_context.Usuario, "Id", "Username", reserva.UsuarioId);
return(View(reserva));
// return RedirectToAction(nameof(ListadoReserva));
}
public ModificarReserva(Usuario user, Reserva reserve, Hotel hotelSelec)
{
InitializeComponent();
usuario = user;
reserva = reserve;
hotel = hotelSelec;
habitacionesRemovidas = new List<Habitacion>();
habitacionesAgregadas = new List<Habitacion>();
contador = 1;
PopularComboBoxesYGrillas();
this.hotelComboBox.SelectedItem = this.BuscarHotelReserva();
this.hotelComboBox.Enabled = false;
this.PopularRegimen();
CalcularPrecioHabitaciones(this.HabitacionesReservadasDataGrid);
CalcularPrecioHabitaciones(this.HabitacionesDisponiblesDataGrid);
if (habitacionesDisponibles.Count == 0)
MessageBox.Show("No hay habitaciones disponibles para la fecha de la reserva.",
"Atención", MessageBoxButtons.OK);
}
public IHttpActionResult GetAll()
{
List <Reserva> reservas = new List <Reserva>();
try
{
using (SqlConnection sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["RESERVAS"].ConnectionString))
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT RES_CODIGO, USU_CODIGO, HAB_CODIGO,
RES_FECHA_INGRESO, RES_FECHA_SALIDA
FROM RESERVA", sqlConnection);
sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
Reserva reserva = new Reserva()
{
RES_CODIGO = sqlDataReader.GetInt32(0),
USU_CODIGO = sqlDataReader.GetInt32(1),
HAB_CODIGO = sqlDataReader.GetInt32(2),
RES_FECHA_INGRESO = sqlDataReader.GetDateTime(3),
RES_FECHA_SALIDA = sqlDataReader.GetDateTime(4),
};
reservas.Add(reserva);
}
sqlConnection.Close();
}
}
catch (Exception)
{
throw;
}
return(Ok(reservas));
}
public bool EfetuarReserva(long codveiculo, long codcliente, DateTime dataretirada, DateTime dataentrega, string tiporetirada, string formapagamento, string valorpedido, Usuario usuario)
{
bool resultado = false;
using (TransactionScope transaction = new TransactionScope())
{
try
{
if (codveiculo != 0 && codcliente != 0 && dataretirada != null && dataentrega != null && tiporetirada != "" && formapagamento != "" && Decimal.Parse(valorpedido) != 0 && usuario.CodigoUsuario != 0)
{
Reserva reserva = new Reserva();
Veiculo veiculo = new VeiculoDAO().Buscar(codveiculo);
veiculo.CodigoVeiculo = codveiculo;
veiculo.Status = 2;
new VeiculoDAO().Atualizar(veiculo);
reserva.CodigoCliente = codcliente;
reserva.CodigoVeiculo = codveiculo;
reserva.CodigoUsuario = usuario.CodigoUsuario;
reserva.DataEntrega = dataentrega.ToString();;
reserva.DataRetirada = dataretirada.ToString();;
reserva.TipoRetirada = tiporetirada;
reserva.Status = 2;
reserva.FormaPagamento = formapagamento;
reserva.ValorLocacao = Decimal.Parse(valorpedido);
reserva.DataReserva = DateTime.Now.ToString();
reserva.Situacao = "Reserva";
reservaDAO.Inserir(reserva);
resultado = true;
transaction.Complete();
}
}
catch (Exception ex)
{
}
return(resultado);
}
}
public ActionResult Reserva(string ViajeId, string usuarioViaja, string asientos)
{
//Console.WriteLine(" Usuario que viaja: " + usuarioViaja + " Numero de asientos"+ asientos);
if (!string.IsNullOrEmpty(ViajeId) && !string.IsNullOrEmpty(usuarioViaja) && !string.IsNullOrEmpty(asientos))
{
int idViaje = Convert.ToInt32(ViajeId);
int numAsientos = Convert.ToInt32(asientos);
Reserva reserva = new Reserva()
{
ApplicationUserId = usuarioViaja,
NumAsientos = numAsientos,
Aceptado = true
};
db.Reservas.Add(reserva);
//Descuento de asientos en la tabla Viaje
var ViajeDescontar = db.Viajes.Find(idViaje);
if (!(numAsientos > ViajeDescontar.NumAsientos))
{
ViajeDescontar.NumAsientos = ViajeDescontar.NumAsientos - numAsientos;
TempData["notificacion"] = "Tu solicitud de reserva ha sido enviada!";
}
ViajeReserva Viaje_Reserva = new ViajeReserva()
{
ViajeId = idViaje,
ReservaId = reserva.ReservaId
};
db.ViajesReservas.Add(Viaje_Reserva);
db.SaveChanges();
return(Redirect("~/Home/Reserva?ViajeId=" + idViaje));
}
return(View());
}
private void toolStripButton_Confirmar_Click(object sender, EventArgs e)
{
EntregaVeiculoService entregaService = new EntregaVeiculoService();
VeiculoService veiculoService = new VeiculoService();
if (entregaService.verificaChecklist(textBox_CheckList.Text))
{
Reserva reserva = entregaService.buscarReserva(CodigoReserva);
Veiculo veiculo = veiculoService.BuscarVeiculo(reserva.CodigoVeiculo);
if (entregaService.devolucao(reserva, veiculo, dateTimePicker_DataEntrega.Value) == true)
{
MessageBox.Show("Devolução Realizada com sucesso!");
ExibirPedido exibePedido = new ExibirPedido();
exibirPedido.Close();
Close();
}
}
else
{
MessageBox.Show("Favor Realizar o checklist do veículo");
}
}
Reserva CriarReserva(CriarReservaModel model)
{
var cliente = _clienteRepository.Obter(model.IdCliente);
var reserva = new Reserva(cliente, model.Diarias);
var produto = _produtoRepository.Obter(model.IdProduto);
reserva.SelecionarProduto(produto);
var pacote = _pacoteRepository.Obter(model.IdPacote);
reserva.SelecionarPacote(pacote);
foreach (var opcionalModel in model.Opcionais)
{
var opcional = _opcionalRepository.Obter(opcionalModel.IdOpcional);
reserva.SelecionarOpcional(opcional, 1);
}
return(reserva);
}
protected void AtualizarDropListViewRecurso(Reserva item)
{
this.dropListViewRecurso.DataSource = Recurso.Carregar(new List<string>() { "SITUACAO = 'A'" }).OrderBy(i => i.Descricao).ToList<Recurso>();
this.dropListViewRecurso.DataBind();
this.dropListViewRecurso.Items.Insert(0, "");
for (int p = 1; p < this.dropListViewRecurso.Items.Count; p++)
{
string value = this.dropListViewRecurso.Items[p].Value;
List<ItemReerva> reservas = ItemReerva.Carregar(new List<string>() { "ID_RECURSO = " + value, "SITUACAO not in ('C','R')" }, 5).Where(r => r.Reserva.Data == item.Data).ToList<ItemReerva>();
foreach (ItemReerva i in reservas)
{
if (int.Parse(Session["USUARIO_PRIORIDADE"].ToString()) < i.Reserva.Funcionario.Prioridade)
{
this.dropListViewRecurso.Items[p].Text += " [Sem prioridade]";
this.dropListViewRecurso.Items[p].Value = "R" + value;
}
else
{
this.dropListViewRecurso.Items[p].Text += " [Indisponível]";
this.dropListViewRecurso.Items[p].Value = "I" + value;
}
}
if (reservas.Count == 0)
{
this.dropListViewRecurso.Items[p].Text += " [Disponível]";
this.dropListViewRecurso.Items[p].Value = "D" + value;
}
}
this.gridItens.DataSource = ItemReerva.Carregar(new List<string>() { "ID_RESERVA = " + item.IdReserva.ToString() }, 2);
this.gridItens.DataBind();
}
private void reservar(int cantHab, Tipo_Habitacion tipo_seleccionado)
{
Reserva reserva = new Reserva();
reserva.CodigoRegimen = regimen_elegido.CodRegimen;
reserva.Fecha_Inicio_struct = dateTimeEntrada.Value;
reserva.Fecha_Fin_struct = dateTimeSalida.Value;
reserva.Fecha_Reserva_struct = Globals.getFechaSistema();
reserva.Usr = Globals.infoSesion.User.Usr;
reserva.cantHabitaciones = cantHab;
reserva.tipo_habitacion = tipo_seleccionado;
List<Habitacion> habitaciones_disponibles;
habitaciones_disponibles = DAOReserva.habitacionDisponibles(Globals.infoSesion.Hotel.CodHotel,tipo_seleccionado.TipoCodigo, reserva.Fecha_Inicio, reserva.Fecha_Fin);
if (habitaciones_disponibles.Count < cantHab)
{
DialogResult dr = MessageBox.Show("No existen suficientes habitaciones disponibles para efectuar la reserva.",
"", MessageBoxButtons.OK);
return;
}
for (int i = 0; i < cantHab; i++)
{
Detalle_Reserva det = new Detalle_Reserva();
det.CodigoHotel = Globals.infoSesion.Hotel.CodHotel;
det.Habitacion = habitaciones_disponibles[i].Id_Habitacion;
reserva.detalles_reserva.Add(det);
}
new ConfirmarReserva(reserva).Show();
Globals.deshabilitarAnterior(this);
}
public CancelarReserva(Usuario user, Reserva reserv)
: this()
{
usuario = user;
reserva = reserv;
}
private void Reservar(DenormalizedReference<Local> local, DateTime data, IList<HoraReservaEnum> hora)
{
#region pré-condição
var reservaComMesmoHorarioParaOLocal = Reservas.FirstOrDefault(r => r.Local.Equals(local)
&& r.Data.Equals(data)
&& r.Hora.Intersect(hora).Count() > 0);
var naoExisteReservaSemelhante = Assertion.That(reservaComMesmoHorarioParaOLocal == null)
.WhenNot(String.Format(@"O local '{0}' foi reservado mais de uma vez para um mesmo horário.
Verifique se o horário '{1} ({2})' está coincidindo com outra reserva para este local neste evento.",
local.Nome, data.ToString("dd/MM/yyyy"), hora.ToHoraReservaString()));
#endregion
naoExisteReservaSemelhante.Validate();
var reserva = new Reserva(local, data, hora);
var reservasAux = Reservas.ToList();
reservasAux.Add(reserva);
Reservas = reservasAux;
}
public ConfirmarReserva(Reserva reserva)
{
InitializeComponent();
datos_Reserva = reserva;
}
private void Cria_Reserva()
{
reserva = new Reserva(local, data, new List<HoraReservaEnum> { HoraReservaEnum.Manha });
}
private void botonDisponibilidad_Click(object sender, EventArgs e)
{
if (!datos_alterados)
{
showToolTip("Hay disponibilidad ya que no se modificaron los datos.", botonDisponibilidad, botonDisponibilidad.Location);
return;
}
if (chequearDatos())
{
nueva_reserva = duplicarReserva(reserva_elegida);
nueva_reserva.Fecha_Inicio_struct = dateTimeInicio.Value;
nueva_reserva.Fecha_Fin_struct = dateTimeFin.Value;
nueva_reserva.tipo_habitacion = tipos_habitacion[comboTipoHab.SelectedIndex];
nueva_reserva.CodigoRegimen = lista_regimenes[comboTipoRegimen.SelectedIndex].CodRegimen;
int cantPersonas = Int32.Parse(textCant.Text);
//Si se mantiene el tipo de habitacion, entonces solo tenemos que agregar o retirar habitaciones, que no sean las originales
if (tipo_elegido.TipoCodigo == nueva_reserva.tipo_habitacion.TipoCodigo)
cantPersonas = cantPersonas - cantPersonas_originales;
List<Habitacion> habitaciones_disponibles;
habitaciones_disponibles = DAOReserva.habitacionDisponibles(Globals.infoSesion.Hotel.CodHotel,
nueva_reserva.tipo_habitacion.TipoCodigo,
nueva_reserva.Fecha_Inicio, nueva_reserva.Fecha_Fin);
int cantAreservar = cantPersonas / nueva_reserva.tipo_habitacion.CantPersonas;
if (habitaciones_disponibles.Count < cantAreservar)
{
MessageBox.Show("No existen suficientes habitaciones disponibles para efectuar la reserva.",
"", MessageBoxButtons.OK);
return;
}
//Si es que faltan habitaciones (Tanto se mantenga o no el tipo de habitacion)
for (int i = 0; i < cantAreservar; i++)
{
Detalle_Reserva det = new Detalle_Reserva();
det.CodigoHotel = Globals.infoSesion.Hotel.CodHotel;
det.CodigoReserva = reserva_elegida.CodigoReserva;
det.Habitacion = habitaciones_disponibles[i].Id_Habitacion;
nueva_reserva.detalles_reserva.Add(det);
}
//Si es que sobran habitaciones (Si el tipo de habitacion se cambia, el numero es negativo y no cicla y queda vacio)
for (int i = 0; i < -cantAreservar; i++)
{
Detalle_Reserva det = new Detalle_Reserva();
det.CodigoHotel = Globals.infoSesion.Hotel.CodHotel;
det.CodigoReserva = reserva_elegida.CodigoReserva;
det.Habitacion = habitaciones_disponibles[i].Id_Habitacion;
detallesAremover.Add(det);
}
textPrecio.Text = Globals.obtenerPrecio(nueva_reserva.CodigoRegimen, cantPersonas + cantPersonas_originales,
Globals.infoSesion.Hotel.Recargo).ToString();
//Simamos la cantPersonas_originales para obtener la cantidad total de personas ingresadas y no tener que levantar todo de nuevo
MessageBox.Show("Hay disponibilidad para modificar la reserva.",
"", MessageBoxButtons.OK);
hab_confirmadas = true;
}
}
public ModificarReserva(Reserva reserva)
{
InitializeComponent();
reserva_elegida = reserva;
}
private Reserva duplicarReserva(Reserva reserva_elegida)
{
Reserva reserva = new Reserva();
reserva.CodigoReserva = reserva_elegida.CodigoReserva;
reserva.CodigoRegimen = reserva_elegida.CodigoRegimen;
reserva.Estado = reserva_elegida.Estado;
reserva.Fecha_Fin_struct = reserva_elegida.Fecha_Fin_struct;
reserva.Fecha_Inicio_struct = reserva_elegida.Fecha_Inicio_struct;
reserva.Fecha_Reserva_struct = reserva_elegida.Fecha_Reserva_struct;
reserva.Huesped = reserva_elegida.Huesped;
reserva.Usr = reserva_elegida.Usr;
return reserva;
}
private void ArmarReserva()
{
reserva = new Reserva(-1, ((Hotel)this.hotelComboBox.SelectedItem).identificador,
((Regimen)this.RegimenDataGrid.CurrentRow.DataBoundItem).identificador,
4000, this.DesdeDateTimePicker.Value, this.HastaDateTimePicker.Value);
}
