Skip to main content

Libro JEE7 05. Login y Seguridad

Libro JEE7 05. Login y Seguridad
  • ROLES
  • CREAR CDI BEANS para administrar los roles
  • CREAR CDI RolAdministrador
  • CREAR CDI ValidadorRoles
  • CREAR CDI LoginBean
  • Codigo completo de LoginBean.java
  • EDITAR LA PAGINA index.xhtml
  • EDITAR LA PAGINA menu.xhtml
  • CREAR LA PÁGINA accesodenegado.xhtml
  • EDITAR LA PÁGINA estatusinsert.xhtml
Puedes descargar los capítulos en formato pdf desde aquí
https://www.dropbox.com/sh/yzivtufjce1h57g/AAAJzegPVBxFtiqzEOlIAdsoa?dl=0



En este capítulo mostraremos cómo crear el formulario de login y realizar las validaciones necesarias de los privilegios.
También colocaremos los formularios en un diálogo visible.









ROLES



Para validar los roles de usuarios tenemos varias alternativas, en esta ocasión lo controlaremos desde CDI Beans.
Crearemos un CDI Beans llamado MenuBeans que contendrá las opciones del menú y los privilegios que tiene el usuario en cada opción.


  • Desde menú File, seleccione New
  • en Categories, seleccione Java Server Faces
  • en File Types, seleccione JSF ManagedBeans
  • Class Name:  MenuBeans
  • Package com.avbravo.scrumweb.generales
  • Scope: Session


Recordar cambiar las anotaciones y los imports.
Si observamos el menú, contamos con la opción Registros y dentro de ella Estatus con dos menuitems, Insertar, Listar.
Definiremos atributos booleanos para los diversos componentes.

Definiremos:
  • Los elementos de la barra con el formato: barraNombre
    • private Boolean barraRegistros = false;
  • Los menú con el formato: nombreMenu
    • private Boolean estatusMenu = false;
  • Los submenu con el formato: nombreOperacion
    • private Boolean estatusCrear = false;


Generamos los get/set mendiante , clic derecho en el código y seleccionar  Insert CodeGetters and Setterts
Nota:
El código generado como son atributos booleanos se generan los métodos is, en nuestro CDI Beans debemos cambiarlo a get para utilizarlo dentro de nuestras páginas java server faces.


 public Boolean isBarraRegistros() {
       return barraRegistros;
   }


   public void setBarraRegistros(Boolean barraRegistros) {
       this.barraRegistros = barraRegistros;
   }


Cambiamos is por get, los métodos set quedan iguales no se modifican.


public Boolean getBarraRegistros() {
       return barraRegistros;
   }


   public void setBarraRegistros(Boolean barraRegistros) {
       this.barraRegistros = barraRegistros;
   }








Codigo completo  de MenuBeans.java


import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.inject.Named;


/**
*
* @author avbravo
*/
@Named
@SessionScoped
public class MenuBeans implements Serializable {


   private static final long serialVersionUID = 1L;


   /*
    * barra de menu
    */
   private Boolean barraRegistros = false;
   /*   
    */
   private Boolean estatusMenu = false;
   private Boolean estatusCrear = false;
   private Boolean estatusConsultar = false;
   private Boolean estatusEditar = false;
   private Boolean estatusListar = false;
   private Boolean estatusEliminar = false;

//Crear el método habilitarTodo(Boolean activo), que recibi un parámetro de tipo //booleano y que será asignado a los todos los atributos del CDI Beans.

public void habilitarTodo(Boolean activo) {
       /*
        barra
        */
       barraRegistros = activo;


       estatusMenu = activo;
       estatusCrear = activo;
       estatusConsultar = activo;
       estatusEditar = activo;
       estatusListar = activo;
       estatusEliminar = activo;
   }


public Boolean getBarraRegistros() {
       return barraRegistros;
   }


   public void setBarraRegistros(Boolean barraRegistros) {
       this.barraRegistros = barraRegistros;
   }


   public Boolean getEstatusMenu() {
       return estatusMenu;
   }


   public void setEstatusMenu(Boolean estatusMenu) {
       this.estatusMenu = estatusMenu;
   }


   public Boolean getEstatusCrear() {
       return estatusCrear;
   }


   public void setEstatusCrear(Boolean estatusCrear) {
       this.estatusCrear = estatusCrear;
   }


   public Boolean getEstatusConsultar() {
       return estatusConsultar;
   }


   public void setEstatusConsultar(Boolean estatusConsultar) {
       this.estatusConsultar = estatusConsultar;
   }


   public Boolean getEstatusEditar() {
       return estatusEditar;
   }
   public void setEstatusEditar(Boolean estatusEditar) {
       this.estatusEditar = estatusEditar;
   }
   public Boolean getEstatusListar() {
       return estatusListar;
   }


   public void setEstatusListar(Boolean estatusListar) {
       this.estatusListar = estatusListar;
   }


   public Boolean getEstatusEliminar() {
       return estatusEliminar;
   }


   public void setEstatusEliminar(Boolean estatusEliminar) {
       this.estatusEliminar = estatusEliminar;
   }


}






















       

CREAR CDI BEANS para administrar los roles

Pasos:
Crearemos un CDI Beans para cada rol, donde indicaremos los privilegios que tiene en base a su rol, y el CDI Beans ValidadorRoles, a continuación mostraremos la imagen de como seria nuestro paquete con los CDI Beans, si observamos existe un CDI para cada rol.

CREAR  CDI RolAdministrador



  • Desde menú File, seleccione New
  • en Categories, seleccione Java Server Faces
  • en File Types, seleccione JSF ManagedBeans
  • Class Name: RolAdministrador
  • Package com.avbravo.scrumweb.roles
  • Scope: request


Inyectamos MenuBeans
 @Inject
   MenuBeans menuBeans;


y creamos el método activar(), donde asignamos valores de true a los atributos correspondientes a los roles, si deseamos que el usuario no tenga acceso a una opción simplemente asignamos un valor de false.


 public void activar() {
       menuBeans.setBarraRegistros(true);
       menuBeans.setEstatusMenu(true);
       menuBeans.setEstatusCrear(true);
       menuBeans.setEstatusConsultar(true);
       menuBeans.setEstatusEditar(true);
       menuBeans.setEstatusListar(true);
       menuBeans.setEstatusEliminar(true);
   }






Código completo  de RolAdministrador.java
import com.avbravo.scrumweb.generales.MenuBeans;
import java.io.Serializable;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;


/**
*
* @author avbravo
*/
@Named
@RequestScoped


public class RolAdministrador {


   @Inject
   MenuBeans menuBeans;


   /**
    * Creates a new instance of RolAdministrador
    */
   public RolAdministrador() {
   }
   public void activar() {
       menuBeans.setBarraRegistros(true);
       menuBeans.setEstatusMenu(true);
       menuBeans.setEstatusCrear(true);
       menuBeans.setEstatusConsultar(true);
       menuBeans.setEstatusEditar(true);
       menuBeans.setEstatusListar(true);
       menuBeans.setEstatusEliminar(true);
   }
}

De la misma forma creamos los CDI Beans RolDuenoProducto y en el método activar de cada uno de ellos establecemos los privilegios para acceder o no cada opción.


CREAR  CDI ValidadorRoles



  • Desde menú File, seleccione New
  • en Categories, seleccione Java Server Faces
  • en File Types, seleccione JSF ManagedBeans
  • Class Name: ValidadorRoles
  • Package com.avbravo.scrumweb.roles
  • Scope: request


Pasos:
  1. Inyectamos los CDI Beans de roles
  2. Inyectamos MenuBeans
  3. Crear un método validarRoles(String rolvalidacion), que recivira un parámetro que indica el rol y este será validado llamando al método activar(), del CDI Beans correspondiente.
  4. Si no existe un rol especifico se desactivara todos las opciones de los menu, invocando a menuBeans.habilitarTodo(false);


Código completo  de ValidadorRoles.java


import com.avbravo.scrumweb.generales.JSFUtil;
import com.avbravo.scrumweb.generales.MenuBeans;
import com.avbravo.scrumweb.generales.ResourcesFiles;
import java.io.Serializable;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;


/**
*
* @author avbravo
*/
@Named
@RequestScoped
public class ValidadorRoles {
@Inject
RolAdministrador rolAdministrador;
@Inject
RolDuenoProducto rolDuenoProducto;


   @Inject
   MenuBeans menuBeans;
   @Inject
   ResourcesFiles rf;


   /**
    * Creates a new instance of ValidadorRoles
    */
   public ValidadorRoles() {
   }


   public Boolean validarRoles(String rolvalidacion) {
       Boolean ok = Boolean.TRUE;


       try {
           switch (rolvalidacion) {
               case "administrador":


                   rolAdministrador.activar();
                   break;
               case "product owner":


                   rolDuenoProducto.activar();
                   break;
             
               default:
                   menuBeans.habilitarTodo(false);
                   ok = Boolean.FALSE;
                   JSFUtil.warningDialog(rf.getMensajeArb("warning.title"), rf.getMensajeArb("info.sinrolasignado"));
                  
           }
       } catch (Exception e) {
           JSFUtil.addErrorMessage("validarRoles() " + e.getLocalizedMessage());
       }
       return ok;
   }


}





CREAR  CDI LoginBean



  • Desde menú File, seleccione New
  • en Categories, seleccione Java Server Faces
  • en File Types, seleccione JSF ManagedBeans
  • Class Name: LoginBean
  • Package com.avbravo.scrumweb.generales
  • Scope: Session


Pasos:
  1. Inyectamos Usuarios, UsuariosFacade,ResourcesFiles, MenuBeans,ValidadorRoles
  2. Crear metodos get/set para el Entity Usuarios.
  3. Crear atributo Boolean logeado y los    @Inject
  4.    RolAdministrador rolAdministrador;
  5.    @Inject
  6.    RolDuenoProducto rolDuenoProducto;
  7. métodos set/get. Recordar cambiar el método is por get.
  8. Crear el método verificarLogin(), en este método se validará el username y password del usuario y el rol que tiene el mismo dentro de la aplicación.
  9. Crear metodo logout()
  10. Crear método init()


Codigo completo  de LoginBean.java

import com.avbravo.scrumweb.Usuarios;
import com.avbravo.scrumweb.ejb.UsuariosFacade;
import com.avbravo.scrumweb.roles.ValidadorRoles;
import java.io.IOException;
import java.io.Serializable;
import javax.annotation.PostConstruct;
import javax.enterprise.context.SessionScoped;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpSession;


@Named
@SessionScoped
public class LoginBean implements Serializable {


private static final long serialVersionUID = 1L;
   @Inject
   UsuariosFacade usuariosFacade;
   Usuarios usuarios = new Usuarios();
   @Inject
   ResourcesFiles rf;
   @Inject
   MenuBeans menuBeans;
   @Inject
   ValidadorRoles validadorRoles;


   Boolean logeado = false;
   /**
    * Creates a new instance of LoginBean
    */
    public Usuarios getUsuarios() {
       return usuarios;
   }


   public void setUsuarios(Usuarios usuarios) {
       this.usuarios = usuarios;
   }


   public Boolean getLogeado() {
       return logeado;
   }


   public void setLogeado(Boolean logeado) {
       this.logeado = logeado;
   }


   @PostConstruct
   public void init() {
   }


   public LoginBean() {
   }
   
   public String verificarLogin() {
       try {
           menuBeans.habilitarTodo(false);
           setLogeado(Boolean.FALSE);
           Usuarios u = usuariosFacade.find(usuarios.getUsername());


           if (u == null) {
               JSFUtil.addWarningMessage(rf.getMensajeArb("login.usernamenotvalid"));
               return null;
           }
           if (!u.getActivo().equals("si")) {
               JSFUtil.addSuccessMessage(rf.getMensajeArb("login.inactive"));
               return "";
           }
           if (!u.getPassword().equals(usuarios.getPassword())) {
               JSFUtil.addSuccessMessage(rf.getMensajeArb("login.passwordnotvalid"));
               return "";
           }
           usuarios = u;
           setLogeado(Boolean.TRUE);


           if (validadorRoles.validarRoles(usuarios.getIdgruposusuario().getIdgruposusuario())) {


               return "";
           }


       } catch (Exception e) {
           JSFUtil.addErrorMessage(e, "verificarLogin()");
       }


       return null;
   }


   public String logout() {
       try {


           HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
           if (session != null) {
               session.invalidate();
           }
String url = "/scrumweb/faces/index.xhtml?faces-redirect=true";
           FacesContext fc = FacesContext.getCurrentInstance();
           ExternalContext ec = fc.getExternalContext();
           try {
               ec.redirect(url);
           } catch (IOException ex) {
               JSFUtil.addErrorMessage(ex.getLocalizedMessage());
           }
return "/scrumweb/faces/index.xhtml?faces-redirect=true";
       } catch (Exception e) {
           JSFUtil.addErrorMessage(e, "logout()");
       }
       return null;
   }


   public String irLogin() {
       return "/index";
   }


   public void irInicio() {
       FacesContext ctx = FacesContext.getCurrentInstance();
       ExternalContext extContext = ctx.getExternalContext();


       String url = extContext.encodeActionURL(ctx.getApplication().getViewHandler().getActionURL(ctx, "/index.xhtml"));


       try {
           extContext.redirect(url);
       } catch (IOException ioe) {
           JSFUtil.addErrorMessage(ioe.getLocalizedMessage().toString());
       }
   }
}














EDITAR LA PAGINA index.xhtml

Colocar las etiquetas para validar el login de usuario.
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:ui="http://xmlns.jcp.org/jsf/facelets"
     xmlns:h="http://xmlns.jcp.org/jsf/html"
     xmlns:p="http://primefaces.org/ui"
     xmlns:f="http://xmlns.jcp.org/jsf/core">


   <body>


       <ui:composition template="./template.xhtml">
           <!--
                       <ui:define name="top">
                           top
                       </ui:define>
           
                       <ui:define name="bottom">
                           bottom
                       </ui:define>
           
                       <ui:define name="left">
                           left
                       </ui:define>
           -->


<ui:define name="center">
               <h:form id="formtopnologeado" rendered="#{!loginBean.logeado}" >
                   <p:growl id="growl" life="1500" />
                   <p:dialog visible="true" header="#{app['application.title']}" closable="false" showEffect="clip" hideEffect="fade" widgetVar="loginDialog">  


                       <h:panelGrid columns="2" >
                           <f:facet name="header">
                               <h:outputLabel  value="#{mensajes['boton.login']}"/>
                           </f:facet>


                           <h:outputText value="#{app['login.username']}"></h:outputText>
                         <h:inputText value="#{loginBean.usuarios.username}"  required="true" />
                        <h:outputText value="#{app['login.password']}"  ></h:outputText>
                           <h:inputSecret value="#{loginBean.usuarios.password}"  required="true" />
                           <f:facet name="footer">
<p:commandButton action="#{loginBean.verificarLogin}" value="#{app['boton.login']}" ajax = "false" />
                           </f:facet>
                       </h:panelGrid>
                   </p:dialog>  
               </h:form>


           </ui:define>
</ui:composition>


   </body>
</html>

























EDITAR LA PAGINA menu.xhtml

Editar las opciones y colocar la validación para activar las opciones en base al valor de los atributos de menuBeans.
Paso:
  1. Colocar la propiedad rendered en el <p:megaMenu> utilizando el atributo logeado de loginBean.
  2. Utilizar rendered en el submenú utilizando barraRegistros
  3. Utilizar el atributo rendered de los <menuitem> utilizando estatusCrear y estatusListar.
el rendered y el atributo de menuBeans correspondientes, para establecer la validación.
  1. Colocar en el menuitem logout  actionListener="#{loginBean.logout}" ajax = "false" rendered="#{loginBean.logeado}"

<h:body>
       <ui:composition>
           <h:form id="menuForm" >
               <p:megaMenu rendered="#{loginBean.logeado}">  
                   <p:submenu label="#{app['menu.records']}" rendered="#{menuBeans.barraRegistros}"  icon="ui-icon-check">  
                       <p:column>                              
      <p:submenu label="#{app['menu.estatus']}" rendered="#{menuBeans.estatusMenu}">  
              <p:menuitem value="#{app['menu.insert']}" rendered="#{menuBeans.estatusCrear}" url="/faces/page/estatus/estatusinsert.xhtml" />  
              <p:menuitem value="#{app['menu.list']}"  rendered="#{menuBeans.estatusListar}" url="/faces/page/estatus/estatuslist.xhtml"/>  
      </p:submenu>  


                       </p:column>  
                   </p:submenu>  
                  <p:menuitem value="#{app['login.logout']}" actionListener="#{loginBean.logout}" title="#{app['login.logout']}" ajax = "false" rendered="#{loginBean.logeado}" icon="ui-icon-power"/>


          







CREAR LA PÁGINA accesodenegado.xhtml

Esta página la usaremos para desplegar un mensaje indicando que el usuario no tiene privilegios para visualizar la página, generalmente ocurre cuando el usuario trata de ingresar el url en el navegador para ingresar a paginas no autorizadas.
Pasos:
  1. Crear el Facelets Template Client
  2. Agregar un dialogo visible
  3. Mostrar un texto
  4. Utilizar un boton para enviarlo a la pagina para logearse.


Ahora creamos un Facelets Template Client
  • Desde menú File, seleccione New
  • en Categories, seleccione Java Server Faces
  • en File Types,  JSF Page
  • En File Name: accesodenegado




Colocamos un diálogo, con un panelGrid donde colocamos una etiqueta y un botón para regresar al index.xhtml.











Código completo  de accesodenegado.xhtml


<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:h="http://xmlns.jcp.org/jsf/html"
     xmlns:ui="http://xmlns.jcp.org/jsf/facelets"
     xmlns:p="http://primefaces.org/ui">


   <h:body>
       <ui:composition>
 
        <p:dialog visible="true" header="#{app['login.accesodenegado']}"  closable="false" showEffect="fade" hideEffect="fade" widgetVar="loginDialog">  
                   <p:panelGrid columns="1" >
                       <h:outputText value="#{app['login.accesodenegadoDetalle']}"/>
                       <p:commandButton action="#{loginBean.irLogin}" value="#{app['boton.return']}" ajax="false"/>
                   </p:panelGrid>
               </p:dialog>
       
       </ui:composition>
  </h:body>
</html>

















EDITAR  LA PÁGINA estatusinsert.xhtml

Estableceremos validación de acceso a nivel de cada página para solo permitir el ingreso al usuario con los privilegios.
Pasos:


  1. Establecer el rendered con la opción de menuBeans en el form principal
<ui:define name="center">
               <f:view>
                   <h:form rendered="#{menuBeans.estatusCrear}">


colocar en comentarios
<!--                            <h1><h:outputText value="#{app['form.estatusnew']}"/></h1>-->


  1. Colocar un dialogo
<p:dialog visible="true" header="#{app['form.estatusnew']}" closable="true" showEffect="clip" hideEffect="fade" widgetVar="estatusinsertDialog">  


cerramos el diálogo después </h:panelGrid>
</p:dialog>


  1. Agregar el include accesodenegado si no se tiene permisos para ingresar al formulario.
antes del </f:view> fuera del form principal.
                
   <h:form rendered="#{!menuBeans.estatusCrear}">
                       <ui:include src="/accesodenegado.xhtml" />
   </h:form>


</f:view>

se mostrará en un diálogo el formulario


Repetimos el proceso para la página estatuslist.xhtml usando el rendered
<h:form id="form" rendered="#{menuBeans.estatusListar}">


Colocamos el datatable en un dialogo.
<p:dialog visible="true" header="#{app['form.estatuslist']}" closable="false" showEffect="clip" hideEffect="fade" widgetVar="estatuslistDialog">  
<p:dataTable id="datatable" paginator="true"
                                        rows="7" value="#{estatusDataController.estatusList}" var="item"
                                        rowKey="#{item.idestatus}"
                                        selectionMode="single"
                                        selection="#{estatusDataController.selected}"
                                        filteredValue="#{estatusDataController.filtered}"
                                        >
   </p:dataTable>
                       </p:dialog>

Agregamos el include con el rendered.
<h:form rendered="#{!menuBeans.estatusListar}">
                       <ui:include src="/accesodenegado.xhtml" />
   </h:form>



Para probarlo podemos pegar en el browser el url


Sin haberse logueado y mostrará el diálogo de acceso denegado, y al presionar el boton Regresar nos lleva a la página index.html donde nos debemos loguear.




De esta manera restringimos el acceso por privilegios a cada página



Comments

Anonymous said…
We're a gaggle of volunteers and starting a new scheme in our community.
Your site provided us with helpful info to work on. You've done a formidable process and our whole neighborhood might be grateful
to you.

Popular posts from this blog

Un ejemplo sencillo de Refactorización y Genericos

Un ejemplo sencillo de Refactorización y Genericos

public class Refactorizador<K, V> {

    public V copyFromBeans(K k, V v) {
        try {
            Class claseK = k.getClass();
            Class claseV = v.getClass();

            Method[] metodosK = claseK.getMethods();

            for (Method method : metodosK) {
                if (isGetter(method)) {
                    Method metodoGetK = claseK.getDeclaredMethod(method.getName());
                    Method metodoSetV = claseV.getDeclaredMethod(changeGetBySet(method.getName()), method.getReturnType());
                    metodoSetV.invoke(v, metodoGetK.invoke(k));
                }

            }

        } catch (Exception e) {
            System.out.println("refactorizador() " + e.getLocalizedMessage());
        }
        return v;
    }

     public  boolean isGetter(Method method) {

        if (!method.getName().startsWith("get")) {
            return false;
        }
        if (method.getName().startsWith("getCla…

Apache NetBeans

Apache NetBeans
https://wiki.apache.org/incubator/NetBeansProposal

Si, algo que se esperaba desde hace muchos años, una liberación de NetBeans, para convertirlo en un IDE más abierto, y que permita mayor contribución de la comunidad y de otras empresas, ya inicio su primera etapa en la incubadora de la Fundación Apache.
Las implicaciones que esto conlleva son múltiples por una parte esta la evolución de NetBeans, al permitir que más contribuyentes puedan aportar a sus mejoras, también garantiza que aquellas instituciones no sientan que es una sola organización la que controla la evolución. A las comunidades les permite sentirse que participan de un proyecto con todas las garantías que ofrece la Fundación Apache.

Muchos pensaran que Oracle esta dejando morir el proyecto, la realidad es diferente, hay muchos ingenieros que están participando del proyecto en la fundación Apache.
Es una noticia excelente para los desarrolladores, instituciones, empresas que utilizan NetBeans , se estima qu…

JGMongo con JEE7 +(Primefaces+MongoDB+GlassFish)

Mostrare un ejemplo básico del uso de JGMongo, (Java Mapper Object para MongoDB), en un entorno JavaEE 7.

Desarrollaremos una simple aplicación maven Java Enterprise Edition, que utiliza la base de datos NoSQL MongoDB, NetBeans como IDE de Desarrollo, Java Server Faces como Framework en conjunto con PrimeFaces. Es un ejemplo muy básico donde se almacena los datos de los países en una colección llama paises La vista final sera la siguiente un formulario para captar los datos

Y una pagina donde se muestran los países almacenados en la base de datos.
Pasos previos: 1. Instalar MongoDB 2. Crear el proyecto Maven 3. Agregar la dependencia al archivo pom.xml   <repositories> <repository>    <id>jitpack.io</id>    <url>https://jitpack.io</url> </repository> </repositories>
    <dependency>    <groupId>com.github.avbravo</groupId>    <artifactId>jgmongo</artifactId>    <version>0.1</version> </dependency&…