Init!!

bank-war/src/conf/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

bank-war/src/java/bean/ClienteBean.java

@@ -0,0 +1,209 @@
+package bean;
+
+import beans.ClienteFacadeLocal;
+import beans.UsuarioFacadeLocal;
+import entities.Cliente;
+import entities.CuentaCorriente;
+import entities.TarjetaCredito;
+import entities.TarjetaDebito;
+import entities.Usuario;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.PostConstruct;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+import utils.Passwords;
+
+@Named(value = "clienteBean")
+@SessionScoped
+public class ClienteBean implements Serializable {
+
+  @EJB
+  private ClienteFacadeLocal clienteFacade;
+  @EJB
+  private UsuarioFacadeLocal usuarioFacade;
+
+  private List<Cliente> clienteList;
+  private Cliente cliente;
+  private Usuario usuario;
+
+  @PostConstruct
+  public void init() {
+    this.clienteList = this.clienteFacade.findAll();
+    this.cliente = new Cliente();
+    this.usuario = new Usuario();
+  }
+
+  public String gotoView(Cliente cliente) {
+    this.cliente = cliente;
+    return "admin_cliente_view";
+  }
+
+  public String gotoCreate() {
+    this.resetInnerCliente();
+    return "admin_cliente_create";
+  }
+
+  public String create() {
+    byte[] salt = Passwords.getNextSalt();
+    byte[] hash = Passwords.hash(usuario.getTransientPassword().toCharArray(), salt);
+
+    usuario.setNombre(cliente.getRut());
+    usuario.setPassword(hash);
+    usuario.setSalt(salt);
+    usuario.setRole("Cliente");
+
+    CuentaCorriente cc = new CuentaCorriente();
+    cc.setSaldo(0);
+    cc.setCliente(cliente);
+    cc.setInsertedAt(new Date());
+
+    cliente.getCuentaCorrienteList().add(cc);
+
+    cliente.setUsuario(usuario);
+    usuario.setCliente(cliente);
+
+    usuarioFacade.create(usuario);
+
+    this.clienteList.add(cliente);
+
+    resetInnerCliente();
+
+    return "admin_main";
+  }
+
+  public String gotoUpdate(Cliente cliente) {
+    this.cliente = cliente;
+    this.usuario = cliente.getUsuario();
+
+    return "admin_cliente_edit";
+  }
+
+  public String update() {
+    if (usuario.getTransientPassword() != null) {
+      byte[] salt = Passwords.getNextSalt();
+      byte[] hash = Passwords.hash(usuario.getTransientPassword().toCharArray(), salt);
+
+      usuario.setPassword(hash);
+      usuario.setSalt(salt);
+    }
+
+    usuarioFacade.edit(usuario);
+    clienteFacade.edit(cliente);
+
+    this.resetInnerCliente();
+    return "admin_main";
+  }
+
+  public String gotoDelete(Cliente cliente) {
+    this.cliente = cliente;
+    return "admin_cliente_delete";
+  }
+
+  public String delete() {
+    this.clienteList.remove(cliente);
+
+    usuarioFacade.remove(cliente.getUsuario());
+
+    this.resetInnerCliente();
+
+    return "admin_main";
+  }
+
+  public String gotoContratarCuentaCorriente() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    CuentaCorrienteBean ccb = context.getApplication().evaluateExpressionGet(context, "#{cuentaCorrienteBean}", CuentaCorrienteBean.class);
+    ccb.setCliente(cliente);
+    return "admin_cuenta_corriente_contratar";
+  }
+
+  public String gotoContratarTarjetaCredito() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TarjetaCreditoBean tcb = context.getApplication().evaluateExpressionGet(context, "#{tarjetaCreditoBean}", TarjetaCreditoBean.class);
+    tcb.setCliente(cliente);
+    return "admin_tarjeta_credito_contratar";
+  }
+
+  public String gotoContratarTarjetaDebito() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TarjetaDebitoBean tdb = context.getApplication().evaluateExpressionGet(context, "#{tarjetaDebitoBean}", TarjetaDebitoBean.class);
+    tdb.setCliente(cliente);
+    return "admin_tarjeta_debito_contratar";
+  }
+
+  public String gotoEditTarjetaCredito(TarjetaCredito tarjetaCredito) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TarjetaCreditoBean tcb = context.getApplication().evaluateExpressionGet(context, "#{tarjetaCreditoBean}", TarjetaCreditoBean.class);
+    tcb.setCliente(cliente);
+    tcb.setTarjetaCredito(tarjetaCredito);
+    return "admin_tarjeta_credito_edit";
+  }
+
+  public String gotoViewCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    CuentaCorrienteBean ccb = context.getApplication().evaluateExpressionGet(context, "#{cuentaCorrienteBean}", CuentaCorrienteBean.class);
+    ccb.setCliente(cliente);
+    ccb.setCuentaCorriente(cuentaCorriente);
+    return "cliente_cuenta_corriente_view";
+  }
+
+  public String gotoViewTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TarjetaDebitoBean tdb = context.getApplication().evaluateExpressionGet(context, "#{tarjetaDebitoBean}", TarjetaDebitoBean.class);
+    tdb.setCliente(cliente);
+    tdb.setTarjetaDebito(tarjetaDebito);
+    return "cliente_tarjeta_debito_view";
+  }
+
+  public String gotoViewTarjetaCredito(TarjetaCredito tarjetaCredito) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TarjetaCreditoBean tcb = context.getApplication().evaluateExpressionGet(context, "#{tarjetaCreditoBean}", TarjetaCreditoBean.class);
+    tcb.setCliente(cliente);
+    tcb.setTarjetaCredito(tarjetaCredito);
+    return "cliente_tarjeta_credito_view";
+  }
+  
+  public String gotoAdminViewCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    CuentaCorrienteBean ccb = context.getApplication().evaluateExpressionGet(context, "#{cuentaCorrienteBean}", CuentaCorrienteBean.class);
+    ccb.setCliente(cliente);
+    ccb.setCuentaCorriente(cuentaCorriente);
+    return "admin_cuenta_corriente_view";
+  }
+
+
+  private void resetInnerCliente() {
+    this.cliente = new Cliente();
+    this.usuario = new Usuario();
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////GETTERS Y SETTERS//////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+  public List<Cliente> getClienteList() {
+    return clienteList;
+  }
+
+  public void setClienteList(List<Cliente> clienteList) {
+    this.clienteList = clienteList;
+  }
+
+  public Cliente getCliente() {
+    return cliente;
+  }
+
+  public void setCliente(Cliente cliente) {
+    this.cliente = cliente;
+  }
+
+  public Usuario getUsuario() {
+    return usuario;
+  }
+
+  public void setUsuario(Usuario usuario) {
+    this.usuario = usuario;
+  }
+}

bank-war/src/java/bean/CompraBean.java

@@ -0,0 +1,155 @@
+package bean;
+
+import beans.CompraTarjetaCreditoFacadeLocal;
+import beans.CompraTarjetaDebitoFacadeLocal;
+import beans.TarjetaCreditoFacadeLocal;
+import beans.TarjetaDebitoFacadeLocal;
+import entities.CompraTarjetaCredito;
+import entities.CompraTarjetaDebito;
+import entities.TarjetaCredito;
+import entities.TarjetaDebito;
+import java.io.Serializable;
+import java.util.Date;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.application.FacesMessage;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "compraBean")
+@SessionScoped
+public class CompraBean implements Serializable {
+
+  @EJB
+  private CompraTarjetaCreditoFacadeLocal compraTarjetaCreditoFacade;
+  @EJB
+  private CompraTarjetaDebitoFacadeLocal compraTarjetaDebitoFacade;
+  @EJB
+  private TarjetaDebitoFacadeLocal tarjetaDebitoFacade;
+  @EJB
+  private TarjetaCreditoFacadeLocal tarjetaCreditoFacade;
+
+  private TarjetaDebito tarjetaDebito;
+  private TarjetaCredito tarjetaCredito;
+
+  private int monto;
+  private String comentario;
+  private String clase;
+
+  public String comprar() {
+    if (tarjetaDebito != null) {
+      return comprarTarjetaDebito();
+    } else if (tarjetaCredito != null) {
+      return comprarTarjetaCredito();
+    }
+    return null;
+  }
+
+  public String comprarTarjetaDebito() {
+    CompraTarjetaDebito compra = new CompraTarjetaDebito();
+    compra.setMonto(monto);
+    compra.setComentario(comentario);
+    compra.setInsertedAt(new Date());
+    compra.setTarjetaDebito(tarjetaDebito);
+
+    if (tarjetaDebito.getSaldo() - monto < 0) {
+      FacesContext context = FacesContext.getCurrentInstance();
+      context.addMessage(null, new FacesMessage("La compra sobrepasa el saldo de su tarjeta de debito"));
+      context.validationFailed();
+      return "cliente_tarjeta_debito_compra";
+    }
+    tarjetaDebito.setSaldo(tarjetaDebito.getSaldo() - monto);
+    tarjetaDebito.getCompraList().add(compra);
+    
+    compraTarjetaDebitoFacade.edit(compra);
+    tarjetaDebitoFacade.edit(tarjetaDebito);
+    
+    this.resetInput();
+    return "cliente_tarjeta_debito_view";
+  }
+
+  public String comprarTarjetaCredito() {
+    CompraTarjetaCredito compra = new CompraTarjetaCredito();
+    compra.setMonto(monto);
+    compra.setComentario(comentario);
+    compra.setInsertedAt(new Date());
+    compra.setTarjetaCredito(tarjetaCredito);
+
+    if (clase.equals("Nacional")) {
+      if (tarjetaCredito.getDeudaNacional() + monto > tarjetaCredito.getLimiteNacional()) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("La compra sobrepasa el limite nacional de su cuenta"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_compra";
+      }
+      
+      tarjetaCredito.setDeudaNacional(tarjetaCredito.getDeudaNacional() + monto);
+    } else if (clase.equals("Internacional")) {
+      if (tarjetaCredito.getDeudaInternacional()+ monto > tarjetaCredito.getLimiteInternacional()) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("La compra sobrepasa el limite internacional de su cuenta"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_compra";
+      }
+      tarjetaCredito.setDeudaInternacional(tarjetaCredito.getDeudaInternacional() + monto);
+    }
+
+    tarjetaCredito.getCompraList().add(compra);
+    
+    compraTarjetaCreditoFacade.edit(compra);
+    tarjetaCreditoFacade.edit(tarjetaCredito);
+
+    this.resetInput();
+    return "cliente_tarjeta_credito_view";
+  }
+
+  private void resetInput() {
+    this.monto = 0;
+    this.tarjetaCredito = null;
+    this.tarjetaDebito = null;
+    this.comentario = null;
+  }
+
+  public TarjetaDebito getTarjetaDebito() {
+    return tarjetaDebito;
+  }
+
+  public void setTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    this.tarjetaDebito = tarjetaDebito;
+  }
+
+  public TarjetaCredito getTarjetaCredito() {
+    return tarjetaCredito;
+  }
+
+  public void setTarjetaCredito(TarjetaCredito tarjetaCredito) {
+    this.tarjetaCredito = tarjetaCredito;
+  }
+
+  public int getMonto() {
+    return monto;
+  }
+
+  public void setMonto(int monto) {
+    this.monto = monto;
+  }
+
+  public String getComentario() {
+    return comentario;
+  }
+
+  public void setComentario(String comentario) {
+    this.comentario = comentario;
+  }
+
+  public String getClase() {
+    return clase;
+  }
+
+  public void setClase(String clase) {
+    this.clase = clase;
+  }
+
+  
+  
+}

bank-war/src/java/bean/CuentaCorrienteBean.java

@@ -0,0 +1,89 @@
+package bean;
+
+import beans.ClienteFacadeLocal;
+import beans.CuentaCorrienteFacadeLocal;
+import entities.Cliente;
+import entities.CuentaCorriente;
+import entities.DepositoCuentaCorriente;
+import java.io.Serializable;
+import java.util.Date;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "cuentaCorrienteBean")
+@SessionScoped
+public class CuentaCorrienteBean implements Serializable{
+  @EJB
+  private CuentaCorrienteFacadeLocal cuentaCorrienteFacade;
+  @EJB
+  private ClienteFacadeLocal clienteFacade;
+  
+  private CuentaCorriente cuentaCorriente;
+  private Cliente cliente;
+  
+  public String contratar() {
+    CuentaCorriente cc = new CuentaCorriente();
+    cc.setSaldo(0);
+    cc.setCliente(cliente);
+    cc.setInsertedAt(new Date());
+    
+    cliente.getCuentaCorrienteList().add(cc);
+    clienteFacade.edit(cliente);
+    
+    return "admin_cliente_view";
+  }
+  
+  public String edit() {
+    return "admin_cliente_view";
+  }
+  
+  public String gotoDepositar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    DepositoBean db = context.getApplication().evaluateExpressionGet(context, "#{depositoBean}", DepositoBean.class);
+    db.setCuentaCorriente(cuentaCorriente);
+    return "cliente_cuenta_corriente_depositar";
+  }
+  
+  public String gotoDeleteDeposito(DepositoCuentaCorriente deposito) {
+    FacesContext context = FacesContext.getCurrentInstance();
+    DepositoBean db = context.getApplication().evaluateExpressionGet(context, "#{depositoBean}", DepositoBean.class);
+    db.setCuentaCorriente(cuentaCorriente);
+    db.setDepositoCuentaCorriente(deposito);
+    return "admin_cuenta_corriente_delete_deposito";
+  }
+  
+  public String gotoGirar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    GiroBean gb = context.getApplication().evaluateExpressionGet(context, "#{giroBean}", GiroBean.class);
+    gb.setCuentaCorriente(cuentaCorriente);
+    return "cliente_cuenta_corriente_girar";
+  }
+  
+  public String gotoTransferir() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TransferenciaBean tb = context.getApplication().evaluateExpressionGet(context, "#{transferenciaBean}", TransferenciaBean.class);
+    tb.setCuentaCorriente(cuentaCorriente);
+    return "cliente_cuenta_corriente_transferir";
+  }
+  
+
+  public CuentaCorriente getCuentaCorriente() {
+    return cuentaCorriente;
+  }
+
+  public void setCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    this.cuentaCorriente = cuentaCorriente;
+  }
+
+  public Cliente getCliente() {
+    return cliente;
+  }
+
+  public void setCliente(Cliente cliente) {
+    this.cliente = cliente;
+  }
+  
+  
+}

bank-war/src/java/bean/DepositoBean.java

@@ -0,0 +1,184 @@
+
+package bean;
+
+import beans.CuentaCorrienteFacadeLocal;
+import beans.DepositoCuentaCorrienteFacadeLocal;
+import beans.DepositoTarjetaDebitoFacadeLocal;
+import beans.MetodoFacadeLocal;
+import beans.TarjetaDebitoFacadeLocal;
+import entities.CuentaCorriente;
+import entities.DepositoCuentaCorriente;
+import entities.DepositoTarjetaDebito;
+import entities.Metodo;
+import entities.TarjetaDebito;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.PostConstruct;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.inject.Named;
+
+@Named(value = "depositoBean")
+@SessionScoped
+public class DepositoBean implements Serializable {
+  @EJB 
+  private DepositoCuentaCorrienteFacadeLocal depositoCCFacade;
+  @EJB 
+  private DepositoTarjetaDebitoFacadeLocal depositoTDFacade;
+  @EJB
+  private CuentaCorrienteFacadeLocal cuentaCorrienteFacade;
+  @EJB
+  private TarjetaDebitoFacadeLocal tarjetaDebitoFacade;
+  @EJB
+  private MetodoFacadeLocal metodoFacade;
+
+  private int monto;
+  private String comentario;
+  private Metodo metodo;
+  private List<Metodo> metodoList;
+  private CuentaCorriente cuentaCorriente;
+  private TarjetaDebito tarjetaDebito;
+  private DepositoCuentaCorriente depositoCuentaCorriente;
+  private DepositoTarjetaDebito depositoTarjetaDebito;
+  
+  @PostConstruct
+  private void init(){
+    this.metodoList = metodoFacade.findAll();
+  }
+  
+  public String depositar() {
+    if(cuentaCorriente != null){
+      return depositarEnCuentaCorriente();
+    }else if(tarjetaDebito != null){
+      return depositarEnTarjetaDebito();
+    }else{
+      return null;
+    }
+  }
+  
+  public String depositarEnCuentaCorriente() {
+    DepositoCuentaCorriente deposito = new DepositoCuentaCorriente();
+    deposito.setComentario(comentario);
+    deposito.setMonto(monto);
+    deposito.setMetodo(metodo);
+    deposito.setInsertedAt(new Date());
+    deposito.setCuentaCorriente(cuentaCorriente);
+    
+    cuentaCorriente.getDepositoList().add(deposito);
+    cuentaCorriente.setSaldo(cuentaCorriente.getSaldo() + monto);
+    
+    depositoCCFacade.create(deposito);
+    cuentaCorrienteFacade.edit(cuentaCorriente);
+    
+    resetInput();
+    return "cliente_cuenta_corriente_view";
+  }
+  
+  public String depositarEnTarjetaDebito() {
+    DepositoTarjetaDebito deposito = new DepositoTarjetaDebito();
+    deposito.setComentario(comentario);
+    deposito.setMonto(monto);
+    deposito.setMetodo(metodo);
+    deposito.setInsertedAt(new Date());
+    deposito.setTarjetaDebito(tarjetaDebito);
+    
+    tarjetaDebito.getDepositoList().add(deposito);
+    tarjetaDebito.setSaldo(tarjetaDebito.getSaldo() + monto);
+    
+    depositoTDFacade.create(deposito);
+    tarjetaDebitoFacade.edit(tarjetaDebito);
+    
+    resetInput();
+    return "cliente_tarjeta_debito_view";
+  }
+
+  public String delete() {
+    if(cuentaCorriente != null) {
+      return deleteDepositoCuentaCorriente();
+    }else if (depositoTarjetaDebito != null) {
+      return deleteDepositoTarjetaDebito();
+    }
+    return "error/505";
+  }
+  
+  public String deleteDepositoCuentaCorriente() {
+    return "";
+  }
+  
+  public String deleteDepositoTarjetaDebito() {
+    return "";
+  }
+  
+  private void resetInput() {
+    this.cuentaCorriente = null;
+    this.tarjetaDebito = null;
+    this.metodo = null;
+    this.monto = 0;
+    this.comentario = "";
+  }
+
+  public int getMonto() {
+    return monto;
+  }
+
+  public void setMonto(int monto) {
+    this.monto = monto;
+  }
+
+  public String getComentario() {
+    return comentario;
+  }
+
+  public void setComentario(String comentario) {
+    this.comentario = comentario;
+  }
+
+  public Metodo getMetodo() {
+    return metodo;
+  }
+
+  public void setMetodo(Metodo metodo) {
+    this.metodo = metodo;
+  }
+
+  public CuentaCorriente getCuentaCorriente() {
+    return cuentaCorriente;
+  }
+
+  public void setCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    this.cuentaCorriente = cuentaCorriente;
+  }
+
+  public TarjetaDebito getTarjetaDebito() {
+    return tarjetaDebito;
+  }
+
+  public void setTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    this.tarjetaDebito = tarjetaDebito;
+  }
+
+  public List<Metodo> getMetodoList() {
+    return metodoList;
+  }
+
+  public void setMetodoList(List<Metodo> metodoList) {
+    this.metodoList = metodoList;
+  }
+
+  public DepositoCuentaCorriente getDepositoCuentaCorriente() {
+    return depositoCuentaCorriente;
+  }
+
+  public void setDepositoCuentaCorriente(DepositoCuentaCorriente depositoCuentaCorriente) {
+    this.depositoCuentaCorriente = depositoCuentaCorriente;
+  }
+
+  public DepositoTarjetaDebito getDepositoTarjetaDebito() {
+    return depositoTarjetaDebito;
+  }
+
+  public void setDepositoTarjetaDebito(DepositoTarjetaDebito depositoTarjetaDebito) {
+    this.depositoTarjetaDebito = depositoTarjetaDebito;
+  }
+}

bank-war/src/java/bean/GiroBean.java

@@ -0,0 +1,165 @@
+
+package bean;
+
+import beans.CuentaCorrienteFacade;
+import beans.CuentaCorrienteFacadeLocal;
+import beans.GiroCuentaCorrienteFacadeLocal;
+import beans.GiroTarjetaDebitoFacadeLocal;
+import beans.MetodoFacadeLocal;
+import beans.TarjetaDebitoFacadeLocal;
+import entities.CuentaCorriente;
+import entities.GiroCuentaCorriente;
+import entities.GiroTarjetaDebito;
+import entities.Metodo;
+import entities.TarjetaDebito;
+import java.io.Serializable;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.PostConstruct;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.application.FacesMessage;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "giroBean")
+@SessionScoped
+public class GiroBean implements Serializable {
+  @EJB 
+  private GiroCuentaCorrienteFacadeLocal giroCCFacade;
+  @EJB 
+  private GiroTarjetaDebitoFacadeLocal giroTDFacade;
+  @EJB
+  private MetodoFacadeLocal metodoFacade;
+  @EJB
+  private CuentaCorrienteFacadeLocal cuentaCorrienteFacade;
+  @EJB
+  private TarjetaDebitoFacadeLocal tarjetaDebitoFacade;
+
+  private int monto;
+  private String comentario;
+  private Metodo metodo;
+  private List<Metodo> metodoList;
+  private CuentaCorriente cuentaCorriente;
+  private TarjetaDebito tarjetaDebito;
+  
+  @PostConstruct
+  private void init(){
+    this.metodoList = metodoFacade.findAll();
+  }
+  
+  public String girar() {
+    if(cuentaCorriente != null){
+      return girarEnCuentaCorriente();
+    }else if(tarjetaDebito != null){
+      return girarEnTarjetaDebito();
+    }else{
+      return null;
+    }
+  }
+  
+  public String girarEnCuentaCorriente() {
+    if(cuentaCorriente.getSaldo() - monto < 0 ){
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("El monto sobrepasa el saldo de la cuenta corriente"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_cuenta_corriente_girar";
+    }
+    
+    GiroCuentaCorriente giro = new GiroCuentaCorriente();
+    giro.setComentario(comentario);
+    giro.setMonto(monto);
+    giro.setMetodo(metodo);
+    giro.setInsertedAt(new Date());
+    giro.setCuentaCorriente(cuentaCorriente);
+    
+    cuentaCorriente.getGiroList().add(giro);
+    cuentaCorriente.setSaldo(cuentaCorriente.getSaldo() - monto);
+    
+    giroCCFacade.create(giro);
+    cuentaCorrienteFacade.edit(cuentaCorriente);
+    
+    resetInput();
+    return "cliente_cuenta_corriente_view";
+  }
+  
+  public String girarEnTarjetaDebito() {
+    if(tarjetaDebito.getSaldo() - monto < 0 ){
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("El monto sobrepasa el saldo de la tarjeta de debito"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_tarjeta_debito_girar";
+    }
+    
+    GiroTarjetaDebito giro = new GiroTarjetaDebito();
+    giro.setComentario(comentario);
+    giro.setMonto(monto);
+    giro.setMetodo(metodo);
+    giro.setInsertedAt(new Date());
+    giro.setTarjetaDebito(tarjetaDebito);
+    
+    tarjetaDebito.getGiroList().add(giro);
+    tarjetaDebito.setSaldo(tarjetaDebito.getSaldo() - monto);
+    
+    giroTDFacade.create(giro);
+    tarjetaDebitoFacade.edit(tarjetaDebito);
+    
+    resetInput();
+    return "cliente_tarjeta_debito_view";
+  }
+
+  
+  private void resetInput() {
+    this.cuentaCorriente = null;
+    this.tarjetaDebito = null;
+    this.metodo = null;
+    this.monto = 0;
+    this.comentario = "";
+  }
+
+  public int getMonto() {
+    return monto;
+  }
+
+  public void setMonto(int monto) {
+    this.monto = monto;
+  }
+
+  public String getComentario() {
+    return comentario;
+  }
+
+  public void setComentario(String comentario) {
+    this.comentario = comentario;
+  }
+
+  public Metodo getMetodo() {
+    return metodo;
+  }
+
+  public void setMetodo(Metodo metodo) {
+    this.metodo = metodo;
+  }
+
+  public CuentaCorriente getCuentaCorriente() {
+    return cuentaCorriente;
+  }
+
+  public void setCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    this.cuentaCorriente = cuentaCorriente;
+  }
+
+  public TarjetaDebito getTarjetaDebito() {
+    return tarjetaDebito;
+  }
+
+  public void setTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    this.tarjetaDebito = tarjetaDebito;
+  }
+
+  public List<Metodo> getMetodoList() {
+    return metodoList;
+  }
+
+  public void setMetodoList(List<Metodo> metodoList) {
+    this.metodoList = metodoList;
+  }
+}

bank-war/src/java/bean/PagoBean.java

@@ -0,0 +1,127 @@
+package bean;
+
+import beans.PagoTarjetaCreditoFacadeLocal;
+import beans.TarjetaCreditoFacadeLocal;
+import entities.PagoTarjetaCredito;
+import entities.TarjetaCredito;
+import java.io.Serializable;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.application.FacesMessage;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "pagoBean")
+@SessionScoped
+public class PagoBean implements Serializable {
+
+  @EJB
+  private PagoTarjetaCreditoFacadeLocal pagoTarjetaCreditoFacade;
+  @EJB
+  private TarjetaCreditoFacadeLocal tarjetaCreditoFacade;
+
+  private TarjetaCredito tarjetaCredito;
+
+  private int monto;
+  private String comentario;
+  private String clase;
+
+  public String pagar() {
+    if (clase.equals("Nacional")) {
+      if (tarjetaCredito.getDeudaNacional() == 0) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("No hay ninguna deuda nacional que pagar"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_pagar";
+      }
+      if (tarjetaCredito.getDeudaNacional() - monto < 0) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("El pago sobrepasa la deuda"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_pagar";
+      }
+      
+      PagoTarjetaCredito pago = new PagoTarjetaCredito();
+      pago.setComentario(comentario);
+      pago.setMonto(monto);
+      pago.setTarjetaCredito(tarjetaCredito);
+      
+      tarjetaCredito.setDeudaNacional(tarjetaCredito.getDeudaNacional() - monto);
+      tarjetaCreditoFacade.edit(tarjetaCredito);
+      pagoTarjetaCreditoFacade.create(pago);
+      
+      this.resetInput();
+      return "cliente_tarjeta_credito_view";
+    }
+
+    if (clase.equals("Internacional")) {
+      if (tarjetaCredito.getDeudaInternacional() == 0) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("No hay ninguna deuda internacional que pagar"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_pagar";
+      }
+      if (tarjetaCredito.getDeudaInternacional() - monto < 0) {
+        FacesContext context = FacesContext.getCurrentInstance();
+        context.addMessage(null, new FacesMessage("El pago sobrepasa la deuda internacional"));
+        context.validationFailed();
+        return "cliente_tarjeta_credito_pagar";
+      }
+
+      PagoTarjetaCredito pago = new PagoTarjetaCredito();
+      pago.setComentario(comentario);
+      pago.setMonto(monto);
+      pago.setTarjetaCredito(tarjetaCredito);
+      
+      tarjetaCredito.setDeudaInternacional(tarjetaCredito.getDeudaInternacional() - monto);
+      tarjetaCredito.getPagoList().add(pago);
+      
+      tarjetaCreditoFacade.edit(tarjetaCredito);
+      pagoTarjetaCreditoFacade.create(pago);
+
+      this.resetInput();
+      return "cliente_tarjeta_credito_view";
+    }
+    
+    return "cliente_tarjeta_credito_view";
+  }
+  
+  public void resetInput() {
+    this.monto = 0;
+    this.comentario = null;
+    this.clase = null;
+  }
+
+  public TarjetaCredito getTarjetaCredito() {
+    return tarjetaCredito;
+  }
+
+  public void setTarjetaCredito(TarjetaCredito tarjetaCredito) {
+    this.tarjetaCredito = tarjetaCredito;
+  }
+
+  public int getMonto() {
+    return monto;
+  }
+
+  public void setMonto(int monto) {
+    this.monto = monto;
+  }
+
+  public String getComentario() {
+    return comentario;
+  }
+
+  public void setComentario(String comentario) {
+    this.comentario = comentario;
+  }
+
+  public String getClase() {
+    return clase;
+  }
+
+  public void setClase(String clase) {
+    this.clase = clase;
+  }
+
+}

bank-war/src/java/bean/TarjetaCreditoBean.java

@@ -0,0 +1,86 @@
+package bean;
+
+import beans.ClienteFacadeLocal;
+import beans.TarjetaCreditoFacadeLocal;
+import entities.Cliente;
+import entities.TarjetaCredito;
+import java.io.Serializable;
+import java.util.Date;
+import javax.annotation.PostConstruct;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "tarjetaCreditoBean")
+@SessionScoped
+public class TarjetaCreditoBean implements Serializable {
+
+  @EJB
+  private TarjetaCreditoFacadeLocal tarjetaCreditoFacade;
+  @EJB
+  private ClienteFacadeLocal clienteFacade;
+
+  private Cliente cliente;
+  private TarjetaCredito tarjetaCredito;
+
+  @PostConstruct
+  public void init() {
+    this.cliente = new Cliente();
+    this.tarjetaCredito = new TarjetaCredito();
+  }
+
+  public String contratar() {
+    tarjetaCredito.setCliente(cliente);
+    tarjetaCredito.setInsertedAt(new Date());
+
+    cliente.getTarjetaCreditoList().add(tarjetaCredito);
+    clienteFacade.edit(cliente);
+
+    this.resetClases();
+    return "admin_cliente_view";
+  }
+
+  public String gotoComprar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    CompraBean cb = context.getApplication().evaluateExpressionGet(context, "#{compraBean}", CompraBean.class);
+    cb.setTarjetaCredito(tarjetaCredito);
+    return "cliente_tarjeta_credito_comprar";
+  }
+  
+  public String gotoPagar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    PagoBean pb = context.getApplication().evaluateExpressionGet(context, "#{pagoBean}", PagoBean.class);
+    pb.setTarjetaCredito(tarjetaCredito);
+    return "cliente_tarjeta_credito_pagar";
+  }
+
+  public String edit() {
+    tarjetaCreditoFacade.edit(tarjetaCredito);
+
+    this.resetClases();
+    return "admin_cliente_view";
+  }
+
+  private void resetClases() {
+    this.cliente = new Cliente();
+    this.tarjetaCredito = new TarjetaCredito();
+  }
+
+  public Cliente getCliente() {
+    return cliente;
+  }
+
+  public void setCliente(Cliente cliente) {
+    this.cliente = cliente;
+  }
+
+  public TarjetaCredito getTarjetaCredito() {
+    return tarjetaCredito;
+  }
+
+  public void setTarjetaCredito(TarjetaCredito tarjetaCredito) {
+    this.tarjetaCredito = tarjetaCredito;
+  }
+
+}

bank-war/src/java/bean/TarjetaDebitoBean.java

@@ -0,0 +1,94 @@
+package bean;
+
+import beans.ClienteFacadeLocal;
+import beans.TarjetaDebitoFacadeLocal;
+import entities.Cliente;
+import entities.TarjetaDebito;
+import java.io.Serializable;
+import java.util.Date;
+import javax.annotation.PostConstruct;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "tarjetaDebitoBean")
+@SessionScoped
+public class TarjetaDebitoBean implements Serializable {
+
+  @EJB
+  private TarjetaDebitoFacadeLocal tarjetaDebitoFacade;
+  @EJB
+  private ClienteFacadeLocal clienteFacade;
+
+  private Cliente cliente;
+  private TarjetaDebito tarjetaDebito;
+
+  @PostConstruct
+  public void init() {
+    this.cliente = new Cliente();
+    this.tarjetaDebito = new TarjetaDebito();
+  }
+
+  public String contratar() {
+    tarjetaDebito.setCliente(cliente);
+    tarjetaDebito.setInsertedAt(new Date());
+
+    cliente.getTarjetaDebitoList().add(tarjetaDebito);
+    clienteFacade.edit(cliente);
+
+    this.resetInput();
+    return "admin_cliente_view";
+  }
+  
+  public String gotoDepositar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    DepositoBean db = context.getApplication().evaluateExpressionGet(context, "#{depositoBean}", DepositoBean.class);
+    db.setTarjetaDebito(tarjetaDebito);
+    return "cliente_tarjeta_debito_depositar";
+  }
+  
+  public String gotoGirar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    GiroBean gb = context.getApplication().evaluateExpressionGet(context, "#{giroBean}", GiroBean.class);
+    gb.setTarjetaDebito(tarjetaDebito);
+    return "cliente_tarjeta_debito_girar";
+  }
+  
+  public String gotoTransferir() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    TransferenciaBean tb = context.getApplication().evaluateExpressionGet(context, "#{transferenciaBean}", TransferenciaBean.class);
+    tb.setTarjetaDebito(tarjetaDebito);
+    return "cliente_tarjeta_debito_transferir";
+  }
+  
+  public String gotoComprar() {
+    FacesContext context = FacesContext.getCurrentInstance();
+    CompraBean cb = context.getApplication().evaluateExpressionGet(context, "#{compraBean}", CompraBean.class);
+    cb.setTarjetaDebito(tarjetaDebito);
+    return "cliente_tarjeta_debito_comprar";
+  }
+  
+
+  private void resetInput() {
+    this.cliente = new Cliente();
+    this.tarjetaDebito = new TarjetaDebito();
+  }
+
+  public Cliente getCliente() {
+    return cliente;
+  }
+
+  public void setCliente(Cliente cliente) {
+    this.cliente = cliente;
+  }
+
+  public TarjetaDebito getTarjetaDebito() {
+    return tarjetaDebito;
+  }
+
+  public void setTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    this.tarjetaDebito = tarjetaDebito;
+  }
+
+}

bank-war/src/java/bean/TransferenciaBean.java

@@ -0,0 +1,179 @@
+package bean;
+
+import beans.CuentaCorrienteFacadeLocal;
+import beans.TarjetaDebitoFacadeLocal;
+import beans.TransferenciaCuentaCorrienteFacadeLocal;
+import beans.TransferenciaTarjetaDebitoFacadeLocal;
+import entities.CuentaCorriente;
+import entities.TarjetaDebito;
+import entities.TransferenciaCuentaCorriente;
+import entities.TransferenciaTarjetaDebito;
+import java.io.Serializable;
+import java.util.Date;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.application.FacesMessage;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+
+@Named(value = "transferenciaBean")
+@SessionScoped
+public class TransferenciaBean implements Serializable {
+
+  @EJB
+  private TransferenciaCuentaCorrienteFacadeLocal transferenciaCCFacade;
+  @EJB
+  private TransferenciaTarjetaDebitoFacadeLocal transferenciaTDFacade;
+  @EJB
+  private CuentaCorrienteFacadeLocal cuentaCorrienteFacade;
+  @EJB
+  private TarjetaDebitoFacadeLocal tarjetaDebitoFacade;
+
+  private int monto;
+  private int destinatario_id;
+  private String comentario;
+  private CuentaCorriente cuentaCorriente;
+  private TarjetaDebito tarjetaDebito;
+
+  public String transferir() {
+    if (cuentaCorriente != null) {
+      return transferirEnCuentaCorriente();
+    } else if (tarjetaDebito != null) {
+      return transferirEnTarjetaDebito();
+    } else {
+      return null;
+    }
+  }
+
+  public String transferirEnCuentaCorriente() {
+    if(this.destinatario_id == this.cuentaCorriente.getId()){
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("No se puede transferir hacia si mismo"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_cuenta_corriente_transferir";
+    }
+    
+    CuentaCorriente destinatario = cuentaCorrienteFacade.find(this.destinatario_id);
+    if (destinatario == null) {
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("La cuenta corriente ingresada no existe"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_cuenta_corriente_transferir";
+    }
+
+    if (cuentaCorriente.getSaldo() - monto < 0) {
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("El monto sobrepasa el saldo de la cuenta corriente"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_cuenta_corriente_transferir";
+    }
+
+    TransferenciaCuentaCorriente transferencia = new TransferenciaCuentaCorriente();
+    transferencia.setComentario(comentario);
+    transferencia.setMonto(monto);
+    transferencia.setInsertedAt(new Date());
+    transferencia.setCuentaCorrienteFrom(cuentaCorriente);
+    transferencia.setCuentaCorrienteTo(destinatario);
+
+    cuentaCorriente.getTransferenciaFromList().add(transferencia);
+    destinatario.getTransferenciaToList().add(transferencia);
+    
+    cuentaCorriente.setSaldo(cuentaCorriente.getSaldo() - monto);
+    destinatario.setSaldo(destinatario.getSaldo() + monto);
+    
+    transferenciaCCFacade.create(transferencia);
+    cuentaCorrienteFacade.edit(cuentaCorriente);
+    cuentaCorrienteFacade.edit(destinatario);
+
+    resetInput();
+    return "cliente_cuenta_corriente_view";
+  }
+
+  public String transferirEnTarjetaDebito() {
+    if(this.destinatario_id == this.tarjetaDebito.getId()){
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("No se puede transferir hacia si mismo"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_tarjeta_debito_transferir";
+    }
+    
+    TarjetaDebito destinatario = tarjetaDebitoFacade.find(this.destinatario_id);
+    if (destinatario == null) {
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("La tarjeta de debito ingresada no existe"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_tarjeta_debito_transferir";
+    }
+
+    if (tarjetaDebito.getSaldo() - monto < 0) {
+      FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("El monto sobrepasa el saldo de la tarjeta de debito"));
+      FacesContext.getCurrentInstance().validationFailed();
+      return "cliente_tarjeta_debito_transferir";
+    }
+
+    TransferenciaTarjetaDebito transferencia = new TransferenciaTarjetaDebito();
+    transferencia.setComentario(comentario);
+    transferencia.setMonto(monto);
+    transferencia.setInsertedAt(new Date());
+    transferencia.setTarjetaDebitoFrom(tarjetaDebito);
+    transferencia.setTarjetaDebitoTo(destinatario);
+
+    tarjetaDebito.getTransferenciaFromList().add(transferencia);
+    destinatario.getTransferenciaToList().add(transferencia);
+    
+    tarjetaDebito.setSaldo(tarjetaDebito.getSaldo() - monto);
+    destinatario.setSaldo(destinatario.getSaldo() + monto);
+    
+    transferenciaTDFacade.create(transferencia);
+    tarjetaDebitoFacade.edit(tarjetaDebito);
+    tarjetaDebitoFacade.edit(destinatario);
+
+    resetInput();
+    return "cliente_tarjeta_debito_view";
+  }
+
+  private void resetInput() {
+    this.cuentaCorriente = null;
+    this.tarjetaDebito = null;
+    this.monto = 0;
+    this.destinatario_id = 0;
+    this.comentario = "";
+  }
+
+  public int getMonto() {
+    return monto;
+  }
+
+  public void setMonto(int monto) {
+    this.monto = monto;
+  }
+
+  public String getComentario() {
+    return comentario;
+  }
+
+  public void setComentario(String comentario) {
+    this.comentario = comentario;
+  }
+
+  public CuentaCorriente getCuentaCorriente() {
+    return cuentaCorriente;
+  }
+
+  public void setCuentaCorriente(CuentaCorriente cuentaCorriente) {
+    this.cuentaCorriente = cuentaCorriente;
+  }
+
+  public TarjetaDebito getTarjetaDebito() {
+    return tarjetaDebito;
+  }
+
+  public void setTarjetaDebito(TarjetaDebito tarjetaDebito) {
+    this.tarjetaDebito = tarjetaDebito;
+  }
+
+  public int getDestinatario_id() {
+    return destinatario_id;
+  }
+
+  public void setDestinatario_id(int destinatario_id) {
+    this.destinatario_id = destinatario_id;
+  }
+  
+  
+}

bank-war/src/java/bean/UsuarioBean.java

@@ -0,0 +1,113 @@
+package bean;
+
+import beans.UsuarioFacadeLocal;
+import entities.Usuario;
+import java.io.Serializable;
+import javax.ejb.EJB;
+import javax.enterprise.context.SessionScoped;
+import javax.faces.application.FacesMessage;
+import javax.faces.context.FacesContext;
+import javax.inject.Named;
+import utils.Passwords;
+
+@Named(value = "userBean")
+@SessionScoped
+public class UsuarioBean implements Serializable {
+
+  @EJB
+  private UsuarioFacadeLocal usuarioFacade;
+
+  private String nombre;
+  private String password;
+
+  public String login() {
+    Usuario u = usuarioFacade.findByNombre(nombre);
+    
+    if (u == null) {
+      FacesContext context = FacesContext.getCurrentInstance();
+      context.addMessage(null, new FacesMessage("El usuario o la contraseña son invalidos"));
+      context.validationFailed();
+      return "index";
+    }
+
+    if (!Passwords.isExpectedPassword(password.toCharArray(), u.getSalt(), u.getPassword())) {
+      FacesContext context = FacesContext.getCurrentInstance();
+      context.addMessage(null, new FacesMessage("El usuario o la contraseña son invalidos"));
+      context.validationFailed();
+      return "index";
+    }
+
+    this.setUsuario(u);
+    
+    if(isAdmin())
+      return "admin_main";
+    if(isClient()){
+      FacesContext context = FacesContext.getCurrentInstance();
+      ClienteBean clienteBean = context.getApplication().evaluateExpressionGet(context, "#{clienteBean}", ClienteBean.class);
+      clienteBean.setCliente(u.getCliente());
+      return "cliente_main";
+    }
+    
+    return "error/500";
+  }
+
+  public String register() {
+    byte[] salt = Passwords.getNextSalt();
+    byte[] hash = Passwords.hash(password.toCharArray(), salt);
+
+    Usuario u = new Usuario();
+    u.setNombre(nombre);
+    u.setPassword(hash);
+    u.setSalt(salt);
+    u.setRole("Admin");
+
+    usuarioFacade.create(u);
+
+    return "index";
+  }
+
+  public String logout() {
+    FacesContext.getCurrentInstance().getExternalContext().invalidateSession();
+    return "index";
+  }
+
+  public boolean isLogged() {
+    return this.getUsuario() != null;
+  }
+
+  public boolean isAdmin() {
+      return this.getUsuario().getRole().equals("Admin");
+  }
+
+  public boolean isClient() {
+    return this.getUsuario().getRole().equals("Cliente");
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////GETTERS Y SETTERS//////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+  public String getNombre() {
+    return nombre;
+  }
+
+  public void setNombre(String nombre) {
+    this.nombre = nombre;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public void setPassword(String password) {
+    this.password = password;
+  }
+
+  public Usuario getUsuario() {
+    return (Usuario) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("usuario");
+  }
+
+  public void setUsuario(Usuario usuario) {
+    FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("usuario", usuario);
+  }
+
+}

bank-war/src/java/utils/MetodoConverter.java

@@ -0,0 +1,47 @@
+package utils;
+
+import beans.MetodoFacadeLocal;
+import entities.Metodo;
+import javax.ejb.EJB;
+import javax.faces.application.FacesMessage;
+import javax.faces.bean.ManagedBean;
+import javax.faces.bean.RequestScoped;
+import javax.faces.component.UIComponent;
+import javax.faces.context.FacesContext;
+import javax.faces.convert.Converter;
+import javax.faces.convert.ConverterException;
+
+@ManagedBean
+@RequestScoped
+public class MetodoConverter implements Converter {
+
+    @EJB
+    private MetodoFacadeLocal metodoFacade;
+
+    @Override
+    public Object getAsObject(FacesContext context, UIComponent component, String submittedValue) {
+        if (submittedValue == null || submittedValue.isEmpty()) {
+            return null;
+        }
+
+        try {
+            return metodoFacade.find(Integer.valueOf(submittedValue));
+        } catch (NumberFormatException e) {
+            throw new ConverterException(new FacesMessage(String.format("%s no es id de metodo valido", submittedValue)), e);
+        }
+    }
+
+    @Override
+    public String getAsString(FacesContext context, UIComponent component, Object modelValue) {
+        if (modelValue == null) {
+            return "";
+        }
+
+        if (modelValue instanceof Metodo) {
+            return String.valueOf(((Metodo) modelValue).getId());
+        } else {
+            throw new ConverterException(new FacesMessage(String.format("%s no es un metodo valido", modelValue)));
+        }
+    }
+
+}

bank-war/src/java/utils/Passwords.java

@@ -0,0 +1,73 @@
+package utils;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.spec.InvalidKeySpecException;
+import java.util.Arrays;
+import java.util.Random;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+
+/**
+ * Clase encargada de crear y comparar contraseñas de forma segura
+ */
+public class Passwords {
+
+  private static final Random RANDOM = new SecureRandom();
+  private static final int ITERATIONS = 10000;
+  private static final int KEY_LENGHT = 256;
+
+  private Passwords() {
+  }
+
+  /**
+   * Genera aleatoriamente un <code>byte[]</code> de tamaño 16
+   *
+   * @return El <code>byte[]</code> generados
+   */
+  public static byte[] getNextSalt() {
+    byte[] salt = new byte[16];
+    RANDOM.nextBytes(salt);
+    return salt;
+  }
+
+  /**
+   * Compara 2 constraseñas, la primera sin hashear aun y la segunda ya hasheada
+   *
+   * @param password <code>char[]</code> que contiene la contraseña sin hashear aun
+   * @param salt <code>byte[]</code> que contiene la sal con la que juntar la contraseña al momento de hashearla
+   * @param expectedHash <code>byte[]</code> con una contraseña ya hasheada con la que comprar
+   * @return un boleano indicando que las constraseñas son iguales o no
+   */
+  public static boolean isExpectedPassword(char[] password, byte[] salt, byte[] expectedHash) {
+    byte[] pwdHash = hash(password, salt);
+    Arrays.fill(password, Character.MIN_VALUE);
+    if (pwdHash.length != expectedHash.length)
+      return false;
+    for (int i = 0; i < pwdHash.length; i++) {
+      if (pwdHash[i] != expectedHash[i])
+        return false;
+    }
+    return true;
+  }
+
+  /**
+   * Hashea una contraseña.
+   *
+   * @param password <code>char[]</code> con la contraseña a hashear
+   * @param salt <code>byte[]</code> con la salt que se le aplicara a la contraseña
+   * @return <code>byte[]</code> con la constraseña hasheada
+   */
+  public static byte[] hash(char[] password, byte[] salt) {
+    PBEKeySpec spec = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGHT);
+    Arrays.fill(password, Character.MIN_VALUE);
+    try {
+      SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
+      return skf.generateSecret(spec).getEncoded();
+    } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
+      throw new AssertionError("Error while hashing a password: " + e.getMessage(), e);
+    } finally {
+      spec.clearPassword();
+    }
+  }
+}

bank-war/src/java/utils/RutValidator.java

@@ -0,0 +1,55 @@
+package utils;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.faces.application.FacesMessage;
+import javax.faces.component.UIComponent;
+import javax.faces.context.FacesContext;
+import javax.faces.validator.FacesValidator;
+import javax.faces.validator.Validator;
+import javax.faces.validator.ValidatorException;
+
+@FacesValidator(value = "rutValidator")
+public class RutValidator implements Validator {
+
+  private final static Pattern PATTERN = Pattern.compile("(\\d+)-(\\d|k)", Pattern.CASE_INSENSITIVE);
+
+  @Override
+  public void validate(FacesContext fc, UIComponent uic, Object o) throws ValidatorException {
+    Matcher matcher = PATTERN.matcher(o.toString());
+
+    if (!matcher.matches()) {
+      FacesMessage message = new FacesMessage("Rut: El formato no es correcto");
+      message.setSeverity(FacesMessage.SEVERITY_ERROR);
+      throw new ValidatorException(message);
+    }
+
+    if (!rutChecksum(matcher.group(1), matcher.group(2).toLowerCase().charAt(0))) {
+      FacesMessage message = new FacesMessage("Rut: El digito verificador no es correcto");
+      message.setSeverity(FacesMessage.SEVERITY_ERROR);
+      throw new ValidatorException(message);
+    }
+
+  }
+
+  private boolean rutChecksum(String body, char dv) {
+    int sum = 0;
+    for (int i = body.length() - 1, j = 2; i >= 0; i--, j++) {
+      int digit = body.charAt(i) - '0';
+      if (j == 8)
+        j = 2;
+
+      sum += digit * j;
+    }
+
+    int mod11 = 11 - (sum % 11);
+
+    char digitoVerificador = (char) (mod11 + '0');
+    if (mod11 == 11)
+      digitoVerificador = '0';
+    if (mod11 == 10)
+      digitoVerificador = 'k';
+    
+    return dv == digitoVerificador ;
+  }
+}

bank-war/src/java/utils/UniqueRutValidator.java

@@ -0,0 +1,31 @@
+package utils;
+
+import beans.ClienteFacadeLocal;
+import entities.Cliente;
+import javax.ejb.EJB;
+import javax.faces.application.FacesMessage;
+import javax.faces.bean.ManagedBean;
+import javax.faces.bean.RequestScoped;
+import javax.faces.component.UIComponent;
+import javax.faces.context.FacesContext;
+import javax.faces.validator.Validator;
+import javax.faces.validator.ValidatorException;
+
+
+@ManagedBean
+@RequestScoped
+public class UniqueRutValidator implements Validator {
+  @EJB
+  private ClienteFacadeLocal clienteFacade;
+
+  @Override
+  public void validate(FacesContext fc, UIComponent uic, Object o) throws ValidatorException {
+    Cliente cliente = clienteFacade.findByRut(o.toString());
+    
+    if (cliente != null) {
+      FacesMessage message = new FacesMessage("Rut: Ya existe un usuario con ese rut");
+      message.setSeverity(FacesMessage.SEVERITY_ERROR);
+      throw new ValidatorException(message);
+    }
+  }
+}