protected override void OnAppearing()
{
base.OnAppearing();
MessagingCenter.Subscribe <Reserva>(this, "ReservaSelecionada", async(reserva) =>
{
if (!reserva.Confirmado)
{
var reenviar = await DisplayAlert("Reenviar", "Deseja reenviar os dados da reserva?", "Sim", "Não");
if (reenviar)
{
ReservaService service = new ReservaService();
service.EnviarReserva(reserva);
_viewModel.AtualizarLista();
}
}
});
MessagingCenter.Subscribe <Reserva>(this, "SucessoReserva", async(reserva) => {
await DisplayAlert("Reenviar", "Reenvio com sucesso!", "Ok");
});
MessagingCenter.Subscribe <Reserva>(this, "FalhaReserva", async(reserva) => {
await DisplayAlert("Reenviar", "Falha ao reenvivar!", "Ok");
});
}
/// <summary>
/// Carrega os services para manipular os dados no banco de dados.
/// </summary>
static void carregaServices()
{
string ConnectionString_Desenvolvimento = "mongodb://127.0.0.1:27017/?readPreference=primary&ssl=false";
agendamentodb = new AgendamentoService(new DatabaseSettings()
{
DatabaseName = "agendamento",
ConnectionString = ConnectionString_Desenvolvimento,
Agendamento = "agendamento"
});
reservadb = new ReservaService(new DatabaseSettings()
{
DatabaseName = "agendamento",
ConnectionString = ConnectionString_Desenvolvimento,
Reserva = "reserva"
});
horariodb = new HorarioService(new DatabaseSettings()
{
DatabaseName = "agendamento",
ConnectionString = ConnectionString_Desenvolvimento,
Horario = "horario"
});
}
private void btnSalvarReserva_Click(object sender, EventArgs e)
{
string erro = String.Empty;
if (!ValidarCampos(out erro))
{
MessageBox.Show(erro, "Atenção");
}
ReservaTO reservaTO = new ReservaTO();
reservaTO.IdMorador = Convert.ToInt32(txtCodMorReserva.Text);
reservaTO.IdTipoReserva = Convert.ToInt32(cboTipoReserva.SelectedValue);
reservaTO.DataReserva = dtDataReserva.Value.Date;
ReservaService.Criar(reservaTO);
if (!reservaTO.Valido)
{
MessageBox.Show(reservaTO.Mensagem, "Atenção");
return;
}
this.Close();
}
public int buscarMesa(DateTime fechaReserva, int cantidadComensales)
{
Token token = (Token)Session["token"];
_mesaService = new MesaService(token.access_token);
List <Mesa> mesas = _mesaService.Obtener();
List <Mesa> mesasConCapcidad = mesas.Where(x => x.CantidadComensales >= cantidadComensales).ToList();
_reservaService = new ReservaService(token.access_token);
List <Reserva> reservas = _reservaService.Obtener();
int idMesa = 0;
foreach (Mesa mesa in mesasConCapcidad)
{
DateTime horaDesde = fechaReserva.AddMinutes(-60);
DateTime horahasta = fechaReserva.AddMinutes(60);
if (reservas == null || reservas.Count == 0)
{
idMesa = mesa.Id;
break;
}
List <Reserva> reservasMesa = reservas.Where(x => x.IdMesa == mesa.Id &&
x.FechaReserva.Date == fechaReserva.Date &&
x.FechaReserva >= horaDesde &&
x.FechaReserva <= horahasta
).ToList();
if (reservasMesa.Count == 0)
{
idMesa = mesa.Id;
break;
}
}
return(idMesa);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
ValidarSesion();
Usuario usuario = (Usuario)Session["usuario"];
if (usuario.IdTipoUsuario != TipoUsuario.administrador)
{
linkUsuarios.Attributes.Add("class", "list-group-item d-none");
linkReporteria.Attributes.Add("class", "list-group-item d-none");
if (usuario.IdTipoUsuario != TipoUsuario.bodega)
{
linkBodega.Attributes.Add("class", "list-group-item d-none");
}
if (!new int[] { TipoUsuario.cocina, TipoUsuario.garzon }.Contains(usuario.IdTipoUsuario))
{
linkCocina.Attributes.Add("class", "list-group-item d-none");
linkRestaurante.Attributes.Add("class", "list-group-item d-none");
}
if (usuario.IdTipoUsuario != TipoUsuario.garzon)
{
linkRestaurante.Attributes.Add("class", "list-group-item d-none");
}
}
Token token = (Token)Session["token"];
_mesaService = new MesaService(token.access_token);
List <Mesa> mesas = _mesaService.Obtener();
if (mesas != null && mesas.Count > 0)
{
List <Mesa> mesasDisponibles = mesas.Where(x => x.EstadoMesa.Id == EstadoMesa.disponible).ToList();
List <Mesa> mesasOcupadas = mesas.Where(x => x.EstadoMesa.Id == EstadoMesa.ocupada).ToList();
lblMesasDisponibles.Text = mesasDisponibles.Count.ToString();
lblMesasOcupadas.Text = mesasOcupadas.Count.ToString();
}
_reservaService = new ReservaService(token.access_token);
List <Reserva> reservas = _reservaService.Obtener();
if (reservas != null && reservas.Count > 0)
{
List <Reserva> reservasActivas = reservas.Where(x => x.EstadoReserva.Id == EstadoReserva.enCurso).ToList();
lblComensales.Text = reservasActivas.Count.ToString();
List <Reserva> listaProximaReserva = reservas.Where(x => x.EstadoReserva.Id == EstadoReserva.creada &&
x.FechaReserva.Date == DateTime.Now.Date &&
x.FechaReserva > DateTime.Now).ToList();
lblProximaReserva.Text = "Sin próximas reservas para hoy";
if (listaProximaReserva != null && listaProximaReserva.Count > 0)
{
Reserva proximaReserva = listaProximaReserva.OrderBy(x => x.FechaReserva).FirstOrDefault();
if (proximaReserva != null)
{
lblProximaReserva.Text = proximaReserva.FechaReserva.ToString("g") + " - " + proximaReserva.Mesa.Nombre;
}
}
}
}
}
public ListadoReserva()
{
InitializeComponent();
ReservaService = new ReservaService();
HotelService = new HotelService();
RegimenService = new RegimenService();
TipoHabitacionService = new TipoHabitacionService();
}
private void btnFacturar_Click(object sender, EventArgs e)
{
Factura factura = new Factura();
string error = string.Empty;
TarjetaDeCredito tarjeta = null;
if (Convert.ToInt32(cmbMedioDePago.SelectedValue) == 0)
{
error += "Seleccione un medio de pago";
}
factura.TipoPagoId = Convert.ToInt32(cmbMedioDePago.SelectedValue);
factura.ClienteId = this.ClienteId;
if (factura.TipoPagoId == 2)
{
error += ValidateTarjeta();
if (string.IsNullOrEmpty(error))
{
tarjeta = CreateTarjetaDeCredito();
}
}
if (string.IsNullOrEmpty(error))
{
try
{
factura.EstadiaId = Convert.ToInt32(txtNroEstadia.Text);
factura.Fecha = Session.Fecha;
factura.Items = new List <FacturaItem>();
EstadiaService estadiaService = new EstadiaService();
Estadia estadia = estadiaService.GetById(Convert.ToInt32(txtNroEstadia.Text));
ReservaService reservaService = new ReservaService();
Reserva reserva = reservaService.GetReservaByCodigo(estadia.CodigoReserva);
RegimenService regimenService = new RegimenService();
Regimen regimen = regimenService.GetByCodigo(reserva.RegimenCodigo);
CreateNightsItems(factura, estadia, reserva, regimen.Precio);
CreateConsumibleItems(factura, estadia, regimen.ConsumiblesGratis);
foreach (FacturaItem fi in factura.Items)
{
factura.Total += fi.Precio;
}
FacturaService service = new FacturaService();
factura.Numero = service.Insert(factura, tarjeta);
MostrarFactura(factura);
}
catch (Exception)
{
MessageBox.Show("Ocurrió un error al crear la factura");
}
}
else
{
MessageBox.Show(error);
}
}
private void dgvReserva_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
var grid = (DataGridView)sender;
if (grid.Columns[e.ColumnIndex] is DataGridViewButtonColumn && e.RowIndex >= 0)
{
int codigo = Convert.ToInt32(grid.Rows[e.RowIndex].Cells["Codigo"].Value);
AltaReserva form = new AltaReserva(ReservaService.GetReservaByCodigo(codigo));
}
}
public ActionResult Details(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
ReservaTO ReservaTO = new ReservaTO();
try
{
ReservaTO = ReservaService.Obter(id);
if (!ReservaTO.Valido)
{
Session["Mensagem"] = ReservaTO.Mensagem;
return(RedirectToActionPermanent("Index"));
}
var ReservaVM = Mapper.Map <ReservaTO, ReservaVM>(ReservaTO);
NomearVariaveis(ReservaVM, null);
return(View(ReservaVM));
}
catch (Exception ex)
{
ReservaTO.Mensagem = $"Erro ao obter Reserva. Erro: {ex.Message}";
}
return(View());
}
public ActionResult Index()
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
ListaReservaTO listaReserva = new ListaReservaTO();
try
{
if (_moradorTO != null)
{
listaReserva = ReservaService.ListarPorMorador(_moradorTO.Identificador);
}
else
{
listaReserva = ReservaService.Listar();
}
var listaReservasVM = Mapper.Map <List <ReservaTO>, List <ReservaVM> >(listaReserva.Lista);
NomearVariaveis(null, listaReservasVM);
return(View(listaReservasVM));
}
catch (Exception ex)
{
listaReserva.Mensagem = $"Erro ao obter Reservaes. Erro: {ex.Message} ";
}
return(View());
}
private void btnModificar_Click(object sender, EventArgs e)
{
if (currentReserva != null)
{
AltaReserva form = new AltaReserva(currentReserva);
form.ShowDialog();
SetearReserva(ReservaService.GetReservaByCodigo(currentReserva.Codigo));
}
else
{
MessageBox.Show("Primero debe seleccionar una reserva.");
}
}
public ReservaController(IReservaRepository reservaRepository, ReservaService reservaService,
IOpcionalRepository opcionalRepository, ITrechoRepository trechoRepository,
IClasseDeVooRepository classeDeVooRepository, PassagensContext contexto,
IUsuarioRepository usuarioRepository)
{
this.reservaRepository = reservaRepository;
this.reservaService = reservaService;
this.opcionalRepository = opcionalRepository;
this.trechoRepository = trechoRepository;
this.classeDeVooRepository = classeDeVooRepository;
this.usuarioRepository = usuarioRepository;
this.contexto = contexto;
}
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));
}
public IActionResult AtualizarReserva([FromBody] Reserva reserva)
{
try
{
ReservaService reservaService = new ReservaService(this._context);
reservaService.AtualizarReserva(reserva);
return(Ok(""));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public IActionResult PesquisarReserva([FromHeader] Reserva reserva)
{
try
{
ReservaService reservaService = new ReservaService(this._context);
reservaService.BuscarReserva(reserva);
return(Ok(reservaService._reserva));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public ActionResult Edit(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
ViewBag.Morador = ListarMoradores();
ViewBag.TipoReserva = ListarTipoReservas();
if (ModelState.IsValid)
{
var ReservaTO = ReservaService.Obter(id);
if (!ReservaTO.Valido)
{
Session["Mensagem"] = ReservaTO.Mensagem;
return(RedirectToAction("Index"));
}
var ReservaVM = Mapper.Map <ReservaTO, ReservaVM>(ReservaTO);
NomearVariaveis(ReservaVM, null);
return(View(ReservaVM));
}
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
if (ModelState.IsValid)
{
if (id > 0)
{
var retorno = ReservaService.Remover(id);
Session["Mensagem"] = retorno.Mensagem;
}
}
return(RedirectToAction("Index"));
}
public IActionResult CancelarReserva([FromBody] Reserva reserva)
{
try
{
ReservaService reservaService = new ReservaService(this._context);
reservaService.CancelarReserva(reserva);
reservaService.EnviarEmailCancelamento(reserva);
return(Ok(""));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public IActionResult Reservar([FromBody] Reserva reserva)
{
try
{
ReservaService reservaService = new ReservaService(_context);
reservaService.Salvar(reserva);
reservaService.EnviarEmailReserva(reserva);
return(Ok(reserva));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
private void btnConfirmaExclusaoReserva_Click(object sender, EventArgs e)
{
int idReserva = Convert.ToInt32(lblExcluirCodReserva.Text);
RetornoTO retorno = new RetornoTO();
retorno = ReservaService.Remover(idReserva);
//Todo: Retornar mensagem se nao for valido
if (!retorno.Valido)
{
MessageBox.Show(retorno.Mensagem, "Atenção");
}
this.Close();
}
private void PreencherCampos(int id)
{
ReservaTO reservaTO = new ReservaTO();
reservaTO = ReservaService.Obter(id);
if (!reservaTO.Valido)
{
MessageBox.Show(reservaTO.Mensagem, "Atenção");
}
txtEditarCodMorReserva.Text = Convert.ToString(reservaTO.IdMorador);
cboEditarTipoReserva.Text = Convert.ToString(reservaTO.IdTipoReserva);
dtEditarDataReserva.Text = Convert.ToString(reservaTO.DataReserva);
lblEditarCodReserva.Text = reservaTO.Identificador.ToString();
}
protected void btnEditarReserva_Click(object sender, EventArgs e)
{
ValidarSesion();
Page.Validate("ValidacionReserva");
if (!Page.IsValid)
{
upModalReserva.Update();
return;
}
try
{
Reserva reserva = new Reserva();
reserva.Id = int.Parse(txtIdReserva.Text);
reserva.FechaReserva = Convert.ToDateTime(txtFechaHoraReserva.Text);
reserva.CantidadComensales = int.Parse(txtCantidadComensalesReserva.Text);
reserva.IdEstadoReserva = int.Parse(ddlEstadoReserva.SelectedValue);
reserva.IdCliente = int.Parse(ddlClienteReserva.SelectedValue);
reserva.IdMesa = int.Parse(ddlMesaReserva.SelectedValue);
Token token = (Token)Session["token"];
_reservaService = new ReservaService(token.access_token);
bool editar = _reservaService.Modificar(reserva, reserva.Id);
if (editar)
{
List <Reserva> reservas = _reservaService.Obtener();
if (reservas != null && reservas.Count > 0)
{
var reservasOrdenadas = reservas.OrderByDescending(x => x.FechaReserva).ToList();
actualizarRepeater(listaReservas, reservasOrdenadas, listaReservasVacia);
upListaReservas.Update();
}
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "editarReserva", "Swal.fire('Reserva editada', '', 'success');", true);
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "modalReserva", "$('#modalReserva').modal('hide');", true);
}
else
{
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "modalReserva", "Swal.fire('Error al editar reserva', '', 'error');", true);
}
}
catch (Exception ex)
{
string mensaje = ex != null && ex.Message != null ? ex.Message : "Ocurrió un error inesperado. Intente nuevamente";
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "error", "Swal.fire('Error', '" + mensaje + "', 'error');", true);
return;
}
}
private void btnBuscar_Click(object sender, EventArgs e)
{
string codigo = txtCodigo.Text;
if (!string.IsNullOrEmpty(codigo))
{
Reserva reserva = ReservaService.GetReservaByCodigo(Convert.ToInt32(codigo));
if (reserva != null)
{
SetearReserva(reserva);
}
else
{
MessageBox.Show("No se ha encontrado la reserva");
}
}
}
private void btnSalvarReserva_Click(object sender, EventArgs e)
{
ReservaTO reservaTO = new ReservaTO();
reservaTO.IdMorador = Convert.ToInt32(txtEditarCodMorReserva.Text);
reservaTO.Identificador = Convert.ToInt32(lblEditarCodReserva.Text);
reservaTO.IdTipoReserva = Convert.ToInt32(cboEditarTipoReserva.Text);
reservaTO.DataReserva = Convert.ToDateTime(dtEditarDataReserva.Text);
ReservaService.Atualizar(reservaTO);
if (!reservaTO.Valido)
{
MessageBox.Show(reservaTO.Mensagem);
}
this.Close();
}
public BaseReservaController(
IReservaRepository reservaRepository,
ISuiteRepository suiteRepository,
IUsuarioRepository usuarioRepository,
ReservaService reservaService,
BookingContext contexto,
IOpcionalRepository opcionalRepository,
IReservaOpcionalRepository reservaOpcionalRepository
)
{
this.reservaRepository = reservaRepository;
this.reservaService = reservaService;
this.contexto = contexto;
this.usuarioRepository = usuarioRepository;
this.suiteRepository = suiteRepository;
this.opcionalRepository = opcionalRepository;
this.reservaOpcionalRepository = reservaOpcionalRepository;
}
public ActionResult Create(ReservaVM Reserva)
{
if (ModelState.IsValid)
{
Reserva.ConfirmacaoReserva = Reserva.Confirmacao ? "S" : "N";
var ReservaTO = Mapper.Map <ReservaVM, ReservaTO>(Reserva);
ReservaService.Criar(ReservaTO);
Session["Mensagem"] = ReservaTO.Mensagem;
return(RedirectToAction("Index"));
}
else
{
return(View(Reserva));
}
}
protected int guardarReserva(int idCliente, int idMesa, DateTime fecha)
{
Reserva reserva = new Reserva();
reserva.FechaReserva = fecha;
reserva.CantidadComensales = int.Parse(txtComensales.Text);
reserva.IdEstadoReserva = EstadoReserva.creada;
reserva.IdCliente = idCliente;
reserva.IdMesa = idMesa;
Token token = (Token)Session["token"];
_reservaService = new ReservaService(token.access_token);
int idReserva = _reservaService.Guardar(reserva);
reserva.Id = idReserva;
Session["reservaCreada"] = reserva;
return(idReserva);
}
private void btnDisponibilidad_Click(object sender, EventArgs e)
{
if (esValidoSinRegimen())
{
int hotelId = getHotelId();
DateTime fechaDesde = dateFechaDesde.Value;
DateTime fechaHasta = dateFechaHasta.Value;
int tipoHabitacionCodigo = (int)cmbTipoHabitacion.SelectedValue;
if (!ReservaService.IsReservaAvailable(hotelId, fechaDesde, fechaHasta, tipoHabitacionCodigo))
{
MessageBox.Show("No hay disponibilidad para los parametros solicitados");
}
else
{
MessageBox.Show("El precio es de " + GenerarPrecio() + " USD");
}
}
}
public ActionResult Delete(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
if (id > 0)
{
var ReservaTO = ReservaService.Obter(id);
var ReservaVM = Mapper.Map <ReservaTO, ReservaVM>(ReservaTO);
NomearVariaveis(ReservaVM, null);
return(View(ReservaVM));
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult Edit(ReservaVM ReservaVM)
{
if (ModelState.IsValid)
{
ReservaVM.ConfirmacaoReserva = ReservaVM.Confirmacao ? "S" : "N";
var ReservaTO = Mapper.Map <ReservaVM, ReservaTO>(ReservaVM);
ReservaService.Atualizar(ReservaTO);
if (!ReservaTO.Valido)
{
Session["Mensagem"] = ReservaTO.Valido;
return(RedirectToAction("Index"));
}
ReservaVM = Mapper.Map <ReservaTO, ReservaVM>(ReservaTO);
}
return(RedirectToAction("Index"));
}