VALIDADOR

Este es un proyecto que se realizo aplicando los patrones prototipe y singleton
haciendo una conexion a base de datos para la validación de usuarios a un sistema.

package co.edu.udistrital.validador.bd;

import java.sql.*;

/**
* Clase encargada de realizar la conexion con la base de datos esta misma clase se encarga de consultar y hacer persistencia de datos.
*/
public class Conexion {

static private String bd = "validador";
static private String login = "usuario2";
static private String password = "1234";
static private String url = "jdbc:mysql://localhost/" + bd;
static private Conexion conex = null;
private String CadenaSql;
private Connection conexion = null;

/**
* el contructor se encargada de realizar la conexion a la base de datos
* y muestra en consola mensajes si se pudo o no conectar a labase de datos.
*/
private Conexion() {
try {
System.out.println("Tratando de cargar el driver");
Class.forName("com.mysql.jdbc.Driver");
conexion = DriverManager.getConnection(url, login, password);
if (conexion != null) {
System.out.println("Conexion a base de datos " + bd + " OK");
}
} catch (SQLException sqlEx) {
System.out.println(sqlEx);
} catch (ClassNotFoundException ex) {
System.out.println(ex);
}
}

public String EjecutarSql() {
try {
Statement stmt = conexion.createStatement();
stmt.executeUpdate(CadenaSql);

} catch (SQLException ex) {

System.out.println("Totio");
}
return ("Fue un exito");
}

/**
*
* Funcion encargada de realizar las consultas para poder usarla debe existir
* una conexion a base de datos
*
*
* @return ResultSet
*/
public ResultSet Consultar() {
ResultSet tabla = null;
try {
Statement stmt = conexion.createStatement();
tabla = stmt.executeQuery(CadenaSql);
} catch (SQLException ex) {
System.out.println(ex);
}
return tabla;
}

/**
* Setter que asigna el valor a la cadenaSql
*
* @param String cadena;
*/
public void setCadena(String cadena) {
CadenaSql = cadena;
}

/**
* getter que retorna
*
* @return Connection;
*/
public Connection getConectar() {
return conexion;
}

/**
* Funcion encargada de realizar la desconexion a base de datos
*/
public void desconectar() {
conexion = null;
}

/**
* Funcion encargada de retornar el objeto conexion y garantiza que la clase se instancie una sola vez.
* @return Conexion
* @uml.property name="conexion"
*/
static public Conexion getConexion() {
if (conex == null) {
conex = new Conexion();
}
return conex;
}
}

package co.edu.udistrital.validador.Logica;

/**
* Clase que implementa la interface Cloneable
*/
public abstract class Usuario implements Cloneable {

private String tipoDeUsuario = "NaDa";
private boolean obtenerUsuarios = false;
private boolean entrarSistema = false;
private boolean eliminarUsuario = false;
private boolean modificarUsuario = false;
private boolean adicionarUsuario = false;
private String nombre;
private String identificacion;
private String apellido;

/**
* metodo que recibe el nombre del tipo de Usuario
* @param String
* @uml.property name="tipoDeUsuario"
*/
public void setTipoDeUsuario(String usuario) {
this.tipoDeUsuario = usuario;

}


/**
* metodo que recibe el valor boolena de entrarsistema
* @param boolean
* @uml.property name="entarSistema"
*/
public void setEntrarSistema(boolean b) {
this.entrarSistema = b;
}

/**
* metodo que recibe el valor boolena de obtenerUsuarios
* @param boolean
* @uml.property name="obtenerUsuarios"
*/
public void setObtenerUsuario(boolean b) {
this.obtenerUsuarios = b;
}

/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setEliminarUsuario(boolean b) {
this.eliminarUsuario = b;

}
/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setModifiarUsuario(boolean b) {
this.modificarUsuario = b;


}
/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setAdicionarUsuario(boolean b) {
this.adicionarUsuario = b;

}
public void setIdentificacion(String identificacion) {
this.identificacion = identificacion;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public void setapellido(String apellido) {
this.apellido = apellido;
}
public boolean getEliminarUsuario(){
return this.eliminarUsuario;
}
public boolean getObtenerUsuario(){
return this.obtenerUsuarios;
}
public boolean getModifiarUsuario(){
return this.modificarUsuario;
}
public String getTipoDeUsuario() {
return this.tipoDeUsuario;
}
public boolean getAdicionarUsuario(){
return this.adicionarUsuario;
}
public String getIdentificacion() {
return identificacion;
}

public String getNombre() {
return nombre;
}

public String getApellido() {
return apellido;
}

public String adicionarUsuario() {
String CadenaSQL;
if (adicionarUsuario) {
CadenaSQL = "INSERT INTO clientes VALUES('" + this.nombre + "','" + this.apellido + "','" + this.identificacion + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String modificarUsuario() {
String CadenaSQL;
if (modificarUsuario) {
CadenaSQL = "UPDATE clientes SET apellido = '" + this.apellido + "', documento = '" + this.identificacion + "' WHERE (nombre = '" + this.nombre + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}

}

public String eliminarUsusario() {
String CadenaSQL;
if (eliminarUsuario) {
CadenaSQL = "DELETE FROM clientes WHERE(nombre = '" + this.nombre + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String consultarUsuarios() {
String CadenaSQL;
if (obtenerUsuarios) {
CadenaSQL = "SELECT * FROM clientes";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String consultarUnUsuario() {
String CadenaSQL;
CadenaSQL = "SELECT * FROM clientes WHERE(nombre = '" + this.nombre + "')";
return CadenaSQL;
}

}

package co.edu.udistrital.validador.Logica;
/**
* Clase que define un tipo de usuario, hereda de la clase Usuario
*/

public class TipoUsuarioA extends Usuario{
/**
* Metodo heredado de la clase usuario, que a su vez implementa
* la interface Cloneable
*
* @return Object
*/
public Object clone(){
Object o=null;
try{
o=super.clone();
}catch(CloneNotSupportedException e){
System.out.println("Error en tiempo de clonacion");
}
return o;
}

/**
* Metodo que crea la clonacion y ejecuta la autoclonacion
*
* @return Usuario
*/
public Usuario copiarTipo(){
Usuario a=(Usuario)clone();
a.setTipoDeUsuario("Usuario de Tipo A");
a.setEntrarSistema(true);
a.setObtenerUsuario(true);
a.setEliminarUsuario(true);
a.setAdicionarUsuario(true);
a.setModifiarUsuario(true);
return a;
}

}

package co.edu.udistrital.validador.Logica;

/**
* Clase que define un tipo de usuario, hereda de la clase Usuario
*/
public class TipoUsuarioB extends Usuario {
/**
* Metodo heredado de la clase usuario, que a su vez implementa
* la interface Cloneable
*
* @return Object
*/
public Object clone() {
Object o = null;
try {
o = super.clone();
} catch (CloneNotSupportedException e) {
System.out.println("Error en tiempo de clonacion");
}
return o;
}

/**
* Metodo que crea la clonacion y ejecuta la autoclonacion
*
* @return Usuario
*/
public Usuario copiarTipo() {
Usuario a = (Usuario) clone();
a.setTipoDeUsuario("Usuario de Tipo B");
a.setEntrarSistema(true);
a.setModifiarUsuario(true);
return a;
}
}

package co.edu.udistrital.validador.Logica;

import co.edu.udistrital.validador.bd.Conexion;
import java.sql.*;

/**
* Clase que valida ingreso a los tipos de ususario. Esta clase implementa el patron Singleton ya que solo se necesita una instancia de esta.
*/
public class Validador {

private Conexion conexion;
private int tipoUsuario=0;
private boolean valida;
private String usuario;
private String clave;

/**
* Retorna el numero de clave validada que ingreso el cliente
* @return int
* @uml.property name="tipoUsuario"
*/
public int getTipoUsuario() {
return this.tipoUsuario;
}

public Validador() {
//Crea una instancia de la clase conexion
conexion = Conexion.getConexion();
}

/**
* consulta la tabla usuarios en la base de datos y valida
* segun la clave ingresado por el cliente
*
* @param String
* @return int
*/
public boolean validar(String cla, String usu) {
this.valida = false;
this.clave = cla;
this.usuario=usu;
conexion.setCadena("SELECT * FROM usuarios where login ='"+usuario+"'");
ResultSet tabla = conexion.Consultar();
try {
while (tabla.next()) {
if (this.clave.compareTo(tabla.getString("clave"))==0) {
this.tipoUsuario = Integer.parseInt(tabla.getString("tipo"));
this.valida = true;
}

}
} catch (SQLException ex) {
System.out.println("Problemas con la tabla");
}
return this.valida;
}
}

package co.edu.udistrital.validador.presentacion;

import co.edu.udistrital.validador.Logica.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


/**
* Clase que se encarga de generar la interfaz gr�fica y de relacionarla co la l�gica
*/

public class Presentacion implements ActionListener {

//atributos de la GUI
private JFrame frame;
private JButton aceptar;
private JButton clear;
private JLabel log;
private JLabel pass;
private JPasswordField txtpassword;
private JTextField txtloging;
private Container pane;

//atributos de validacion y usuarios
private Validador val;
private TipoUsuarioA TipoA;
private TipoUsuarioB TipoB;
private Usuario usuario = null;

/**
* El costructor de la clase inicializa todos los componentes de la GUI
*
*/

public Presentacion() {
frame = new JFrame("Validador");
aceptar = new JButton("Aceptar");
clear = new JButton("Cls");
log= new JLabel("Usuario: ");
pass= new JLabel("Password: ");
txtpassword = new JPasswordField(0);
txtloging = new JTextField(0);
pane = new JPanel();
val = new Validador();

TipoA = new TipoUsuarioA();
TipoB = new TipoUsuarioB();

pane = frame.getContentPane();
pane.setLayout(null);

log.setBounds(30, 20, 100, 20);
pass.setBounds(30, 60, 100, 20);
txtloging.setBounds(130, 20 , 200, 25);
txtpassword.setBounds(130, 60, 200, 25);
aceptar.setBounds(240, 120, 90, 30);
clear.setBounds(30, 120, 90, 30);
aceptar.addActionListener(this);
clear.addActionListener(this);

frame.add(clear);
frame.add(aceptar);
frame.add(log);
frame.add(pass);
frame.add(txtpassword);
frame.add(txtloging);
frame.pack();

frame.setBounds(450, 450, 380, 200);
frame.setResizable(false);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

/**
* Este m�todo se encarga de inicializar el usuario adecuaado de acuerdo con la validaci�n
* @param t - tipo de usuario(dato que se optiene en la validaci�n)
* @return Usuario que ingresa al sistema.
*/

public Usuario mostrarTipo(int t) {
switch (t) {
default:

case 1:
usuario = TipoA.copiarTipo();
break;

case 2:
usuario = TipoB.copiarTipo();
break;
}

return usuario;
}

/**
* M�todo principal del programa
* @param args
*/

public static void main(String[] args) {
new Presentacion();
}

/**
* M�todo de la interface ActionListener, que se implementa, para manejar
* los eventos generados por los botones que hacen parte del programa.
*/

public void actionPerformed(ActionEvent e) {
if (e.getSource().equals(this.aceptar)) {

/*
* Despues de oprimir el boton aceptar se corre esta lineas de codigo.
* Aqu� se llama el meto validar de validaci�n para validar el tipo de usuario.
* Si el usuario existe en el sistema el m�todo validar devuelve true.
* Luego con los dato otrogados por la clase validador se muestra un mensaje con el tipo de usuario.
*/

if (val.validar(this.txtpassword.getText(),this.txtloging.getText())) {
new ModuloPrincipal(this.mostrarTipo(val.getTipoUsuario()));
} else {
JOptionPane.showMessageDialog(null, "USUARIO NO EXISTE", "ERROR", JOptionPane.ERROR_MESSAGE);

}
}
if (e.getSource().equals(this.clear)) {
this.txtpassword.setText("");
}
}
}

package co.edu.udistrital.validador.presentacion;

import co.edu.udistrital.validador.Logica.*;
import co.edu.udistrital.validador.bd.*;
import java.awt.event.ActionEvent;

import javax.swing.*;

import java.awt.*;
import java.awt.event.*;
import java.sql.SQLException;
import java.util.StringTokenizer;


import javax.swing.table.DefaultTableModel;
/**
* clase que se encarga de generar la interfaz gráfica para los usarios registrados.
* @author Priscilos
*/

public class ModuloPrincipal implements ActionListener {

Conexion conexion;
Usuario usuario;
//Usuario usu;
JFrame frame;
JPanel pane;
Container panelTabla;
JTabbedPane pestana;
JSplitPane separaPaneles;
JMenuBar barra;
JMenu menu;
JMenuItem lisPiezasDis;
JMenuItem listClientes;
JMenuItem listapiezas;
JButton btnGuardar, btnModificar, btnConsultar, btnEliminar, btnConsultarLista, btnBorrar;
JLabel lblDatosClientes, lblNombre, lblApellido, lblIdentificacion;
JTextField txtNombre, txtApellido, txtIdentificacion;
DefaultTableModel modeloTabla;
JTable tablaConsultas, tablaPiezas;
JScrollPane scrollPanel;
StringTokenizer token;
StringTokenizer tokens;
int numTab;
int nDatos;
double[] entrega;
double[] reserva;
char administrador;
java.sql.ResultSet tabla;

/**
* El constructor de la clase inicializa todos los componentes de la GUI
* que pueden variar de acuerdo con el tipo de usario que ingreas.
* @param usu - usuario que ingreas al interfaz gráfica.
*/

public ModuloPrincipal(Usuario usu) {
conexion = Conexion.getConexion();
usuario = usu;
frame = new JFrame("...:::" + usuario.getTipoDeUsuario() + ":::...");
pane = new JPanel(null);
panelTabla = new JPanel();

panelTabla.setLayout(null);

pestana = new JTabbedPane();

btnGuardar = new JButton("Guardar");
btnModificar = new JButton("Editar");
btnConsultar = new JButton("Consultar");
btnEliminar = new JButton("Eliminar");
btnConsultarLista = new JButton("Registrados");

btnBorrar = new JButton("Borrar");






lblDatosClientes = new JLabel("Datos del Usuario");
lblNombre = new JLabel("Nombre");
lblApellido = new JLabel("Apellido");
lblIdentificacion = new JLabel("Identificacion");


txtNombre = new JTextField(15);
txtApellido = new JTextField(15);
txtIdentificacion = new JTextField(15);


separaPaneles = new JSplitPane();

pestana.add("Listas", panelTabla);



lblDatosClientes.setBounds(20, 30, 160, 20);
lblNombre.setBounds(35, 60, 160, 20);
lblIdentificacion.setBounds(35, 90, 160, 20);
lblApellido.setBounds(35, 120, 160, 20);

txtNombre.setBounds(180, 60, 160, 20);
txtIdentificacion.setBounds(180, 90, 160, 20);
txtApellido.setBounds(180, 120, 160, 20);

btnGuardar.setBounds(30, 460, 85, 30);
btnModificar.setBounds(115, 460, 85, 30);
btnConsultar.setBounds(200, 460, 85, 30);
btnEliminar.setBounds(285, 460, 85, 30);
btnBorrar.setBounds(285, 425, 85, 30);
btnConsultarLista.setBounds(330, 440, 110, 30);


pane.add(lblDatosClientes);
pane.add(lblNombre);
pane.add(lblApellido);
pane.add(lblIdentificacion);

pane.add(txtNombre);
pane.add(txtApellido);
pane.add(txtIdentificacion);

pane.add(btnGuardar);
pane.add(btnModificar);
pane.add(btnConsultar);
pane.add(btnEliminar);

pane.add(btnBorrar);
panelTabla.add(btnConsultarLista);
btnModificar.setEnabled(false);
btnEliminar.setEnabled(false);
btnGuardar.setEnabled(usuario.getAdicionarUsuario());
btnConsultarLista.setEnabled(usuario.getObtenerUsuario());




separaPaneles.setRightComponent(pestana);
separaPaneles.setLeftComponent(pane);
pestana.setMinimumSize(new Dimension(400, 50));
pane.setPreferredSize(new Dimension(410, 110));

btnGuardar.addActionListener(this);
btnModificar.addActionListener(this);
btnConsultar.addActionListener(this);
btnEliminar.addActionListener(this);
btnConsultarLista.addActionListener(this);
btnBorrar.addActionListener(this);



frame.getContentPane().add(separaPaneles, BorderLayout.CENTER);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setResizable(false);
frame.setSize(900, 550);
frame.setVisible(true);
}

//crea las tablas
public void mostrarTabla(String CadenaSQl, String[] columNom, int k) {
if (numTab >= 1) {
scrollPanel.setVisible(false);
}
Object[][] dato = new Object[100][k];
conexion.setCadena(CadenaSQl);
tabla = conexion.Consultar();

try {
int i = 0;
while (tabla.next()) {
for (int j = 1; j < k; j++) {
dato[i][j - 1] = tabla.getString(j);

}
i++;

}
} catch (SQLException ex) {

ex.printStackTrace();
}


modeloTabla = new DefaultTableModel(dato, columNom);
tablaConsultas = new JTable(modeloTabla);
tablaConsultas.setPreferredScrollableViewportSize(new Dimension(450, 400));
scrollPanel = new JScrollPane(tablaConsultas);
scrollPanel.setBounds(15, 30, 435, 400);
panelTabla.add(scrollPanel);
numTab++;
}

public void actionPerformed(ActionEvent e) {
if (e.getSource().equals(btnGuardar)) {
usuario.setNombre(txtNombre.getText());
usuario.setIdentificacion(txtIdentificacion.getText());
usuario.setapellido(txtApellido.getText());


conexion.setCadena(usuario.adicionarUsuario());
System.out.println(conexion.EjecutarSql());
}
if (e.getSource().equals(btnModificar)) {
usuario.setNombre(txtNombre.getText());
usuario.setIdentificacion(txtIdentificacion.getText());
usuario.setapellido(txtApellido.getText());

conexion.setCadena(usuario.modificarUsuario());
System.out.println(conexion.EjecutarSql());
}
if (e.getSource().equals(btnConsultar)) {

usuario.setNombre(txtNombre.getText());
conexion.setCadena(usuario.consultarUnUsuario());
tabla = conexion.Consultar();
try {
while (tabla.next()) {
txtNombre.setText(tabla.getString(1));
txtApellido.setText(tabla.getString(2));
txtIdentificacion.setText(tabla.getString(3));

}
} catch (SQLException ex) {

ex.printStackTrace();
}
btnModificar.setEnabled(usuario.getModifiarUsuario());
btnEliminar.setEnabled(usuario.getEliminarUsuario());
}
if (e.getSource().equals(btnEliminar)) {
usuario.setNombre(txtNombre.getText());
conexion.setCadena(usuario.eliminarUsusario());
System.out.println(conexion.EjecutarSql());

}
if (e.getSource().equals(btnConsultarLista)) {
String[] columNom = {"Nombre", "apellido", "identificacion"};
mostrarTabla(usuario.consultarUsuarios(), columNom, 4);

}
if(e.getSource().equals(btnBorrar)){
txtNombre.setText("");
txtApellido.setText("");
txtIdentificacion.setText("");
}




}


}