LoginController

Realiza la validación de las credenciales del usuario.

Para el registro de acceso utilizamos

//Acceso
     @Inject
    AccessInfoServices accessInfoServices;
    @Inject
    AccessInfoRepository accessInfoRepository;

Agregar los atributos

  @Inject
    ResourcesFiles rf;
    @Inject
    ValidadorRoles validadorRoles;
    Boolean loggedIn = false;
    private String username;
    private String password;
    private String foto;
    private String id;
    private String key;
    String usernameSelected;
    Boolean recoverSession = false;
    Boolean userwasLoged = false;
    Boolean tokenwassend = false;
    String usernameRecover = "";
    String myemail = "@gmail.com";
    String mytoken = "";

Agregar los facade y entity para roles si existen una entidad para roles.

  @Inject
    UsuarioRepository usuarioRepository;
    Usuario usuario = new Usuario();
    @Inject
    RolFacade rolFacade;
    Rol rol = new Rol();

Implementar los metodos

 @PostConstruct
    public void init() {
    }


     @PreDestroy
    public void destroy() {
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="constructor">
    public LoginController() {
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="irLogin">
    public String irLogin() {
        return "/faces/login";
    }


   public String doLogin() {
  }


    private Boolean isUserValid() {
  }

  public String sendToken() {
  }

  public String destroyByUser() {
  }

  public String destroyByToken() {
  }

  public String invalidateCurrentSession() {
   }

   public String doLogout() {
            return logout("/spardjsd/faces/login.xhtml?faces-redirect=true");
    }

    public String changePassword() {
    }
  }

Nota:

El libro Jmoordb explica las implementaciones sobre auditorias.

https://www.gitbook.com/book/avbravo/jmoordb/details

El libro avbravosecurity explica el uso de tokens y sesiones.

https://www.gitbook.com/book/avbravo/avbravosecurity/details

Codigo completo.

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
 * and open the template in the editor.
*/
package com.avbravo.spard.controller;

// <editor-fold defaultstate="collapsed" desc="imports">
import com.avbravo.avbravoutils.JsfUtil;
import com.avbravo.avbravosecurity.SecurityInterface;
import javax.inject.Inject;
import org.primefaces.context.RequestContext;
import com.avbravo.avbravoutils.email.ManagerEmail;
import com.avbravo.ejbjmoordb.services.AccessInfoServices;
import com.avbravo.ejbspard.ejb.AccessInfoRepository;
import com.avbravo.ejbspard.ejb.RolRepository;
import com.avbravo.ejbspard.ejb.UsuarioRepository;
import com.avbravo.ejbspard.entity.Rol;
import com.avbravo.ejbspard.entity.Usuario;
import com.avbravo.spard.roles.ValidadorRoles;
import com.avbravo.spard.util.ResourcesFiles;
import java.util.logging.Logger;
import javax.inject.Named;
import java.io.Serializable;
import java.util.Optional;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.enterprise.context.SessionScoped;
import javax.faces.application.ConfigurableNavigationHandler;
import javax.faces.context.FacesContext;
    // </editor-fold>

/**
 *
 * @authoravbravo
 */
@Named
@SessionScoped
public class LoginController  implements Serializable, SecurityInterface  {
// <editor-fold defaultstate="collapsed" desc="fields">
    private static final long serialVersionUID = 1L;
    private static final Logger LOG = Logger.getLogger(LoginController.class.getName());

    //Acceso
     @Inject
    AccessInfoServices accessInfoServices;
    @Inject
    AccessInfoRepository accessInfoRepository;
    @Inject
    ResourcesFiles rf;
    @Inject
    ValidadorRoles validadorRoles;
    Boolean loggedIn = false;
    private String username;
    private String password;
    private String foto;
    private String id;
    private String key;
    String usernameSelected;
    Boolean recoverSession = false;
    Boolean userwasLoged = false;
    Boolean tokenwassend = false;
    String usernameRecover = "";
    String myemail = "@gmail.com";
    String mytoken = "";
    @Inject
    UsuarioRepository usuarioRepository;
    Usuario usuario = new Usuario();
    @Inject
    RolRepository rolRepository;
    Rol rol = new Rol();
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="getter/setter">
   public String getMyemail() {
        return myemail;
    }
    public void setMyemail(String myemail) {
        this.myemail = myemail;
    }
    public String getId() {
         return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public Usuario getUsuario() {
        return usuario;
    }
    public void setUsuario(Usuario usuario) {
        this.usuario = usuario;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Boolean getLoggedIn() {
        return loggedIn;
     }
    public void setLoggedIn(Boolean loggedIn) {
        this.loggedIn = loggedIn;
    }
    public Boolean getTokenwassend() {
        return tokenwassend;
    }
    public void setTokenwassend(Boolean tokenwassend) {
        this.tokenwassend = tokenwassend;
    }
    public String getMytoken() {
        return mytoken;
    }
    public void setMytoken(String mytoken) {
        this.mytoken = mytoken;
    }
    public String getUsernameSelected() {
        return usernameSelected;
    }
    public void setUsernameSelected(String usernameSelected) {
        this.usernameSelected = usernameSelected;
    }
    public Boolean getUserwasLoged() {
        return userwasLoged;
    }
    public void setUserwasLoged(Boolean userwasLoged) {
        this.userwasLoged = userwasLoged;
    }
    // </editor-fold>

// <editor-fold defaultstate="collapsed" desc="init">
    @PostConstruct
    public void init() {
        loggedIn = false;
        recoverSession = false;
        userwasLoged = false;
        tokenwassend = false;
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="destroy">
    @PreDestroy
    public void destroy() {
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="constructor">
    public LoginController() {
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="irLogin">
    public String irLogin() {
//        return "/faces/login";
        return "/login";
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="doLogin">
    public String doLogin() {
        try {

            tokenwassend = false;
            userwasLoged = false;
            loggedIn = true;
            usuario= new Usuario(); 
            if (username == null || password == null) {
                JsfUtil.warningMessage(rf.getAppMessage("login.usernamenotvalid"));
                return null;
            }
            usernameRecover = usernameRecoveryOfSession();
            recoverSession = !usernameRecover.equals("");
            if (recoverSession) {
                  invalidateCurrentSession();
                  RequestContext.getCurrentInstance().execute("PF('sessionDialog').show();");
                  return "";
            }
          if (recoverSession && usernameRecover.equals(username)) {
            } else {
                if (isUserLogged(username)) {
                    userwasLoged = true;
                    JsfUtil.warningMessage(rf.getAppMessage("login.alreadylogged"));
                    return "";
                }

            }
            if (!isUserValid()) {
                  accessInfoRepository.save(accessInfoServices.generateAccessInfo(username, "login",rf.getAppMessage("login.usernameorpasswordnotvalid")));
                JsfUtil.warningMessage(rf.getAppMessage("login.usernameorpasswordnotvalid")); 
                return " ";

            }
            saveUserInSession(username, 2100);
              accessInfoRepository.save(accessInfoServices.generateAccessInfo(username, "login",rf.getAppMessage("login.welcome") ));
            loggedIn = true;
            foto = "img/me.jpg";
            JsfUtil.successMessage(rf.getAppMessage("login.welcome") + " " + usuario.getNombre());
//            return "/faces/index.xhtml?faces-redirect=true";
   return "/dashboard.xhtml?faces-redirect=true";
        } catch (Exception e) {
            JsfUtil.errorMessage(e, "doLogin()");
        }
        return "";
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="isValid">
    /**
     * verifica si es valido el usuario
     *
     * @return
     */
    private Boolean isUserValid() {
        Boolean isvalid = false;
        try {
            if (username.isEmpty() || username.equals("") || username == null) {
                JsfUtil.successMessage(rf.getAppMessage("warning.usernameisempty"));
                return false;
            }
            if (password.isEmpty() || password.equals("") || password == null) {
                JsfUtil.successMessage(rf.getAppMessage("warning.passwordisempty")); 
                return false;
            }
            usuario.setUsername(username); 
            Optional<Usuario> optional = usuarioRepository.findById(usuario);
            if (!optional.isPresent()) {
                JsfUtil.warningMessage(rf.getAppMessage("login.usernamenotvalid"));
                return false;
            }else{ 
                Usuario u2 = optional.get();
//               usuario = optional.get();
               usuario = u2;
               if (!usuario.getPassword().equals(password)) {
                   JsfUtil.successMessage(rf.getAppMessage("login.passwordnotvalid"));
                   return false;
               }
               if (!validadorRoles.validarRoles(usuario.getRol().getIdrol())) {
                   JsfUtil.successMessage(rf.getAppMessage("login.notienerolenelsistema") + " " + usuario.getRol().getIdrol());
                   return false;
                }
           }
  return true;
 } catch (Exception e) {
            JsfUtil.errorMessage("userValid() " + e.getLocalizedMessage());
        }
        return isvalid;
    }// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="sendToken()"> 
    public String sendToken() {
        try {

//            if(!myemail.equals("emailusuario")){
//                //no es el email del usuario
//            }
            ManagerEmail managerEmail = new ManagerEmail();
            String token = tokenOfUsername(username);
            if (!token.equals("")) {

                String texto = rf.getAppMessage("token.forinitsession")+  " " + token +  rf.getAppMessage("token.forinvalidate ");
                if (managerEmail.send(myemail, rf.getAppMessage("token.tokenofsecurity"), texto, "[e-mail]", "adminpasswordemail"))
{
                    JsfUtil.successMessage(rf.getAppMessage("token.wassendtoemail"));
                    tokenwassend = true;
                } else {
                    JsfUtil.warningMessage(rf.getAppMessage("token.errortosendemail"));
                }
            } else {
                JsfUtil.warningMessage(rf.getAppMessage("token.asiganedtouser"));
            }

        } catch (Exception e) {
            JsfUtil.errorMessage("sendToken() " + e.getLocalizedMessage());
        }
        return "";
    }// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="destroyByUser()"> 
    public String destroyByUser() {
        try {
            if (isUserValid()) {
                userwasLoged = !destroyByUsername(username);
                if (!userwasLoged) {
                    JsfUtil.successMessage(rf.getAppMessage("session.destroyedloginagain"));
                } else {
                    JsfUtil.successMessage(rf.getAppMessage("session.notdestroyed"));
                }
            } else {  
                JsfUtil.warningMessage(rf.getAppMessage("warning.usernotvalid"));
            }
        } catch (Exception e) {
            JsfUtil.errorMessage("destroyByUser() " + e.getLocalizedMessage());
        }
        return "";
    }
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="destroyWithToken()">

    public String destroyByToken() {
        try {
            if (isUserValid()) {
                userwasLoged = !destroyByToken(username, mytoken);

            } else {
                JsfUtil.warningMessage("Los datos del usuario no son validos");
            }
        } catch (Exception e) {
                JsfUtil.warningMessage(rf.getAppMessage("warning.usernotvalid"));
        }
        return "";
    }
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="invalidateCurrentSession"> 

    public String invalidateCurrentSession() {
        try {
            if (invalidateMySession()) {
                JsfUtil.successMessage(rf.getAppMessage("sesion.invalidate"));
            } else {
                JsfUtil.warningMessage(rf.getAppMessage("sesion.errortoinvalidate"));
            }

        } catch (Exception e) {
            JsfUtil.successMessage("invalidateCurrentSession() " + e.getLocalizedMessage());
        }
        return "";
    }// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="doLogout">
    public String doLogout() {
            return logout("/spardjsd/faces/login.xhtml?faces-redirect=true");
    }
    // </editor-fold>
// <editor-fold defaultstate="collapsed" desc="changePassword">
    public String changePassword() {
        try {
            usuarioRepository.update(usuario);
            JsfUtil.successMessage(rf.getAppMessage("info.update"));
        } catch (Exception e) {
            JsfUtil.errorMessage(e.getLocalizedMessage());
        }
        return null;
    }
    // </editor-fold>



}