@Override
  public void procesarEvento(Evento evento) {

    Object info = evento.getInfo();

    switch (evento.getTipoEvento()) {
      case FIJAR_LYL:
        lookAndFeel = (String) info;
        break;
      case LOGIN_OK:
        if (info.getClass().getName().startsWith("Modelo.Usuario")) {
          // vGLogin.setVisible(false);
          // vGLogin = null;
          Usuario usuarioActivo = (Usuario) info;
          // this.initLookAndFeelAplicacion(lookAndFeel);
          this.initLookAndFeelAplicacion(usuarioActivo.getLookAndFeel());

          operacion(usuarioActivo);
        } else {
          assert false : info.getClass().getName() + " clase no valida";
        }
        break;
      case LOGOUT:
        vGPrincipal.setVisible(false);
        // vGPrincipal = null;
        vGLogin.limpiarModelo();
        vGLogin.setVisible(true);

        break;
      default:
        System.err.println("eventoRespuesta() no tratado");
    }
  }
 public static void editar(
     String id, String nome, String login, String senha, String caminhofoto, String email) {
   Usuario usuarioantigo = new UsuarioDAO().findById(Integer.parseInt(id));
   Usuario a = new Usuario(Integer.parseInt(id), nome, login, senha, caminhofoto, email);
   a.setLivros(usuarioantigo.getLivros());
   new UsuarioDAO().alterar(a);
 }
 public static void vinculaLivro(String idLivro, String idUsuario) {
   UsuarioDAO dao = new UsuarioDAO();
   Usuario usuario = dao.findById(Integer.parseInt(idUsuario));
   LivroDAO livrodao = new LivroDAO();
   Livro livro = livrodao.findById(Integer.parseInt(idLivro));
   usuario.adicionaLivro(livro);
   dao.alterar(usuario);
 }
Exemple #4
0
  private void btSalvarActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_btSalvarActionPerformed
    boolean temgrupo = false;
    boolean temusuario = false;
    boolean editou = false;
    if (controle.Formatacao.verificarNulos(jpCadastro)) {
      if (btBuscarGrupo.isEnabled()) {
        grupo.setId(Integer.parseInt(qftfIdGrupo.getText()));
        temgrupo = true;
      } else {

      }
      if (btBuscarUsuario.isEnabled()) {
        usuarioselecionado.setId(Integer.parseInt(qftfIdUsuario.getText()));
        temusuario = true;

      } else {
        usuarioselecionado = new Usuario();
        usuarioselecionado.setId(0);
      }

      int numerodelinhas = jTable1.getRowCount();
      for (int i = 0; i < numerodelinhas; i++) {

        permissao = new Permissao();
        telaselecionada.setId(Integer.parseInt(String.valueOf(jTable1.getValueAt(i, 0))));
        if (temgrupo) {
          permissao.setGrupo(grupo);
        }
        permissao.setTela(telaselecionada);
        permissao.setUsuarioByIdUsuarioModificador(usuario);
        if (temusuario) {
          permissao.setUsuarioByIdUsuario(usuarioselecionado);
        }

        permissao.setId(Integer.parseInt(String.valueOf(jTable1.getValueAt(i, 6))));
        String inserir = (String.valueOf(jTable1.getValueAt(i, 3)));
        String editar = (String.valueOf(jTable1.getValueAt(i, 4)));
        String inativar = (String.valueOf(jTable1.getValueAt(i, 5)));
        String ler = (String.valueOf(jTable1.getValueAt(i, 2)));
        permissao.setInserir(Util.stringParaBinario(inserir));
        permissao.setEditar(Util.stringParaBinario(editar));
        permissao.setInativar(Util.stringParaBinario(inativar));
        permissao.setLer(Util.stringParaBinario(ler));

        editou = this.editar();
      }
      if (editou) {
        JOptionPane.showMessageDialog(rootPane, "Operação Realizada com sucesso");
      }
      limparCampos();

    } else {

    }
  } // GEN-LAST:event_btSalvarActionPerformed
Exemple #5
0
 @Override
 public void setRelacionado3(String id, String nome) {
   try {
     int idusuario = Integer.parseInt(id);
     Usuario u = new Usuario();
     u.setId(idusuario);
     controlePermissao.popularTabela(jTable1, u, true);
   } catch (Exception e) {
     System.err.println("Erro em setRelacionado3: " + e);
   }
 } // GEN-LAST:event_btBuscarGrupoActionPerformed
  public static boolean validaUsuario(String login, String senha) {
    UsuarioDAO dao = new UsuarioDAO();
    Usuario u = dao.findByCollumPalavra("login", login);
    if (u != null) {
      if (u.getSenha().equals(senha)) {

        return true;
      }
    }
    return false;
  }
 @Override
 public List<Contato> getContatosUsuario(Usuario usuario) throws Exception {
   sql = new StringBuilder();
   sql.append("select * from Contato where nmLogin=?");
   List<Contato> contatos = null;
   try {
     cn = FabricaDeConexao.getConnection();
     stmt = cn.prepareStatement(sql.toString());
     stmt.setString(1, usuario.getNmLogin());
     System.out.println(stmt);
     rs = stmt.executeQuery();
     contatos = new ArrayList<Contato>();
     Contato contato = null;
     ITelefoneDAO telefoneDAO = new TelefoneDAO();
     IEmailDAO emailDAO = new EmailDAO();
     while (rs.next()) {
       contato = new Contato();
       contato.setCdContato(rs.getInt("cdContato"));
       contato.setNmContato(rs.getString("nmContato"));
       contato.setNmCaminhoFoto(rs.getString("nmCaminhoFoto"));
       contato.setNmLogin(rs.getString("nmLogin"));
       contato.setEmails(emailDAO.getEmailsContato(contato.getCdContato()));
       contato.setTelefones(telefoneDAO.getTelefonesContato(contato.getCdContato()));
       contatos.add(contato);
     }
   } catch (SQLException e) {
     throw e;
   } finally {
     fecharConexoes();
   }
   return contatos;
 }
Exemple #8
0
 public void editar(Guia objeto, Usuario usuario, String xml) throws Exception {
   try {
     cnn = Conexion.getConexion();
     CallableStatement cs = null;
     cs = cnn.prepareCall("call uspUpdGuia(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
     cs.setInt(1, objeto.getIdGuia());
     cs.setString(2, objeto.getPeriodo());
     cs.setString(3, objeto.getNumero());
     cs.setString(4, objeto.getFecha());
     cs.setDouble(5, objeto.getTipoCambio());
     cs.setString(6, objeto.getSerie());
     cs.setString(7, objeto.getNumeroDocumento());
     cs.setInt(8, objeto.getIdTipoMovimiento());
     cs.setString(9, objeto.getReferencia());
     cs.setInt(10, objeto.getIdOrdenProduccion());
     cs.setInt(11, objeto.getIdClienteProveedor());
     cs.setInt(12, objeto.getIdAlmacen());
     cs.setString(13, objeto.getObservaciones());
     cs.setString(14, usuario.getNick());
     cs.setString(15, xml);
     cs.execute();
     cnn.close();
     cs.close();
   } catch (SQLException ex) {
     throw ex;
   }
 }
Exemple #9
0
  @Override
  public void setRelacionado2(String id, String nome) {
    try {
      btBuscarGrupo.setEnabled(false);
      qftfIdGrupo.setText("0");

      qftfIdUsuario.setText(id);
      jftfNomeUsuario.setText(nome);
      int idusuario = Integer.parseInt(id);
      Usuario u = new Usuario();
      u.setId(idusuario);
      controlePermissao.popularTabela(jTable1, u, false);

    } catch (Exception e) {
      System.err.println("Erro em setRelacionado2: " + e);
    }
  }
Exemple #10
0
 @Override
 public void adiciona(Usuario usuario) {
   if (usuario.getId() == null) {
     this.manager.persist(usuario);
   } else {
     this.manager.merge(usuario);
   }
 }
 public String cadastrarUsuario() {
   usuario.setContatos(new ArrayList<Contato>());
   DBSimulator.getInstance().criarUsuario(usuario);
   FacesContext.getCurrentInstance()
       .addMessage(
           null,
           new FacesMessage(FacesMessage.SEVERITY_INFO, "Usuário Cadastrado com Sucesso!", null));
   return "/login";
 }
 @Override
 public Usuario iniciarSesionUsuario(Integer idUsuario, String claveUsuario) throws Exception {
   if (idUsuario == null || claveUsuario == null) {
     throw new Exception("Los datos de ingreso son obligatorios");
   }
   if (claveUsuario.equals("")) {
     throw new Exception("La clave es obligatoria");
   }
   Usuario usuario = UsuarioDAO.find(idUsuario);
   if (usuario != null) {
     if (!usuario.getClaveUsuario().equals(claveUsuario)) {
       throw new Exception("La contraseña es incorrecta");
     }
   } else {
     throw new Exception("el usuario no existe");
   }
   return usuario;
 }
Exemple #13
0
  // método para deletar o obj
  public void deletar(Usuario u) {
    Usuario usuario = new Usuario();
    this.session = HibernateUtil.getSessionFactory().openSession();
    this.session.beginTransaction();

    usuario = (Usuario) this.session.load(Usuario.class, u.getId());

    this.session.delete(usuario);
    this.session.getTransaction().commit();
  }
Exemple #14
0
 public Usuario verificarUsuario(Usuario usuario) throws Exception {
   Usuario us = null;
   try {
     sesion = HibernateUtil.getSessionFactory().openSession();
     String hql =
         "FROM Usuario WHERE usuario_usuario='"
             + usuario.getUsuarioUsuario()
             + "' and usuario_contrasenia='"
             + usuario.getUsuarioContrasenia()
             + "'";
     Query query = sesion.createQuery(hql);
     if (!query.list().isEmpty()) {
       us = (Usuario) query.list().get(0);
     }
   } catch (Exception e) {
     throw e;
   }
   return us;
 }
 public void eliminar(DetalleFactura objeto, Usuario usuario) throws Exception {
   try {
     cnn = Conexion.getConexion();
     CallableStatement cs = null;
     cs = cnn.prepareCall("call uspUpdInactivarDetalleFactura(?,?)");
     cs.setInt(1, objeto.getIdDetalleFactura());
     cs.setString(2, usuario.getNick());
     cs.execute();
     cnn.close();
     cs.close();
   } catch (SQLException ex) {
     throw ex;
   }
 }
 /**
  * Método que se encarga de actualizar los datos generales de un tutor.
  *
  * @param correo Correo del tutor
  * @param contrasenia Contrasenia del tutor
  * @param nombre Nombre del tutor
  * @param ap Apellido paterno del tutor
  * @param am Apellido materno del tutor
  * @param cel Celular del tutor
  * @param ad Información del tutor
  * @return ID del tutor.
  */
 public int actualizaDatos(
     String correo, String contrasenia, String nombre, String ap, String am, long cel, String ad) {
   try {
     session.beginTransaction();
     Query p = session.getNamedQuery("BuscaPorCorreo").setString("correoUsuario", correo);
     Usuario u = (Usuario) p.uniqueResult();
     u.setCorreoUsuario(correo);
     u.setContraseniaUsuario(contrasenia);
     u.setNombreUsuario(nombre);
     u.setApellidoPaternoUsuario(ap);
     u.setApellidoMaternoUsuario(am);
     u.setTelefonoUsuario(cel);
     u.setAcercaDeUsuario(ad);
     session.persist(u);
     session.getTransaction().commit();
     return u.getIdUsuario();
   } catch (Exception e) {
     return -1;
   }
 }
 public void ingresar(DetalleFactura objeto, Usuario usuario) throws Exception {
   try {
     cnn = Conexion.getConexion();
     CallableStatement cs = null;
     cs = cnn.prepareCall("call uspInsDetalleFactura(?,?,?,?,?,?)");
     cs.setInt(1, objeto.getIdProducto());
     cs.setInt(2, objeto.getCantidad());
     cs.setDouble(3, objeto.getPrecio());
     cs.setDouble(4, objeto.getSubTotal());
     cs.setInt(5, objeto.getIdFactura());
     cs.setString(6, usuario.getNick());
     cs.execute();
     cnn.close();
     cs.close();
   } catch (SQLException ex) {
     throw ex;
   }
 }
 @Override
 public int getQtContatos(Usuario usuario) throws Exception {
   sql = new StringBuilder();
   sql.append("SELECT count(*) as quantidade  FROM Contato where nmLogin like ?");
   int quantidade = 0;
   try {
     cn = FabricaDeConexao.getConnection();
     stmt = cn.prepareStatement(sql.toString());
     stmt.setString(1, usuario.getNmLogin());
     System.out.println(stmt);
     rs = stmt.executeQuery();
     if (rs.next()) {
       quantidade = rs.getInt("quantidade");
     }
   } catch (SQLException e) {
     throw e;
   } finally {
     fecharConexoes();
   }
   return quantidade;
 }
  /**
   * Handles the HTTP <code>POST</code> method.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    PrintWriter out = response.getWriter();
    String nic_usu = request.getParameter("inputNombreUsuario");
    String con_usu = request.getParameter("inputPassword");

    String cor_usu = request.getParameter("inputCorreo");
    String nom_usu = request.getParameter("inputNombre");
    String apa_usu = request.getParameter("inputPaterno");
    String ama_usu = request.getParameter("inputMaterno");
    String tip_usu = request.getParameter("selRolUsuario");
    String gpo_alu = request.getParameter("inputGrupo");
    String bol_alu = request.getParameter("inputBoleta");

    try {
      Connection con = Conexion.getConexion();

      Usuario usuario = new Usuario();
      usuario.setNicUsu(nic_usu);
      usuario.setConUsu(con_usu);
      usuario.setIdTus(Integer.parseInt(tip_usu));

      ValidarUsuario validarUsuario = new ValidarUsuario(usuario);
      if (validarUsuario.esValido()) {
        UsuarioBD usuarioBD = new UsuarioBD();
        int idUsu = usuarioBD.insertarUsuario(con, usuario);
        System.out.println("La id insertada es: " + idUsu);
        usuario.setIdUsu(idUsu);
        TipoUsuario tipoUsuario = new TipoUsuario();
        TipoUsuarioBD tipoUsuarioBD = new TipoUsuarioBD();
        tipoUsuario = tipoUsuarioBD.getPorIdTus(con, usuario.getIdTus());
        String desTus = tipoUsuario.getDesTus();
        // Comprobar de que tipo de usuario se trata

        if (desTus.equals("Alumno")) {
          Alumno alumno = new Alumno();
          alumno.setIdUsu(usuario.getIdUsu());
          alumno.setAmaAlu(ama_usu);
          alumno.setApaAlu(apa_usu);
          alumno.setBolAlu(Integer.parseInt(bol_alu));
          alumno.setCorAlu(cor_usu);
          alumno.setNomAlu(nom_usu);
          alumno.setGpoAlu(gpo_alu);
          ValidarAlumno validarAlumno = new ValidarAlumno(alumno);

          if (validarAlumno.esValido()) {
            System.out.println("===El alumno es valido===");
            AlumnoBD alumnoBD = new AlumnoBD();
            alumnoBD.insertarAlumno(con, alumno);
          } else {
            System.out.println("===El alumno no es valido===");
          }
        } else if (desTus.equals("Profesor")) {
          Bd.addProfesor(con, idUsu, apa_usu, ama_usu, nom_usu, cor_usu);
        } else if (desTus.equals("Tecnico")) {
          Bd.addTecnico(idUsu, apa_usu, ama_usu, nom_usu, cor_usu);
        }
      }
      con.close();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
    /*
    try{
        if(Bd.usuarioNuevo(nic_usu)){
            Bd.addUsuario(nic_usu, con_usu, Integer.parseInt(tip_usu));
            int idUser = Bd.getIdUsuario(nic_usu, con_usu);
            if(Bd.getDescTipoUsuario(Integer.parseInt(tip_usu)).equals("Alumno")){
                Bd.addAlumno(idUser, apa_usu, ama_usu, nom_usu, gpo_alu, Integer.parseInt(bol_alu), cor_usu);
            }else if(Bd.getDescTipoUsuario(Integer.parseInt(tip_usu)).equals("Profesor")){
                Bd.addProfesor(idUser, apa_usu, ama_usu, nom_usu, cor_usu);
            }else if(Bd.getDescTipoUsuario(Integer.parseInt(tip_usu)).equals("Tecnico")){
                Bd.addTecnico(idUser, apa_usu, ama_usu, nom_usu, cor_usu);
            }
        }else{
            out.println("El nombre de usuario ya existe");
        }
    }catch (ClassNotFoundException ex) {
    Logger.getLogger(AgregarUsuario.class.getName()).log(Level.SEVERE, null, ex);
    }catch (SQLException ex) {
    Logger.getLogger(AgregarUsuario.class.getName()).log(Level.SEVERE, null, ex);
    }*/

    response.sendRedirect("admin/agregar-usuario.jsp");
  }
Exemple #20
0
 public static void main(String args[]) {
   for (Usuario u : new UsuarioDao().listar()) {
     System.out.println(u.getNome());
   }
 }
Exemple #21
0
 @Override
 public void remover(Usuario usuario) {
   Usuario UserASerRemovido = manager.getReference(Usuario.class, usuario.getId());
   this.manager.remove(UserASerRemovido);
 }
 public static int retornaId(String login) {
   UsuarioDAO dao = new UsuarioDAO();
   Usuario u = dao.findByCollumPalavra("login", login);
   return u.getId();
 }
  @Override
  public void procesarEvento(Evento evento) {
    Evento eventoRespuesta = null;

    switch (evento.getTipoEvento()) {
      case SALIR:
        System.out.println("Saliendo");
        System.exit(1);
        break;
      case LOGIN:
        if (!evento.getInfo().getClass().getName().equals("Modelo.Login")) {
          assert false : evento.getInfo().getClass().getName() + " clase invalida";
        } else {
          Login login = (Login) evento.getInfo();
          System.out.println("Intento acceso para: " + login.toString());
          Usuario usuario;
          try {
            usuario = biblioteca.login(login.getNombre(), login.getClave());
            ((Usuario) usuario).setLookAndFeel(login.getLookAndFeel());
            // System.out.println("---"+usuario.getClass().getSimpleName()+"-");
            eventoRespuesta = new Evento(TipoEvento.LOGIN_OK, usuario);
          } catch (Exception ex) {
            // Logger.getLogger(Controlador.class.getName()).log(Level.SEVERE, null, ex);
            System.err.println("ERROR");
            eventoRespuesta = new Evento(TipoEvento.LOGIN_FALLO);
          }
          evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
        }

        break;
      case LOGOUT:
        evento.getDestinoRespueta().procesarEvento(new Evento(TipoEvento.LOGOUT));
        break;
      case OBTENER_CAT_DEWEY:
        evento
            .getDestinoRespueta()
            .procesarEvento(
                new Evento(TipoEvento.OBTENER_CAT_DEWEY, biblioteca.getCategoriasDewey()));
        break;

      case CONSULTA_CATALOGO_GENERAL:
        System.out.println("CONSULTA_CATALOGO_GENERAL");
        try {

          Catalogo catalogo = biblioteca.getAlberga();
          eventoRespuesta = new Evento(TipoEvento.CONSULTA_CATALOGO_GENERAL, catalogo);

        } catch (Exception ex) {
          Logger.getLogger(Controlador.class.getName()).log(Level.SEVERE, null, ex);
          System.err.println("CONSULTA_CATALOGO_GENERAL: ERROR");
          eventoRespuesta = new Evento(TipoEvento.ERROR);
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
        break;
      case CONSULTA_CATALOGO_CONCRETA:
        System.out.println("CONSULTA_CATALOGO_CONCRETA" + evento.getInfo().getClass().getName());
        if (!evento.getInfo().getClass().getName().startsWith("HBM.TituloId")) {
          assert false : evento.getInfo().getClass().getName() + " clase invalida";
        }

        try {
          TituloId tituloId = (TituloId) evento.getInfo();

          Titulo titulo = biblioteca.getAlberga().getCatalogo().get(tituloId);
          eventoRespuesta = new Evento(TipoEvento.CONSULTA_CATALOGO_CONCRETA, titulo);

        } catch (Exception ex) {
          Logger.getLogger(Controlador.class.getName()).log(Level.SEVERE, null, ex);
          System.err.println("CONSULTA_CATALOGO_CONCRETA: ERROR");
          eventoRespuesta = new Evento(TipoEvento.ERROR);
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
        break;

      case LISTADO_USUARIOS:
        System.out.println("Listado de usuarios");
        try {

          GestorUsuarios gestorUsuarios = biblioteca.getUsuarios();
          eventoRespuesta = new Evento(TipoEvento.LISTADO_USUARIOS, gestorUsuarios);

        } catch (Exception ex) {
          Logger.getLogger(Controlador.class.getName()).log(Level.SEVERE, null, ex);
          System.err.println("LISTADO_USUARIOS: ERROR");
          eventoRespuesta = new Evento(TipoEvento.LISTADO_USUARIOS_ERROR);
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
        break;
      case ALTA_USUARIO:
        Usuario usuario = (Usuario) evento.getInfo();
        try {
          biblioteca.altaUsuario(usuario);
          eventoRespuesta = new Evento(TipoEvento.ALTA_USUARIO_OK);

        } catch (Exception ex) {
          eventoRespuesta = new Evento(TipoEvento.ALTA_USUARIO_ERROR);
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
        break;

      case MODIFICACION_TITULO:
        Titulo titulo = (Titulo) evento.getInfo();
        try {
          biblioteca.modificacionTitulo(titulo);
          eventoRespuesta = new Evento(TipoEvento.MODIFICACION_TITULO_OK, titulo.getId());

        } catch (Exception ex) {
          eventoRespuesta = new Evento(TipoEvento.MODIFICACION_TITULO_ERROR, titulo.getId());
          System.out.println("Error en modificacion de título");
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);

        break;
      case BAJA_TITULO:
        System.out.println("Controlador BAJA_TITULO");

        TituloId tituloId = ((Titulo) evento.getInfo()).getId();
        try {
          biblioteca.bajaTitulo(tituloId);
          eventoRespuesta = new Evento(TipoEvento.BAJA_TITULO_OK, tituloId);
        } catch (Exception ex) {
          eventoRespuesta = new Evento(TipoEvento.BAJA_TITULO_ERROR, tituloId);
        }
        evento.getDestinoRespueta().procesarEvento(eventoRespuesta);
    }
  }