Exemple #1
0
        private async void RenombrarCategoria_Clicked(object sender, EventArgs e)
        {
            string nuevoNombreCategoria;

            string[] categorias;

            lock (Global.CategoriasLock)
                categorias = Global.Categorias.Select(cl => ((GrupoArticuloCategoria)cl).Categoria).ToArray();

            string categoriaSeleccionada = await UserDialogs.Instance.ActionSheetAsync($"Renombrar categoría", "Cancelar", null, null, categorias);

            if (categoriaSeleccionada == "Cancelar")
            {
                return;
            }

            while (true)
            {
                nuevoNombreCategoria = await Global.PedirAlUsuarioStringCorrecto("Nuevo nombre para categoría", 100, true);

                if (nuevoNombreCategoria == null)
                {
                    return;
                }

                if (categorias.Contains(nuevoNombreCategoria))
                {
                    await UserDialogs.Instance.AlertAsync("Ya existe una Categoría con este nombre", "Alerta", "Aceptar");
                }
                else
                {
                    break;
                }
            }

            RenombrarCategoria(categoriaSeleccionada, nuevoNombreCategoria);
        }
Exemple #2
0
        // ============================================================================================== //

        // 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();
        }
Exemple #3
0
        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;
            }
        }
Exemple #4
0
        // ============================================================================================== //

        // 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();
        }
Exemple #5
0
        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();
                }
            }
        }