private async void ListaTareas_ItemTapped(object sender, ItemTappedEventArgs e)
{
var tareaPulsada = (Tarea)e.Item;
string opcion = await UserDialogs.Instance.ActionSheetAsync("Opciones tarea", "Cancelar", null, null, OpcionesTarea);
if (opcion == "Cancelar")
{
return;
}
if (opcion == OpcionesTarea[0]) // Completada
{
if (await UserDialogs.Instance.ConfirmAsync("Confirmar tarea completada", "¿Tarea completada?", "Completada", "Cancelar"))
{
await Task.Run(() =>
{
new Comando_TareaCompletada(tareaPulsada.ID).Enviar(Global.IPGestor);
});
lock (Global.TareasPersonalesLock)
{
Global.TareasPersonales.Remove(tareaPulsada);
Global.TareasPersonales.Ordenar();
}
}
return;
}
if (opcion == OpcionesTarea[1]) // Reasignar
{
if (await UserDialogs.Instance.ConfirmAsync("Confirmar reasignación de tarea", "¿Reasignar tarea?", "Reasignar", "Cancelar"))
{
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ReasignarTarea(tareaPulsada.ID).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, () =>
{
lock (Global.TareasPersonalesLock)
{
Global.TareasPersonales.Remove(tareaPulsada);
Global.TareasPersonales.Ordenar();
}
});
}
return;
}
}
public static async void RenombrarCategoria(string NombreActual, string NuevoNombre)
{
UserDialogs.Instance.ShowLoading("Cambiando nombre a categoría...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarCategoriaNombre(NombreActual, NuevoNombre).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
}
private async void MoverMesa(byte numeroMesaOrigen, byte nuevoSitioX, byte nuevoSitioY)
{
UserDialogs.Instance.ShowLoading("Moviendo mesa...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarMesaSitio(numeroMesaOrigen, nuevoSitioX, nuevoSitioY).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, ActualizarMapaMesas);
UserDialogs.Instance.HideLoading();
}
private async void EditarMapaMesas(string TituloLoading, TiposEdicionMapaMesas TipoEdicionMapaMesas)
{
UserDialogs.Instance.ShowLoading(TituloLoading);
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_EditarMapaMesas(TipoEdicionMapaMesas).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, ActualizarMapaMesas);
UserDialogs.Instance.HideLoading();
}
// ============================================================================================== //
// Eventos UI -> Barra navegación
private async void NuevoArticulo_Clicked(object sender, EventArgs e)
{
Articulo nuevoArticulo = new("", "", 0f);
while (true)
{
string nombre = await Global.PedirAlUsuarioStringCorrecto("Nombre", 100, true);
if (nombre == null)
{
return;
}
Articulo[] articulos;
lock (Global.CategoriasLock)
articulos = Global.Categorias.SelectMany(cl => cl).ToArray();
if (articulos.Any(a => a.Nombre == nombre))
{
await UserDialogs.Instance.AlertAsync("Ya existe un artículo con este Nombre", "Alerta", "Aceptar");
}
else
{
nuevoArticulo.Nombre = nombre; break;
}
}
List <string> categorias;
lock (Global.CategoriasLock)
categorias = Global.Categorias.Select(cl => ((GrupoArticuloCategoria)cl).Categoria).ToList();
var categoriasExistentesMasOpcionNueva = categorias;
categoriasExistentesMasOpcionNueva.Add("+ Nueva");
string categoriaONueva = await UserDialogs.Instance.ActionSheetAsync("Categoría", "Cancelar", null, null, categoriasExistentesMasOpcionNueva.ToArray());
if (categoriaONueva == "Cancelar")
{
return;
}
if (categoriaONueva != "+ Nueva")
{
nuevoArticulo.Categoria = categoriaONueva;
}
else
{
while (true)
{
string nuevaCategoria = await Global.PedirAlUsuarioStringCorrecto("Nueva categoría", 100, true);
if (nuevaCategoria == null)
{
return;
}
if (categorias.Contains(nuevaCategoria))
{
await UserDialogs.Instance.AlertAsync("Ya existe una Categoría con este nombre", "Alerta", "Aceptar");
}
else
{
nuevoArticulo.Categoria = nuevaCategoria; break;
}
}
}
while (true)
{
var configuracionPrompt = new PromptConfig
{
InputType = InputType.DecimalNumber,
IsCancellable = true,
Title = "Precio",
Message = $"Mínimo: {Comun.Global.MINIMO_PRECIO_ARTICULO} €\nMáximo: {Comun.Global.MAXIMO_PRECIO_ARTICULO} €",
OkText = "Aceptar",
CancelText = "Cancelar",
MaxLength = (int)Math.Floor(Math.Log10(Comun.Global.MAXIMO_PRECIO_ARTICULO * 100 + 1) + 1),
};
var resultado = await UserDialogs.Instance.PromptAsync(configuracionPrompt);
if (!resultado.Ok)
{
return;
}
if (!float.TryParse(resultado.Text, out float precio) || float.Parse(resultado.Text) < Comun.Global.MINIMO_PRECIO_ARTICULO || float.Parse(resultado.Text) > Comun.Global.MAXIMO_PRECIO_ARTICULO)
{
await UserDialogs.Instance.AlertAsync("El número introducido no es válido", "Alerta", "Aceptar"); continue;
}
nuevoArticulo.Precio = precio;
break;
}
string sitioPreparacionString = await UserDialogs.Instance.ActionSheetAsync("Se prepara en...", "Cancelar", null, null, SitiosPreparacionArticulo_ToStringArray());
if (sitioPreparacionString == "Cancelar")
{
return;
}
nuevoArticulo.SitioPreparacionArticulo = (SitioPreparacionArticulo)Enum.Parse(typeof(SitioPreparacionArticulo), sitioPreparacionString);
UserDialogs.Instance.ShowLoading("Creando artículo...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_CrearArticulo(nuevoArticulo).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
}
private async void ListaArticulos_ItemTapped(object sender, ItemTappedEventArgs e)
{
var articuloPulsado = (Articulo)e.Item;
string opcion = await UserDialogs.Instance.ActionSheetAsync($"{articuloPulsado.Nombre}", "Cancelar", null, null, OpcionesArticulo);
if (opcion == "Cancelar")
{
return;
}
if (opcion == OpcionesArticulo[0]) // Cambiar Nombre
{
string nuevoNombre = "";
while (true)
{
nuevoNombre = await Global.PedirAlUsuarioStringCorrecto($"Nuevo Nombre\n(actual = {articuloPulsado.Nombre})", 100, true);
if (nuevoNombre == null)
{
return;
}
Articulo[] articulos;
lock (Global.CategoriasLock)
articulos = Global.Categorias.SelectMany(cl => cl).ToArray();
if (articulos.Any(a => a.Nombre == nuevoNombre))
{
await UserDialogs.Instance.AlertAsync("Ya existe un artículo con este Nombre", "Alerta", "Aceptar");
}
else
{
break;
}
}
UserDialogs.Instance.ShowLoading("Cambiando nombre...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarArticuloNombre(articuloPulsado.Nombre, nuevoNombre).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesArticulo[1]) // Cambiar Categoría
{
string nuevaCategoria = "";
List <string> categorias;
lock (Global.CategoriasLock)
categorias = Global.Categorias.Select(cl => ((GrupoArticuloCategoria)cl).Categoria).ToList();
var categoriasExistentesMasOpcionNueva = categorias;
categoriasExistentesMasOpcionNueva.Add("+ Nueva");
string categoriaONueva = await UserDialogs.Instance.ActionSheetAsync($"Nueva Categoría\n(actual = {articuloPulsado.Categoria})", "Cancelar", null, null, categoriasExistentesMasOpcionNueva.ToArray());
if (categoriaONueva == "Cancelar")
{
return;
}
if (categoriaONueva != "+ Nueva")
{
nuevaCategoria = categoriaONueva;
}
else
{
while (true)
{
string nuevaNuevaCategoria = await Global.PedirAlUsuarioStringCorrecto("Nueva categoría", 100, true);
if (nuevaNuevaCategoria == null)
{
return;
}
if (categorias.Contains(nuevaNuevaCategoria))
{
await UserDialogs.Instance.AlertAsync("Ya existe una Categoría con este nombre", "Alerta", "Aceptar");
}
else
{
nuevaCategoria = nuevaNuevaCategoria; break;
}
}
}
UserDialogs.Instance.ShowLoading("Cambiando categoria...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarArticuloCategoria(articuloPulsado.Nombre, nuevaCategoria).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesArticulo[2]) // Cambiar Precio
{
float nuevoPrecio = 0f;
while (true)
{
var configuracionPrompt = new PromptConfig
{
InputType = InputType.DecimalNumber,
IsCancellable = true,
Title = $"Nuevo Precio\n(actual = {articuloPulsado.Precio} €)",
Message = $"Mínimo: {Comun.Global.MINIMO_PRECIO_ARTICULO} €\nMáximo: {Comun.Global.MAXIMO_PRECIO_ARTICULO} €",
OkText = "Aceptar",
CancelText = "Cancelar",
MaxLength = (int)Math.Floor(Math.Log10(Comun.Global.MAXIMO_PRECIO_ARTICULO * 100 + 1) + 1),
};
var resultado = await UserDialogs.Instance.PromptAsync(configuracionPrompt);
if (!resultado.Ok)
{
return;
}
if (!float.TryParse(resultado.Text, out nuevoPrecio) || float.Parse(resultado.Text) < Comun.Global.MINIMO_PRECIO_ARTICULO || float.Parse(resultado.Text) > Comun.Global.MAXIMO_PRECIO_ARTICULO)
{
await UserDialogs.Instance.AlertAsync("El número introducido no es válido", "Alerta", "Aceptar"); continue;
}
break;
}
UserDialogs.Instance.ShowLoading("Cambiando precio...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarArticuloPrecio(articuloPulsado.Nombre, nuevoPrecio).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesArticulo[3]) // Cambiar Sitio de Preparación
{
SitioPreparacionArticulo nuevoSitioPreparacion;
var sitiosPreparacionArticulo_menosActual =
SitiosPreparacionArticulo_ToStringArray()
.Where(s => s != articuloPulsado.SitioPreparacionArticulo.ToString())
.ToArray();
string nuevoSitioPreparacionString =
await UserDialogs.Instance.ActionSheetAsync(
$"Cambiar a preparar en...\n(actualmente en {articuloPulsado.SitioPreparacionArticulo})",
"Cancelar",
null, null,
sitiosPreparacionArticulo_menosActual);
if (nuevoSitioPreparacionString == "Cancelar")
{
return;
}
nuevoSitioPreparacion = (SitioPreparacionArticulo)Enum.Parse(typeof(SitioPreparacionArticulo), nuevoSitioPreparacionString);
UserDialogs.Instance.ShowLoading("Cambiando sitio de preparación...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarArticuloSitioDePreparacion(articuloPulsado.Nombre, nuevoSitioPreparacion).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesArticulo[4]) // Eliminar
{
if (await UserDialogs.Instance.ConfirmAsync($"¿Eliminar el artículo '{articuloPulsado.Nombre}'?", "Confirmar eliminación", "Eliminar", "Cancelar"))
{
UserDialogs.Instance.ShowLoading("Eliminando artículo...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_EliminarArticulo(articuloPulsado.Nombre).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, async() => await Global.Get_Articulos());
UserDialogs.Instance.HideLoading();
}
return;
}
}
// ============================================================================================== //
// Eventos UI -> Barra navegación
private async void NuevoUsuario_Clicked(object sender, EventArgs e)
{
Usuario nuevoUsuario = new("", "", "", Roles.Ninguno);
string nombre = await Global.PedirAlUsuarioStringCorrecto("Nombre", Comun.Global.MAX_CARACTERES_LOGIN, true);
if (nombre == null)
{
return;
}
nuevoUsuario.Nombre = nombre;
while (true)
{
string nombreUsuario = await Global.PedirAlUsuarioStringCorrecto("Nombre de Usuario", Comun.Global.MAX_CARACTERES_LOGIN, false);
if (nombreUsuario == null)
{
return;
}
nuevoUsuario.NombreUsuario = nombreUsuario;
bool algunUsuarioConMismoNombre;
lock (Global.UsuariosLock)
algunUsuarioConMismoNombre =
Global.Usuarios
.Any(u => u.NombreUsuario == nombreUsuario);
if (algunUsuarioConMismoNombre)
{
await DisplayAlert("Alerta", "Ya existe un usuario con este Nombre de Usuario", "Aceptar");
}
else
{
break;
}
}
string contrasena = await Global.PedirAlUsuarioStringCorrecto("Contraseña", Comun.Global.MAX_CARACTERES_LOGIN, false);
if (contrasena == null)
{
return;
}
nuevoUsuario.Contrasena = contrasena;
string rolString = await UserDialogs.Instance.ActionSheetAsync("Rol", "Cancelar", null, null, RolesBaseToStringArray());
if (rolString == "Cancelar")
{
return;
}
nuevoUsuario.Rol = (Roles)Enum.Parse(typeof(Roles), rolString);
UserDialogs.Instance.ShowLoading("Creando usuario...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_CrearUsuario(nuevoUsuario).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
}
private async void ListaUsuarios_ItemTapped(object sender, ItemTappedEventArgs e)
{
var usuarioPulsado = (Usuario)e.Item;
string[] opcionesUsuario;
// Si el pulsado es el Admin => solo cambiar contraseña
if (usuarioPulsado.Rol == Roles.Administrador)
{
opcionesUsuario = new string[] { OpcionesUsuario[2] }
}
;
else
{
opcionesUsuario = OpcionesUsuario;
}
string opcion = await UserDialogs.Instance.ActionSheetAsync($"{usuarioPulsado.Nombre}", "Cancelar", null, null, opcionesUsuario);
if (opcion == "Cancelar")
{
return;
}
if (opcion == OpcionesUsuario[0]) // Cambiar Nombre
{
string nuevoNombre;
while (true)
{
nuevoNombre = await Global.PedirAlUsuarioStringCorrecto($"Nuevo Nombre\n(actual = {usuarioPulsado.Nombre})", Comun.Global.MAX_CARACTERES_LOGIN, true);
if (nuevoNombre == null)
{
return;
}
if (nuevoNombre != usuarioPulsado.Nombre)
{
break;
}
await DisplayAlert("Alerta", $"El nuevo Nombre no puede ser igual que el anterior", "Aceptar");
}
UserDialogs.Instance.ShowLoading("Modificando Nombre...");
if (usuarioPulsado.NombreUsuario == Global.UsuarioActual.NombreUsuario)
{
Global.UsuarioActual.Nombre = nuevoNombre;
}
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarUsuarioNombre(usuarioPulsado.NombreUsuario, nuevoNombre).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesUsuario[1]) // Cambiar Nombre de Usuario
{
string nuevoNombreUsuario;
while (true)
{
nuevoNombreUsuario = await Global.PedirAlUsuarioStringCorrecto($"Nuevo Nombre de Usuario\n(actual = {usuarioPulsado.NombreUsuario})", Comun.Global.MAX_CARACTERES_LOGIN, true);
if (nuevoNombreUsuario == null)
{
return;
}
bool algunUsuarioConMismoNombre;
lock (Global.UsuariosLock)
algunUsuarioConMismoNombre =
Global.Usuarios
.Any(u => u.NombreUsuario == nuevoNombreUsuario);
if (algunUsuarioConMismoNombre)
{
await DisplayAlert("Alerta", "Ya existe un usuario con este Nombre de Usuario", "Aceptar");
}
else if (nuevoNombreUsuario == usuarioPulsado.NombreUsuario)
{
await DisplayAlert("Alerta", $"El nuevo Nombre de Usuario no puede ser igual que el anterior", "Aceptar");
}
else
{
break;
}
}
UserDialogs.Instance.ShowLoading("Modificando Nombre de Usuario...");
if (usuarioPulsado.NombreUsuario == Global.UsuarioActual.NombreUsuario)
{
Global.UsuarioActual.NombreUsuario = nuevoNombreUsuario;
}
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarUsuarioNombreUsuario(usuarioPulsado.NombreUsuario, nuevoNombreUsuario).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesUsuario[2]) // Cambiar Contraseña
{
string nuevaContrasena;
while (true)
{
nuevaContrasena = await Global.PedirAlUsuarioStringCorrecto($"Nueva Contraseña\n(actual = {usuarioPulsado.Contrasena})", Comun.Global.MAX_CARACTERES_LOGIN, true);
if (nuevaContrasena == null)
{
return;
}
if (nuevaContrasena != usuarioPulsado.Contrasena)
{
break;
}
await DisplayAlert("Alerta", $"La nueva Contraseña no puede ser igual que la anterior", "Aceptar");
}
UserDialogs.Instance.ShowLoading("Modificando Contraseña...");
if (usuarioPulsado.NombreUsuario == Global.UsuarioActual.NombreUsuario)
{
Global.UsuarioActual.Contrasena = nuevaContrasena;
}
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarUsuarioContrasena(usuarioPulsado.NombreUsuario, nuevaContrasena).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesUsuario[3]) // Cambiar Rol
{
Roles nuevoRol;
while (true)
{
string rolString = await UserDialogs.Instance.ActionSheetAsync($"Nuevo Rol (actual = {usuarioPulsado.Rol})", "Cancelar", null, null, RolesBaseToStringArray());
if (rolString == "Cancelar")
{
return;
}
nuevoRol = (Roles)Enum.Parse(typeof(Roles), rolString);
if (nuevoRol != usuarioPulsado.Rol)
{
break;
}
await DisplayAlert("Alerta", $"El nuevo Rol no puede ser igual que el anterior", "Aceptar");
}
UserDialogs.Instance.ShowLoading("Modificando Rol...");
if (usuarioPulsado.NombreUsuario == Global.UsuarioActual.NombreUsuario)
{
Global.UsuarioActual.Rol = nuevoRol;
}
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarUsuarioRol(usuarioPulsado.NombreUsuario, nuevoRol).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesUsuario[4]) // Eliminar
{
if (await UserDialogs.Instance.ConfirmAsync($"¿Eliminar el usuario '{usuarioPulsado.NombreUsuario}'?", "Confirmar eliminación", "Eliminar", "Cancelar"))
{
UserDialogs.Instance.ShowLoading("Eliminando usuario...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_EliminarUsuario(usuarioPulsado.NombreUsuario).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, RefrescarUsuarios);
UserDialogs.Instance.HideLoading();
}
}
}
private async void MesaPulsada(object sender, EventArgs e)
{
var sitioPulsadoString = (string)((Button)sender).BindingContext;
int indiceDelPunto = sitioPulsadoString.IndexOf('.');
byte sitioPulsadoX = byte.Parse(sitioPulsadoString.Substring(0, indiceDelPunto));
byte sitioPulsadoY = byte.Parse(sitioPulsadoString.Substring(indiceDelPunto + 1, sitioPulsadoString.Length - indiceDelPunto - 1));
bool condicionMesaSeleccionada(Mesa m) => m.SitioX == sitioPulsadoX && m.SitioY == sitioPulsadoY;
if (!Global.Mesas.Any(condicionMesaSeleccionada)) // Crear mesa
{
CrearMesa(sitioPulsadoX, sitioPulsadoY);
}
else
{
var mesaSeleccionada = Global.Mesas.Where(condicionMesaSeleccionada).Single();
string opcion = await UserDialogs.Instance.ActionSheetAsync($"Mesa {mesaSeleccionada.Numero}", "Cancelar", null, null, OpcionesMesaExistente);
if (opcion == "Cancelar")
{
return;
}
if (opcion == OpcionesMesaExistente[0]) // Cambiar número
{
byte mcm = Comun.Global.MAXIMO_COLUMNAS_MESAS;
byte mfm = Comun.Global.MAXIMO_FILAS_MESAS;
if (mcm * mfm > 255)
{
throw new IndexOutOfRangeException("Hay más de 255 mesas :/");
}
byte totalMesas = (byte)(mcm * mfm);
byte numeroNuevaMesa;
while (true)
{
var configuracionPrompt = new PromptConfig
{
InputType = InputType.Number,
IsCancellable = true,
Title = "Cambiar número",
Message = $"Número de mesa (1-{totalMesas})\n(Actual = {mesaSeleccionada.Numero})",
OkText = "Cambiar",
CancelText = "Cancelar",
MaxLength = (int)Math.Floor(Math.Log10(totalMesas) + 1),
};
var resultado = await UserDialogs.Instance.PromptAsync(configuracionPrompt);
if (!resultado.Ok)
{
return;
}
if (resultado.Text == "" || resultado.Text == "0" || resultado.Text == "00")
{
await UserDialogs.Instance.AlertAsync("El número introducido no es válido", "Alerta", "Aceptar"); continue;
}
numeroNuevaMesa = byte.Parse(resultado.Text);
if (numeroNuevaMesa > totalMesas)
{
await UserDialogs.Instance.AlertAsync("El número introducido es mayor al máximo", "Alerta", "Aceptar"); continue;
}
if (Global.Mesas.Where(m => m.Numero == numeroNuevaMesa).Any())
{
await UserDialogs.Instance.AlertAsync("Ya existe una mesa con ese número", "Alerta", "Aceptar");
}
else
{
break;
}
}
UserDialogs.Instance.ShowLoading("Cambiando número de mesa...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_ModificarMesaNumero(mesaSeleccionada.Numero, numeroNuevaMesa).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, ActualizarMapaMesas);
UserDialogs.Instance.HideLoading();
return;
}
if (opcion == OpcionesMesaExistente[1]) // Mover
{
await Navigation.PushPopupAsync(new MoverMesa(mesaSeleccionada.Numero, MoverMesa));
return;
}
if (opcion == OpcionesMesaExistente[2]) // Eliminar
{
if (await UserDialogs.Instance.ConfirmAsync($"¿Eliminar la Mesa '{mesaSeleccionada.Numero}'?", "Confirmar eliminación", "Eliminar", "Cancelar"))
{
UserDialogs.Instance.ShowLoading("Eliminando mesa...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_EliminarMesa(mesaSeleccionada.Numero).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, ActualizarMapaMesas);
UserDialogs.Instance.HideLoading();
return;
}
}
}
}
private async void CrearMesa(byte sitioX, byte sitioY)
{
byte mcm = Comun.Global.MAXIMO_COLUMNAS_MESAS;
byte mfm = Comun.Global.MAXIMO_FILAS_MESAS;
if (mcm * mfm > 255)
{
throw new IndexOutOfRangeException("Hay más de 255 mesas :/");
}
byte totalMesas = (byte)(mcm * mfm);
byte numeroNuevaMesa;
while (true)
{
var configuracionPrompt = new PromptConfig
{
InputType = InputType.Number,
IsCancellable = true,
Title = "Nueva mesa",
Message = $"Número de mesa (1-{totalMesas})",
OkText = "Crear",
CancelText = "Cancelar",
MaxLength = (int)Math.Floor(Math.Log10(totalMesas) + 1),
};
var resultado = await UserDialogs.Instance.PromptAsync(configuracionPrompt);
if (!resultado.Ok)
{
return;
}
if (resultado.Text == "" || resultado.Text == "0" || resultado.Text == "00")
{
await UserDialogs.Instance.AlertAsync("El número introducido no es válido", "Alerta", "Aceptar"); continue;
}
numeroNuevaMesa = byte.Parse(resultado.Text);
if (numeroNuevaMesa > totalMesas)
{
await UserDialogs.Instance.AlertAsync("El número introducido es mayor al máximo", "Alerta", "Aceptar"); continue;
}
if (Global.Mesas.Where(m => m.Numero == numeroNuevaMesa).Any())
{
await UserDialogs.Instance.AlertAsync("Ya existe una mesa con ese número", "Alerta", "Aceptar");
}
else
{
break;
}
}
Mesa nuevaMesa = new(numeroNuevaMesa, sitioX, sitioY);
UserDialogs.Instance.ShowLoading("Creando mesa...");
var comandoRespuesta = await Task.Run(() =>
{
string respuestaGestor = new Comando_CrearMesa(nuevaMesa).Enviar(Global.IPGestor);
return(Comando.DeJson <Comando_ResultadoGenerico>(respuestaGestor));
});
Global.Procesar_ResultadoGenerico(comandoRespuesta, ActualizarMapaMesas);
UserDialogs.Instance.HideLoading();
}
