public void ImprimirColeccion() {
int i;
Usuario registro;
/*
* Se define un arreglo de tipo Object (la clase genérica Java)
*/
Object[] arreglo;
/*
* Se convierte la colección pasada como parámetro a un array, que
* es asignado al arreglo de tipo Object
*/
arreglo = UsuariosRegistrados.toArray();
System.out.println("DATOS");
/*
* Se hace un recorrido del arreglo de tipo Object y se imprime
* la información de la casilla i
*/
for (i = 0; i < arreglo.length; i++) {
registro = (Usuario) arreglo[i];
System.out.println("Nick: " + registro.getNickname());
System.out.println("Clave: " + registro.getClave());
System.out.println("Nombre" + registro.getNombre());
System.out.println();
}
System.out.println("\n\n");
}
/**
* excluir
*
* @param VO Usuario
* @return boolean
*/
public static boolean excluir(Usuario usuario) {
SigeDataBase db = new SigeDataBase();
try {
db.getConn().setAutoCommit(false);
db.prepareStatement("DELETE FROM permissao_usuario WHERE cd_usuario=?");
db.setInt(1, usuario.getCodigo());
db.executeUpdate();
db.getPreparedStatement().close();
db.prepareStatement("DELETE FROM usuarios WHERE cd_usuario=?");
db.setInt(1, usuario.getCodigo());
db.executeUpdate();
db.getConn().commit();
db.closeConnection();
return true;
} catch (SQLException ex) {
ex.printStackTrace();
try {
db.getConn().rollback();
db.closeConnection();
} catch (SQLException ex1) {
ex1.printStackTrace();
db.closeConnection();
}
return false;
}
}
public Usuario BuscarUsuarioDevolver(Usuario objeto) {
boolean encontrado = false;
Usuario auxiliar = null;
/*
* Se define un iterador inicializado con el iterador de la colección
*/
Iterator iterador = UsuariosRegistrados.iterator();
/*
* Mientras no se encuentre el elemento y existan mas elementos en la
* colección, se sigue entrando en el ciclo
*/
while (!encontrado && iterador.hasNext()) {
/*
* Se obtiene el siguiente objeto del iterador y se le hace un cast
* para asignarlo al objeto de tipo Nodo
*/
auxiliar = (Usuario) iterador.next();
/*
* Se invoca al método equals de la clase Nodo para determinar si son
* iguales. En caso de serlo, se encontró el elemento buscado
*/
// if (objeto.equals(auxiliar))
if ((objeto.getNickname().contentEquals(auxiliar.getNickname()))
&& (objeto.getClave().contentEquals(auxiliar.getClave()))) return (auxiliar);
}
return (objeto);
}
public void registrar(Usuario usuario) {
Entidad eUsuario = this.usuario_a_entidad(usuario);
eUsuario = servPersistencia.registrarEntidad(eUsuario);
usuario.setId(eUsuario.getId());
pool.put(eUsuario.getId(), usuario);
}
/**
* Funcion que utiliza el servidor de autenticacion para autenticar a los usuarios provistos
*
* @param usuarios Lista con los usuarios a autenticar
* @param puerto El puerto para conectarse al servidor de autenticacion
* @return Booleano que indica si se pudo autenticar.
* @throws MalformeURLException En caso de una URL mal formada
* @throws RemoteException En caso de que el objeto remoto no este disponible
* @throws NotBoundException En caso de que no se logre hacer el lookup
*/
public static boolean autenticarCliente(ArrayList<Usuario> usuarios, int puerto) {
// Acceder al servidor remoto de autenticacion
String nActual = null;
String cActual = null;
boolean autenticado = false;
try {
s_rmifs_Interface auth =
(s_rmifs_Interface) Naming.lookup("rmi://" + servidor + ":" + puerto + "/s_rmifs");
for (Usuario usuActual : usuarios) {
nActual = usuActual.getUsuario();
cActual = usuActual.getClave();
if (auth.autenticar(nActual, cActual)) {
autenticado = true;
break;
}
}
// Manejo de excepciones.
} catch (MalformedURLException murle) {
System.out.println();
System.out.println("MalformedURLException");
System.out.println(murle);
} catch (RemoteException re) {
System.out.println();
System.out.println("RemoteException");
System.out.println(re);
} catch (NotBoundException nbe) {
System.out.println();
System.out.println("NotBoundException");
System.out.println(nbe);
}
// Si el usuario fue autenticado, guardar sus datos
if (autenticado) {
nombreCliente = nActual;
claveCliente = cActual;
}
return autenticado;
}
/**
* buscaPorLogin
*
* @param nome String
* @return ArrayList
*/
public static ArrayList<Usuario> buscaPorLogin(String login) {
SigeDataBase db = new SigeDataBase();
try {
String query =
"SELECT cd_usuario as codigo, nome_usuario as nome,"
+ " cd_entidade as entidade, login, decode(senha,'base64')"
+ " as senha, cpf, ativo FROM usuarios WHERE lower(login) LIKE lower(?) ORDER BY nome_usuario";
db.setPreparedStatement(
db.getConn()
.prepareStatement(
query, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY));
db.setString(1, '%' + login + '%');
ResultSet rs = db.executeQuery();
if (rs.next()) {
ArrayList<Usuario> resultado = new ArrayList<Usuario>();
do {
Usuario usuario = new Usuario();
Entidade entidade = (Entidade) EntidadeDAO.buscaPorCodigo(rs.getInt("entidade"));
if (entidade != null) {
usuario.setEntidade(entidade);
} else {
throw new SQLException("Entidade Não Existe");
}
usuario.setCodigo(rs.getInt("codigo"));
usuario.setNomeCompleto(rs.getString("nome"));
usuario.setLogin(rs.getString("login"));
usuario.setSenha(rs.getString("senha"));
usuario.setCPF(rs.getString("cpf"));
usuario.setPermissoes(PermissaoDAO.buscaPorUsuario(usuario));
usuario.setAtivo(rs.getBoolean("ativo"));
resultado.add(usuario);
} while (rs.next());
rs.close();
db.closeConnection();
return resultado;
}
db.closeConnection();
return null;
} catch (SQLException ex) {
ex.printStackTrace();
return null;
}
}
/**
* buscaPorCodigo
*
* @param codigo int
* @return Usuario
*/
public static Usuario buscaPorCodigo(int codigo) {
SigeDataBase db = new SigeDataBase();
try {
String query =
"SELECT cd_usuario as codigo, ativo, nome_usuario "
+ "as nome, cd_entidade as entidade, login,"
+ " decode(senha,'base64') as senha, cpf FROM usuarios"
+ " WHERE cd_usuario=? ORDER BY nome_usuario";
db.prepareStatement(query);
db.setInt(1, codigo);
ResultSet rs = db.executeQuery();
if (rs.next()) {
Usuario usuario = new Usuario();
Entidade entidade = EntidadeDAO.buscaPorCodigo(rs.getInt("entidade"));
if (entidade != null) {
usuario.setEntidade(entidade);
} else {
throw new SQLException("Entidade Nao Existe");
}
usuario.setCodigo(rs.getInt("codigo"));
usuario.setNomeCompleto(rs.getString("nome"));
usuario.setLogin(rs.getString("login"));
usuario.setSenha(rs.getString("senha"));
usuario.setCPF(rs.getString("cpf"));
usuario.setAtivo(rs.getBoolean("ativo"));
usuario.setPermissoes(PermissaoDAO.buscaPorUsuario(usuario));
rs.close();
db.closeConnection();
return usuario;
}
db.closeConnection();
return null;
} catch (SQLException ex) {
ex.printStackTrace();
return null;
}
}
/**
* incluir
*
* @param VO Usuario
* @return boolean
*/
public static boolean incluir(Usuario usuario) {
SigeDataBase db = new SigeDataBase();
String query =
"INSERT INTO usuarios(cd_usuario,cd_entidade,nome_usuario,cpf,login,senha,ativo)"
+ " VALUES(default, ?, ?, ?, ?, encode( ?,'base64'), ?)";
try {
Statement stmt = db.getConn().createStatement();
ResultSet rs = stmt.executeQuery("SELECT last_value as codigo FROM usuarios_cd_usuario_seq");
rs.next();
int codigo = rs.getInt("codigo") + 1;
usuario.setCodigo(codigo);
db.getConn().setAutoCommit(false);
db.prepareStatement(query);
db.setInt(1, usuario.getEntidade().getCodigo());
db.setString(2, usuario.getNomeCompleto());
db.setString(3, usuario.getCPF());
db.setString(4, usuario.getLogin());
if (usuario.getSenha() != null) {
db.setString(5, usuario.getSenha());
} else {
db.setString(5, "");
}
db.setBoolean(6, usuario.isAtivo());
db.executeUpdate();
db.getPreparedStatement().close();
db.prepareStatement("INSERT INTO permissao_usuario(cd_usuario, cd_permissao) VALUES(?,?)");
for (int i = 0; i < usuario.getPermissoes().length; i++) {
db.setInt(1, usuario.getCodigo());
db.setInt(2, usuario.getPermissoes()[i].getCodigo());
db.executeUpdate();
}
db.getConn().commit();
db.closeConnection();
return true;
} catch (SQLException ex) {
try {
db.getConn().rollback();
db.closeConnection();
ex.printStackTrace();
} catch (SQLException ex1) {
System.out.println("Erro de SQL: " + ex1.getMessage());
ex1.printStackTrace();
}
return false;
}
}
/**
* salvarAlteracoes
*
* @param VO Usuario
* @return boolean
*/
public static boolean salvarAlteracoes(Usuario usuario) {
SigeDataBase db = new SigeDataBase();
try {
db.getConn().setAutoCommit(false);
String query =
"UPDATE usuarios SET cd_usuario=?, cd_entidade=?, nome_usuario=?, login=?, cpf=?, ativo=?";
if (usuario.getSenha() != null) {
query += ", senha=encode('" + usuario.getSenha() + "','base64')";
}
query += " WHERE cd_usuario=?";
db.prepareStatement(query);
db.setInt(1, usuario.getCodigo());
db.setInt(2, usuario.getEntidade().getCodigo());
db.setString(3, usuario.getNomeCompleto());
db.setString(4, usuario.getLogin());
db.setString(5, usuario.getCPF());
db.setBoolean(6, usuario.isAtivo());
db.setInt(7, usuario.getCodigo());
db.executeUpdate();
db.getPreparedStatement().close();
// exclui as permissões anteriores
db.prepareStatement("DELETE FROM permissao_usuario WHERE cd_usuario=?");
db.setInt(1, usuario.getCodigo());
db.executeUpdate();
db.getPreparedStatement().close();
// inclui as novas permissões
db.prepareStatement(
"INSERT INTO permissao_usuario(cd_usuario, cd_permissao)" + " VALUES(?,?)");
for (int i = 0; i < usuario.getPermissoes().length; i++) {
db.setInt(1, usuario.getCodigo());
db.setInt(2, usuario.getPermissoes()[i].getCodigo());
db.executeUpdate();
}
db.getConn().commit();
db.closeConnection();
return true;
} catch (SQLException ex) {
ex.printStackTrace();
try {
db.getConn().rollback();
db.closeConnection();
} catch (SQLException ex1) {
db.closeConnection();
ex1.printStackTrace();
}
}
return false;
}
public Usuario recuperar(int id) {
// Recuperamos del pool
Usuario usuario = pool.get(id);
if (usuario == null) { // No está registrado en el pool de usuarios, hay que ir a la bd
Entidad eUsuario = servPersistencia.recuperarEntidad(id);
/* Se recuperan primero aquellos atributos que no dependen de recuperar otra entidad */
String nombre = servPersistencia.recuperarPropiedadEntidad(eUsuario, "nombre");
String apellidos = servPersistencia.recuperarPropiedadEntidad(eUsuario, "apellidos");
String dni = servPersistencia.recuperarPropiedadEntidad(eUsuario, "dni");
String email = servPersistencia.recuperarPropiedadEntidad(eUsuario, "email");
String login = servPersistencia.recuperarPropiedadEntidad(eUsuario, "login");
String password = servPersistencia.recuperarPropiedadEntidad(eUsuario, "password");
/* Se crea el usuario con los atributos actuales */
usuario = new Usuario(nombre, apellidos, dni, email, login, password);
usuario.setId(id);
/* Se introduce en el pool para evitar ciclos de llamadas recursivas */
pool.put(id, usuario);
/* Se recupera el resto de atributos */
ProyectoDAO proyectoDAO = factoriaDAO.getProyectoDAO();
String idproyectosVotados = servPersistencia.recuperarPropiedadEntidad(eUsuario, "votos");
LinkedList<Proyecto> pVotados = new LinkedList<>();
if (idproyectosVotados.length() > 0) {
for (String idVotado : idproyectosVotados.split(";")) {
pVotados.add(proyectoDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setVotos(pVotados);
String idproyectosCreados =
servPersistencia.recuperarPropiedadEntidad(eUsuario, "proyectoscreados");
LinkedList<Proyecto> pCreados = new LinkedList<Proyecto>();
if (idproyectosCreados.length() > 0) {
for (String idVotado : idproyectosCreados.split(";")) {
pCreados.add(proyectoDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setproyectosCreados(pCreados);
ApoyoDAO apoyoDAO = factoriaDAO.getApoyoDAO();
String idApoyos = servPersistencia.recuperarPropiedadEntidad(eUsuario, "apoyos");
LinkedList<Apoyo> apoyos = new LinkedList<>();
if (idApoyos.length() > 0) {
for (String idVotado : idApoyos.split(";")) {
apoyos.add(apoyoDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setApoyos(apoyos);
NotificacionDAO notificacionDAO = factoriaDAO.getNotificacionDAO();
String idNotificaciones =
servPersistencia.recuperarPropiedadEntidad(eUsuario, "notificaciones");
LinkedList<Notificacion> notificaciones = new LinkedList<>();
if (idNotificaciones.length() > 0) {
for (String idVotado : idNotificaciones.split(";")) {
notificaciones.add(notificacionDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setNotificaciones(notificaciones);
PreguntaDAO preguntaDAO = factoriaDAO.getPreguntaDAO();
String idPreguntasEmitidas =
servPersistencia.recuperarPropiedadEntidad(eUsuario, "preguntasemitidas");
LinkedList<Pregunta> pEmitidas = new LinkedList<>();
if (idPreguntasEmitidas.length() > 0) {
for (String idVotado : idPreguntasEmitidas.split(";")) {
pEmitidas.add(preguntaDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setPreguntasEmitidas(pEmitidas);
String idPreguntasRecibidas =
servPersistencia.recuperarPropiedadEntidad(eUsuario, "preguntasrecibidas");
LinkedList<Pregunta> pRecibidas = new LinkedList<>();
if (idPreguntasRecibidas.length() > 0) {
for (String idVotado : idPreguntasRecibidas.split(";")) {
pRecibidas.add(preguntaDAO.recuperar(Integer.parseInt(idVotado)));
}
}
usuario.setPreguntasRecibidas(pRecibidas);
}
return usuario;
}
/** Actualiza la información del usuario en la BBDD */
public void actualizarUsuario(Usuario usuario) {
Entidad eUsuario = servPersistencia.recuperarEntidad(usuario.getId());
Entidad newEUsuario = usuario_a_entidad(usuario);
eUsuario.setPropiedades(newEUsuario.getPropiedades());
servPersistencia.modificarEntidad(eUsuario);
}
private Entidad usuario_a_entidad(Usuario usuario) {
/* Crear entidad */
Entidad eUsuario = new Entidad();
eUsuario.setNombre("usuario"); /*"tipo" de entidad */
/* crear propiedades y rellenar datos */
StringBuilder votos = new StringBuilder();
for (Proyecto p : usuario.getVotos()) {
votos.append(p.getId());
votos.append(';');
}
StringBuilder proyectosCreados = new StringBuilder();
for (Proyecto p : usuario.getProyectosCreados()) {
proyectosCreados.append(p.getId());
proyectosCreados.append(';');
}
StringBuilder apoyos = new StringBuilder();
for (Apoyo a : usuario.getApoyos()) {
apoyos.append(a.getId());
apoyos.append(';');
}
StringBuilder notificaciones = new StringBuilder();
for (Notificacion n : usuario.getNotificaciones()) {
notificaciones.append(n.getId());
notificaciones.append(';');
}
StringBuilder preguntasemitidas = new StringBuilder();
for (Pregunta p : usuario.getPreguntasEmitidas()) {
preguntasemitidas.append(p.getId());
preguntasemitidas.append(';');
}
StringBuilder preguntasrecibidas = new StringBuilder();
for (Pregunta p : usuario.getPreguntasRecibidas()) {
preguntasrecibidas.append(p.getId());
preguntasrecibidas.append(';');
}
eUsuario.setPropiedades(
new ArrayList<Propiedad>(
Arrays.asList(
new Propiedad("nombre", usuario.getNombre()),
new Propiedad("apellidos", usuario.getApellidos()),
new Propiedad("dni", usuario.getDni()),
new Propiedad("email", usuario.getEmail()),
new Propiedad("login", usuario.getLogin()),
new Propiedad("password", usuario.getPassword()),
new Propiedad("votos", votos.toString()),
new Propiedad("proyectoscreados", proyectosCreados.toString()),
new Propiedad("apoyos", apoyos.toString()),
new Propiedad("notificaciones", notificaciones.toString()),
new Propiedad("preguntasemitidas", preguntasemitidas.toString()),
new Propiedad("preguntasrecibidas", preguntasrecibidas.toString()))));
return eUsuario;
}
public boolean borrar(Usuario usuario) {
Entidad eUsuario = servPersistencia.recuperarEntidad(usuario.getId());
return servPersistencia.borrarEntidad(eUsuario);
}
/**
* Método public static void guardarArchivoXML(ListaUsuarios listaDeUsuarios): Este método permite
* guardar la lista de usuarios en un archivo XML. El procesamiento se hace con jdom
*/
public static void guardarArchivoXML(ListaUsuario listaDeUsuarios) {
Usuario nodoAuxiliar;
/* Se crea una raiz de la estructura */
Element root = new Element("usuarios");
/* Es posible agregar atributos a la estructura inicial */
root.setAttribute("tipo", "lista de usuarios");
Iterator iterador = listaDeUsuarios.getIterator();
while (iterador.hasNext()) {
/* Se crea la etiqueta "usuario" */
Element usuarios = new Element("usuario");
nodoAuxiliar = (Usuario) iterador.next();
/* Se crean las etiquetas nombre, apellido y cargo */
Element nick = new Element("nick");
Element clave = new Element("clave");
Element nombre = new Element("nombre");
Element apellido = new Element("apellido");
Element fechanac = new Element("fechanac");
Element avatar = new Element("avatar");
/* Se inicializa cada etiqueta con sus valores de la lista */
nick.setText(nodoAuxiliar.getNickname());
clave.setText(nodoAuxiliar.getClave());
nombre.setText(nodoAuxiliar.getNombre());
apellido.setText(nodoAuxiliar.getApellido());
fechanac.setText(nodoAuxiliar.getFechanaci());
avatar.setText(nodoAuxiliar.getAvatar());
/* Se añaden las etiquetas a la etiqueta principal (usuario) */
/* estableciendo que un usuario tiene nombre, apellido y cargo */
usuarios.addContent(nick);
usuarios.addContent(clave);
usuarios.addContent(nombre);
usuarios.addContent(apellido);
usuarios.addContent(fechanac);
usuarios.addContent(avatar);
/* Se añade el nuevo usuario a la estructura XML */
root.addContent(usuarios);
}
/* Se crea un documento nuevo */
Document doc = new Document(root);
try {
/* Se genera un flujo de salida de datos XML */
XMLOutputter out = new XMLOutputter();
/* Se asocia el flujo de salida con el archivo donde se guardaran los datos */
FileOutputStream file = new FileOutputStream(nombreArchivo);
/* Se manda el documento generado hacia el archivo XML */
out.output(doc, file);
/* Se limpia el buffer ocupado por el objeto file y se manda a cerrar el archivo */
file.flush();
file.close();
/* En este caso se manda a imprimir el archivo por la consola */
/* ESTE PROCESO NO ES OBLIGATORIO PARA PROCESAR EL XML */
out.output(doc, System.out);
} catch (Exception e) {
e.printStackTrace();
}
}
