Capitulo 4 Menú Administrador

Hola vamos a continuar con el tutorial porque como prometí lo haríamos completo. Había dicho que continuaremos con abm de datos pero me estaba olvidando algo importante que es la administración de usuarios de nuestra aplicacion en caso de que necesiten dar permisos específicos a los distintos menús del sistema. Porque hasta ahora lo unico que haciamos era verificar un usuarios y contraseña y con eso ya ingresaba al sistema, el que voy a hacer no es la única forma de controlar usuarios ni la mas segura pero es el mas practico para resolver esta cuestión , se puede usar la seguridad de windows, el active directory o el membership de asp.net para usar en windows form pero tomaria mas de un capitulo y habia dicho que no queria que sea tan tedioso y mas bien de practica, en cuanto a lo de no ser seguro es porque si alguien usa un "disassembler" podria cambiar en memoria intrucciones de nuestra aplicacion, pero tranquilos tambien hay fomas de proteger nuestro codigo. Bueno aclarado algunos aspectos continuemos.

Vamos a agregar el menú administrador y el menú salir como en la imagen anterior.

Agregamos 2 labels al label 1 cambiamos su propiedad text y ponemos "Usuario:" y al label 2 cambiamos su propiedad name y ponemos lblUsuario esto servirá para mostrar el usuario activo de nuestra aplicacion, como dije en un capitulo anterior el tamaño los colores y el tipo de letra les dejo para que cada uno lo haga a su gusto yo en lo particular voy a cambiar tamaños de formularios para poder mostrar en las imágenes.

22
Hacemos doble click en el menú salir para generar su evento y escribimos "Application.Exit();" como esta es la pantalla principal de nuestra aplicacion el menu salir nos debe sacar y cerrar por completo nuestra aplicacion. El codigo deberia quedar asi:

private void salirToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

Aquí nos vamos a detener un poco para explicar mas en detalle que estamos haciendo, lo primero en la parte de código del formulario FrmPrincipal declaramos una variable publica del tipo string( que es contenedora de caracteres) para identificar una variable publica de una variable local yo uso el guion bajo antes de la descripción esto no es obligatorio solo como buena costumbre para luego cuando las lineas de código sean muy grandes es útil para identificarlas. Cual es la diferencia entre variables publicas y variable locales es el alcance de estas hay otros tipos de variables les recomiendo leer alcances de variable, como decía el alcance de una variable, esto quiere decir desde donde se la va a llamar para usarla pueden ir por ejemplo solo dentro de un método, de una clase o como en el caso que muestro en la imagen se la va a usar desde otra clase por eso la declare publica, prestemos atención a la imagen que hacemos primero la declaramos publica, definimos el tipo string y le asignamos un nombre _Usuario en el FrmPrincipal porque aquí la vamos a usar luego en el formulario login cuando comprueba el usuario y antes de cargar el formulario menu le damos un valor en este caso le decimos que se le asigne lo que contenga el txtUsuario, entonces la variable cuando cargue el formulario ya tendra un valor que sera el nombre de usuario que se escribió en la caja de texto usuario.

Y ahora solo nos resta llevar el valor de esa variable a la propiedad text del lblUsuario para mostrar que usuario es el que esta activo bueno eso es una parte ya veremos mas adelante para que mas vamos a usar esa variable publica.

Y como podemos observar luego de ingresar en el login establecemos que usuario esta activo en nuestra aplicacion.
Muy bien ahora Vamos a crear una tabla llamada "Permisos" esta tabla contendrá los menús de nuestra aplicacion y definirá el estado de permisos a nuestros usuarios

Le definimos un campo Id del tipo int (integer) un campo usuario del tipo nvchar(50) y el menú administrar que sera de tipo bit (verdadero y falso) como vamos a agregar los menús de la opción administrar lo pueden hacer como lo hago yo pero tengan en cuenta mas adelante cuando se agreguen mas menus es importante definirlos bien para que no nos confundamos.

Agregamos los submenús crearusuario, cambioclave y permisos todos del tipo bit y como vemos definimos que son submenús y pertenecen al menú administrar como vemos si lo mantenemos bien definidos y ordenados nos va a evitar muchos dolores de cabezas cuando sean muchos mas.

Establecemos el campo id como clave principal y le decimos que sea auto_increment, esto lo explique en capítulos anteriores así que no voy a detallar. Grabamos y le ponemos como nombre "Permisos" listo ya tenemos la tabla que necesitamos.

Y por ultimo vamos a establecer los permisos del usuario "Admin" ustedes pueden usar administrador root o lo que quieran, pero como este usuario es el mandamás de la aplicacion los permisos lo vamos a establecer en la base de datos ya que no se podrá modificar desde nuestra aplicacion para evitar que se modifiquen los accesos ya veremos mas adelante de que hablamos y todos los menús deben estar en verdadero. Bueno una vez creada la tabla en la base volvemos al visual studio.

Si estamos siguiendo los capítulos del tutorial ya había explicado el modelo de base de datos de entity framework, entonces hacemos doble click en model1.edmx click con el botón derecho del mouse y elegimos actualizar desde la base de datos, nos aparecerá la nueva tabla creada que es la tabla permisos la seleccionamos y hacemos click en finalizar como vemos en nuestro entity data model ahora también nos aparece la tabla recién creada en sql y ya estamos listos para usarla.

Bien vamos a agregar un formulario nuevo que sera el encargado de crear los usuarios lo llamaremos FrmCrearUsuarios.

Agregamos 2 label, 2 textbox, y 2 botones como en la imagen detallo a continuación las propiedades de cada control como ya vimos como hacer esto de ahora en mas solo voy a dejar como definir las propiedades de cada control, entonces al label1 en su propiedad text ponemos "Usuario:", al label2 también en su propiedad text ponemos "Contraseña:" , al textbox1 en su propiedad name ponemos "txtUsuario", al textbox2 en su propiedad name ponemos txtContraseña, al button1 su propiedad name "btnGrabar" y su propiedad text "Grabar", y al button2 su propiedad name "btnCancelar" y su propiedad text "Cancelar" y al FrmCrearUsuario a la propiedad text ponemos "Crear Usuario" y a su propiedad startposition elegimos centerscreen.

Muy bien volvemos al formulario principal hacemos doble click en el menú crear usuario y nos dirige al evento click del menú, como no me gusta mucho escribir directamente en el evento creo un método que le llamo FormCrearUsuario y dentro de ese método escribo el codigo para abrir el formulario, luego desde el evento llamo al metodo, esto es una practica mia si no la quieren seguir igual sirve el codigo directo, otra cosa como se ve en la imagen utilizo showDialog en lugar de show esto es para abrir formularios y cuadros de diálogos modales y no modales, breve explicación cuando un formulario o cuadro de dialogo es modal mantiene el foco en si mismo, esto quiere decir que no se puede cambiar a otro formulario de nuestra aplicacion sin antes cerrar el formulario modal o el cuadro de dialogo, lo que a mi particularmente me gusta para llevar control y obligar al usuario a usar y cerrar detesto ver mil ventanas abiertas de una aplicacion, pero como dije es gusto particular, veamos un ejemplo.

Nos vamos a la pestaña código de FrmCreaUsuario ya vimos esto pero por las dudas hacen doble click en FrmCrearUsuario y le abre la pestaña diseño que es la parte gráfica del formulario aprietan F7 y los pasa a la parte del código.

Creamos la entidad mibase como hicimos en el formulario login esto lo vamos a hacer cada vez que usemos la base de datos ya sea para ver, grabar, actualizar o borrar en cada formulario que lo requiera. (Nota: me gustaria hacer las imágenes mas extensas pero como estoy trabajando en una netbook cuando mas tiempo dura la grabación mas pesada se me pone la maquina asi que perdon por tantas images).

Creamos un Método que llamamos GrabarUsuario, declaramos la variable usu que es de la clase tutorial usuario y que contiene la tabla usuarios.

Ahora le decimos que usu.NombreU que es el campo NombreU de la tabla usuarios sea igual al contenido del txtUsuario.text, lo mismo para usu.Password=txtContraseña.text.

Acto seguido decimos que la entidad mibase.usuarios.add(usu); lo que hace es agregar con add a mibase usuario los valores de usu que cargamos recién con los valores de los textbox y después solo nos queda grabar con mibase.savechanges();.Listo por ahora dejamos este método que ya lo vamos a llamar pero tenemos que hacer algunos pasos antes.

Vamos a crear otro método igual al anterior pero para grabar sobre la tabla permisos.

establecemos perm.usuario=txtUsuario.text y perm.MenuAdministrar=false

perm.SubMenuCrearUsuario=false, perm.SubMenuCambioClave=false y perm.SubMenuPermisos=false

Bueno en este método se darán cuenta lo que hacemos en la tabla permisos agregamos un usuario nuevo luego establecemos que los campos menu estén en false todos, también vamos a dejar este metodo ya lo vamos a usar enseguida,

Creamos otro método llamado VerificarUsuarioRepetido dejo el codigo aqui

private void VerificaUsuarioRepetido()
        {
            var existe = mibase.Usuarios.Any(x => x.NombreU == txtUsuario.Text);

            if (existe)
            {
                MessageBox.Show("El nombre de usuario ya esta en uso");
            }
            else
            {
                GrabarUsuario();
                GrabarPermisos();
                MessageBox.Show("El Usuario se creo exitosamente");
                this.Close();
            }
        }

Este método buscara que no exista otro usuario con el mismo nombre caso contrario grabara normalmente un usuario nuevo.

Volvemos a la pestaña diseño seleccionamos el botón grabar le hacemos doble click para que nos cree el evento y copiamos esta rutina como ven y ya voy a dejar el codigo, esta rutina verifica que los textbox no estén vacíos, si todo esta bien continua y llama al método VerificarUsuarioRepetido que hicimos recién, como ven es secuencial en el formulario creamos 2 métodos el método de usuario graba en la tabla usuarios nombre de usuario y su contraseña y el segundo método graba en la tabla permisos un usuario nuevo y establece los menús en false a estos 2 método los pusimos dentro del método que verifica que no este repetido luego desde el evento click del boton que también es un método primero verificamos que las caja de texto no esten vacias y comienza la secuencia.
Código -->
private void btnGrabar_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtUsuario.Text) || (string.IsNullOrEmpty(txtContraseña.Text)))
            {

                MessageBox.Show("Los datos no pueden estar vacíos");

                return;

            }
            VerificaUsuarioRepetido();
        }

Y por ultimo creamos el evento del boton cancelar para que salga de la pantalla, este capitulo va a ser extenso porque para que se entienda y se pruebe bien todo tiene que estar completo así que paciencia y continuemos por ahora el formulario crear usuario esta terminado pero no lo vamos a probar todavía.

Agregamos un nuevo formulario llamado FrmPermisos.

Vamos a dejar el formulario como se muestra en la imagen agregando un label, un combobox, un button, un groupbox que se encuentra en la barra de herramientas en la parte contenedores y cuatro checkbox y establecemos las propiedades
FrmPermisos ---text=Permisos del Sistema
frmPermisos ---StarPosition=CenterScreen
label1 --- text= Usuarios:
combobox --- name=cmbUsuarios
combobox --- dropdownstyle=DropDownList
button --- name=btnCargar
button ---text=Cargar
GroupBox---name=groupAdministrar
GroupBox---text=Menu Administrar
dentro del groupbox vamos a poner los checkbox
checkbox1 --- name=chkAdministrar
checkbox1 ---text=Administrar
checkbox2 ---name=chkCambioClave
checkbox2---text=Cambio Clave
checkbox3 ---name=chkCrearUsuario
checkbox3 ---text=Crear Usuario
checkbox4 ---name=chkPermisos
checkbox4 ---text=Permisos
una vez establecidas las propiedades de cada control presionamos F7 y pasamos a la pestaña código del formulario.

Como ya dijimos antes declaramos la entidad del modelo

Creamos un Método CargarUsuarios.

Creamos una variable usu y la cargamos con la lista de la tabla usuarios.

Establecemos el datasource del combo Usuarios con la variable usu.

Y le decimos al cmbUsuarios.DisplayMember="NombreU" o sea que muestre el valor del campo NombreU, pero como la tabla tiene un campo Id que es la clave principal entonces decimos que cmbUsuarios.ValueMember="Id" o sea que busque el Id de la tabla pero que muestre el nombre.

Vamos a la pestaña diseño hacemos doble click en el formulario y nos creara el evento load del formulario este evento es cuando carga el formulario, y llamamos el metodo cargausuarios lo que hará es llenar el combo con el listado de usuarios que estén cargados en la tabla.

Creamos un método llamado CompruebaPermisos.

Declaramos una nueva entidad para ser usada en el método y luego declaramos un variable query puede ser cualquier nombre por costumbre yo uso query y vemos la ventaja de usar LINQ ya que hacemos la consulta sql de forma integrada al lenguaje diciendo que query sea igual a una variable que le puse p puede ser también cualquier nombre que contenga mibase.permisos o sea por el momento query es igual a p y p es igual al contenido de la tabla permisos que esta dentro del modelo por eso mibase.permisos

Completando la consulta decimos where(donde) p.usuario sea igual a el contenido del combobox que quedaría where p.usuario == cmbUsuario.Tex , para no crear confusión en c# el == es de comparación y el = de asignación, entonces si A=1 estamos asignando el valor 1 a la variable A y si decimos A == 1 entonces estamos comparando que la variable A valgo 1, por ultimo decimos select p y cerramos con el punto y coma la consulta, como resultado final la variable query seria el resultado de buscar en la tabla permisos en el campo usuario lo que contenga el texto del combobox

Muy bien ahora hacemos un foreach (La estructura repetitiva foreach es utilizada para recorrer colecciones de datos).  En nuestro caso ya seleccionamos el usuario en la tabla permisos (Permisos p in query) entonces ahora vamos a recorrer los campos menús de la tabla de ese usuario seleccionado.

Y dentro del bucle foreach usamos la propiedad checked de los checkbox esta propiedad admite verdadero o falso, entonces le decimos que asigne el valor que contenga el campo que en nuestro caso seria chkAdministrar.checked=p.MenuAdministar, si el campo MenuAdministar de la tabla permisos esta en true(verdadero) el chkAministrar aparecerá marcado, hacemos lo mismo para cada checkbox.Ya saben ustedes pueden agregar mas campos menús y el procedimiento es igual para todos.

Y terminamos de asignar los checkbox a los valores que contiene la tabla. Aclaración en la imagen anterior a esta pueden observar que esta subrayado con rojo esto indica errores en el código, visual studio analiza la codificación y verifica sin necesidad de depurar si algo no esta bien. Aqui lo que paso es que me olvide en la tabla permisos cuando la creamos es destildar en modo diseño la opción aceptar valores nulos, entonces abren sql buscan la base de datos tutorial y dentro de esta la tabla Permisos la abren en modo diseño "esto ya la vimos así que solo les voy a decir que hacer" y destildan la opcion "Permitir valores NULL" a todos los campos de esta tabla, una vez hecho esto hacemos en visual studio doble click en Model1.edmx para abrir el modelo de base de datos actualizamos y listo se corrige el error. (Nota cada vez que cambiemos algo en nuestra base de datos es obligatorio actualizar el model para reflejar esos cambios).

Ahora vamos a crear un método CompruebaUsuario esta rutina la usaremos para controlar que no se pueda modificar los menús del usuario Admin.

Hacemos un if preguntando si el texto del combobox usuario es igual a "Admin" que en nuestro caso es el usuario administrador, ya saben si cambia el nombre de usuario admin también lo hacen aquí.

La estructura condicional if como su nombre lo indica comprueba una condición en este caso la condición es SI, entonces seria si cmbUsuarios.text == "Admin", si el texto del combobox es igual a "Admin" entonces entre las primeras llaves las instrucciones que escribimos si es verdadera la condición, en este caso mandamos un mensaje al usuario de la aplicacion lo hacemos con "MessageBox.Show("Aquí escribimos el mensaje que queremos mostrar");

Pero que pasa si la condición no es verdadera o sea el texto del combobox no es igual a "Admin" y necesitamos seguir escribiendo instrucciones entonces usamos "else". En resumen hacemos una comprobación si es igual mandamos un mensaje y si no es igual llamamos al método para que compruebe los permisos.

Creamos otro método llamado GrabaPermisos porque esta pantalla ademas de mostrar el estado de los menús también debe tener opción de modificar los mismos.

Este método es similar a CompruebaPermisos así que como en la imagen hacemos todo igual al anterior ya voy a mostrar las diferencias.

Notaran que el cambio radica en que se invirtió en el primer método asignamos el valor del campo de la tabla al checkbox , ahora asignamos el valor del checkbox al campo de la tabla permisos. Esto es porque el primer método debe mostrarnos en pantalla los estados de los menús y este método grabara en la tabla lo que asignemos por medio de los checkbox. Tranquilos ya vamos a probar todo y las cosas empezaran a tomar sentido.

Entonces después de establecer los permisos debemos grabar y usamos mibase.savechanges(); Importante que saquemos el savechanges del foreach puesto que como es un bucle repetitivo si lo dejamos dentro intentara grabar mientras el bucle esta en ejecución y no dará error. Posterior seleccionamos la linea "mibase.savechanges(); hacemos click con el botón derecho del mouse y buscamos delimitar con:, del menú desplegable seleccionamos "try" veremos como nos agrega unas lineas de código. El try catch sirve para interceptar errores de nuestra aplicacion en este caso vamos a comprobar que cuando grabemos no se produzca ningún error, aparte de interceptar los errores nos permitirá continuar con la aplicacion, puesto que se hubiere algún error nos mostrara una excepción y nos sacara de nuestra aplicacion con el try catch evitamos eso.

Una vez declarado el try catch si todo anda bien mostramos un mensaje diciendo que todo se grabo sin problemas,  caso contrario en el catch declaramos una variable "e" que valdra las excepciones del error y mostramos en un mensaje cual es el error llamando a la variable e y a su propiedad  mesage.(NOTA: como es un tutorial no siempre uso el try pero la verdad es muy importante interceptar los errores que puedan sacarnos de nuestra aplicacion, asi que como consejo siempre que graben en una base de datos deben usarlo o cualquier otra rutina que pueda generarnos problemas).

Volvemos a la pestaña diseño agregamos dos button con estas propiedades
button1 ---Name=btnGrabar
button1 ---Text=Grabar
button2 ---Name=btnSalir
button ---Text=Salir

Ahora desde la pestaña diseño seleccionamos uno por uno los button le hacemos doble click y creamos los respectivos eventos.

Y en cada evento llamamos a un método y al botón salir simplemente le decimos que cierre la pantalla.

Volvemos a la pantalla principal creamos el evento del menú permisos, creamos el metodo para abrir el formulario.

Y agregamos el método al evento para poder abrir la pantalla permisos. Bueno terminamos con esta pantalla continuemos.

Agregamos otro formulario que llamaremos FrmCambioClave (Dije que haríamos el menú administrador completo así al final probamos todo, tengamos un poco de paciencia. A estas altura ya deben saber cambiar propiedades asi que pongan como titulo del formulario "Cambio de Clave" y como siempre la posición de inicio sera centrada.

Agregamos 3 labels, 3 textbox y 2 button, como en la imagen las propiedades "Text" ya a esta altura la deben saber hacer por ustedes mismos, solo deben dejar los controles como en la imagen y a las propiedades name de los 3 textbox ponemos: txtusuario, txtContraseñaAnterior y txtContraseñaNueva y a los button escribimos: btnAceptar y btnCancelar. Bien una vez terminado seleccionamos el txtUsuario y buscamos su propiedad "Enabled" veran que esta en true (verdadero) y lo cambiamos por false (falso) y listo.

En el formulario cambio clave creamos la entidad y una variable publica (Nota: a medida que avanza el tutorial voy a ahorrar escritura explicando ya que muchas cosas la vimos y las explique)

Y en el formulario principal creamos el evento del menú creamos un método para abrirlo y en ese mismo método cargamos la variable publica.

En el load del formulario asignamos la variable _Usuario al txtUsuario

Creamos el método ActualizaClave tal como esta en la imagen.

Creamos otro metodo llamado VerificaUsuario como en la imagen.

Creamos el evento del botón aceptar.

Dentro del evento click del botón aceptar escribimos esto.

Y en el evento del botón cancelar solo damos la instrucciones para cerrar el formulario.

En el formulario principal creamos el evento cambio de usuario, lo hacemos tal como esta la imagen.

En el formulario principal creamos un método PermisosMenu este método se encargara de leer los permisos de los distintos menús.

Copiamos tal como esta en la imagen y como ven la rutina lo que hace es verificar en la base de datos el estado (Verdadero o falso) y en las propiedades "Enabled y Visible" de cada menú lo activa o desactiva según sea el caso.

Solo nos resta llamar el método PermisosMenu desde el load del formulario principal que se ejecuta justo después de la pantalla login verifica el usuario y sus permisos.

Bueno con esto terminamos ahora probamos todo, se hizo extenso pero como dije este menús involucra varios formularios y si hacia uno por uno no se entendería bien el concepto.

Ejecutamos la aplicacion después de la pantalla login ingresamos al sistema como estamos con el usuario admin este no tiene rectricciones, seleccionamos crear usuario.

Creamos el usuario nuevo llamado prueba y la contraseña igual aquí nos olvidamos de poner asteriscos en el textbox contraseña y como ya lo vimos a eso se los dejo como tarea grabamos y salimos.

Una vez creado el usuario prueba vamos a la pantalla permisos vemos que no tiene ningun menu habilitado como habíamos hecho cada vez que se creaba un usuario todo los menús deshabilitados.

Le asignamos permisos par el menú administrar y cambio de clave.

Cambiamos el usuario por prueba y vemos como no tiene acceso a permisos ni crea usuarios.

Por ultimo la pantalla cambio de clave que deja cambiar solo al usuario activo. Bueno quedaron caja de textos para poner asteriscos y probar que hace con el usuario admin o cuando están vacías las caja de texto todo eso se los dejo para que ustedes prueben y muchas rutinas de aquí se las puede aplicar o moldear según la necesidades de cada uno aunque este capitulo fue extenso pudieron ver que con LINQ se reduce mucho la codificación espero que les sea de utilidad y hasta el próximo capitulo.