Documentación Del Registro Del Personal De Empresa
La siguiente aplicación esta construida en el lenguaje de programación JAVA y la base de datos en MYSQL, hemos escogido JAVA debido a que es un lenguaje de programación muy potente, además consta de la característica de ser multiplataformas y de encontrar mucha documentación para la elaboración de cualquier aplicación, y hemos escogido la base de datos MYSQL debido a su facil instalación y utilización, además de ser codigo libre.
Esta aplicación resolverá el problema del registro manual del personal de cualquier empresa que allá utilizado esta solución. Se lo resolverá al problema con un software que lleve un registro de la asistencia del personal de una forma sencilla y fácil de entender al usuario, y además le ocupe el menos tiempo posible.
La pantalla principal sera la de acceso directo al empleado para su respectivo registro de entrada como de la salida.
registro del personal
Este software consta de un menú llamado Archivos el cual tiene un acceso a la ventana de Administración y uno de salida. Además consta de una barra de acceso directo a la mismas opciones y un reloj para su propio control.
Autentificación del Administrador
Al hacer click en el icono para la ventana de administración nos aparece la esta ventana para autentificar que somos el administrador de este software con lo cual nos registramos como administrador, accediendo o negando el usuario. Una vez autentificado el usuario tenemos acceso a la ventana de administración.
Ventana para el manejo del Administrador
En esta ventana de administración tenemos también un menú llamado archivo y una barra de acceso directo a las mismas opciones del menú, las opciones son listar, registrar y eliminar . En esta ventana de administración hemos creado y un panel interno en el cual se van abrir dentro de este todas estas opciones de ventanas ya dichas lo cual ara mas fácil de llevar el manejo de estas.
pantalla listar empleados
Al hacer clic en la el icono de acceso directo listar nos aparece la anterior ventana metida dentro del panel de administración esta contendrá un listado de los empleados y para obtener información sobre su asistencia hacemos clic sobre cualquier nombre que queramos apareciéndonos mas información detallada de todas sus asistencias dentro del a misma venta de listar.
Ventana de registro de Empleados
A continuación se presenta la ventana para registrar un nuevo empleado la cual también va ha estar en un un panel interno dentro de la ventana de administración esta podrá hacer accedido mediante el menú, registrar o mediante su acceso directo Acontinuacion se presenta la ventana en esta ventana se va ingresar los datos personales del empleado, para guardarlos en la base de datos de MYSQL
Ventana Eliminar Empleado
La ventana siguiente es la ventana de Eliminar empleado la cual procederá a eliminar cualquier empleado mediante su numero de cédula, podemos acceder a esta ventana mediante menú, eliminar o mediante su icono de acceso directo en la barra de tareas
Ventana para Imprimir informe
La siguiente es la ventana de informe cual puede ser imprimida esta presenta el informe ingresando los datos de cédula, mes y año del pago correspondiente al mes que se va ha cancelar.
Ventanas administración con ventanas internas.
Ventanas administración con ventanas internas.
Documentación de Todas Las Clases Aplicadas
Para desarrollar esta aplicación la primera clase que cree fue la clases de la conexión a la base de datos de MYSQL para lo cual me descargue de internet la librería que controla la conexión a MYSQL.
Para su mayor facilidad he creado un paquete en donde solo pondré las clases que voy ha utilizar y aparte las clases que implementan interfaz gráfica, además de un paquete para todas las imágenes que se utilice.
La Clase Conexion
/*La primera linea importa la librería sql para trabajar con MYSQL y sus respectivas sentencias
La clase Conexion que se la va a utilizar por defecto la cual contiene las siguientes variables que seran estaticas y de tipo string bd que contiene el nombre de la base de datos para la conexion a esta, la variable del mismo tipo login que contiene el login con el cual la clase Conexion va ha tener acceso a mysql, la variable password del mismo tipo que va contener la clave de acceso a mysql y por ultimo la variable url por la cual mysql va ha escuchar las peticiones a esta y que va ha ser del mismo tipo de las anteriores
la varialble url especifica que es una conexión a la base de datos de mysql por la dirección o ip 127.0.0.1 la cual es igual al localhost y que va ha escuchar las peticiones por el puerto 3306*/
import java.sql.*;
public class Conexion {
static String bd = “resgistro_del_personal_empresarial”;
static String login = “root”;
static String password = “creedyeli1234″;
static String url = “jdbc:mysql://127.0.0.1:3306/”+bd;
Connection conn = null; /** Crea una nueva instancia del Conexión */
/* En el constructor de la clase Conexion carga los drivers y se hace la conexión y se hace pone un capturador de posibles errores o ecepciones y la imprime en consola*/
public Conexion(){
try{
//obtenemos el driver de para mysql
Class.forName(”com.mysql.jdbc.Driver”);
//obtenemos la conexión
conn = DriverManager.getConnection(url,login,password);
if (conn!=null){
System.out.println(”Conección a base de datos “+bd+” OK”);
}else
System.out.println(”Error onectando a la base de datos “+bd);
}catch(SQLException e){
System.out.println(e);
}catch(ClassNotFoundException e){
System.out.println(e);
}
}
/* El método getConexion devuelve un objeto Connection que especifica que se ha conectado*/
public Connection getConexion(){
return conn;
}
/* este método desconecta la conexión que se ha hecho a la base de datos*/
public void desconectar(){
conn = null;
System.out.println(”Desconectado”);
}
/* Este es un metodo que sirve de prueba para la clase Conexion */
public static void main(String args[]){
Conexion conec=new Conexion();
}
}
La Clase ConecAdmin
/*En esta clase importamos la librería sql con todas sus clases para trabajar tambien con la base de datos*/
import java.sql.*;
/*Esta clase va ha conectarse a la base de datos y a la stabla que contiene los usuarios y contraseñas de administración. En esta clase creamos un objeto de tipo Conexion el cual hace la conexion a la base de datos */
public class ConecAdmin {
Conexion conec;
/** Creamos el contructor de la clase ConecAdmin la cual inicializa la conexión*/
public ConecAdmin() {
conec = new Conexion();
}
/* Este método retorna si los datos de usuario y contraseñas fueron correctos y están almacenados en la tabla administradores, esto lo hace mediante la devolución de una variable booleana
En este método resive 2 variables de tipo String la cuales contiene el usuario y el password ha comparar con la de la tabla de administrador para ser autentificado*/
public boolean comparacion(String usuario, String passw){
boolean aceptacion=false;
try{
/*crea una variable Statement que con la variable de tipo conexion van a permitir hacer las consultas ha la tabla*/
Statement stm = conec.getConexion().createStatement();
/*con esta sentencia extrae los datos de todos los campos de la tabla administradores y luego los extrae en una variable de tipo metadatos llamada resultado, con la cual se va ha obtener los datos que necesitamos para comparar el ingreso del administrador*/
ResultSet resultado=stm.executeQuery(”SELECT * FROM administradores”);
ResultSetMetaData metaDatos= resultado.getMetaData();
//Con este while recorremos la tabla fila por fila la cual cada fila es un usuario administrador
while(resultado.next()){
//la variable i indica el campo en la tabla de meta datos
int i=2;
/*imprimimos en consola que datos estamos sacando para estar seguros, y los datos que saquemos que deben ser el usuario y el password los almacenamos en unas variables de tipo String usuabd y passwbd la cual
System.out.println(resultado.getString(i)+resultado.getString(i+1));
String usuabd=resultado.getString(i);
String passwbd=resultado.getString(i+1);
/*En este if comparamos si existe una coincidencia con algún usuario administrador si es la autenticación de usuario fue correcta, cambiamos la variable aceptación por verdadero y terminamos la busqueda y retornamos el valor */
if(usuabd.equals(usuario)&& passwbd.equals(passw)){
aceptacion=true;
break;
}else{
aceptacion=false;
}
}
}catch(SQLException e){
System.out.println(e);
}
if(aceptacion==true){
System.out.println(”estan bien las contraseñas”);
}else{
System.out.println(”estan mal las contraseñas”);
}
return aceptacion;
}
//Este es un metodo de prueba de la clase
public static void main(String args[]){
ConecAdmin nuevo=new ConecAdmin();
boolean ver=false;
ver=nuevo.comparacion(”admin”,”admin”);
}
public void desconectar(){
conec.desconectar();
}
}
La Clase NuevoEmpleado
// Importamos las librerías de java que contiene las clases para tratarse con las base de datos
import java.sql.*;
/*Esta clase crea en la tabla de empleados un nuevo empleado, el cual tiene la información de este la cual consiste en nombre, apellido, cédula, sexo, correo, dirección, area y horas que va ha ser por defecto de inicialización cero, y todos de tipo private*/
/* Además creamos un objeto de tipo Conexion para la conexión a la base de datos
public class NuevoEmpleado {
private String nombre;
private String apellido;
private int cedula;
private String horas=”0:0:0″;
private String sexo;
private String correo;
private String direccion;
private String area;
Conexion conec;
/** Creamos el constructor de la clase la cual recibe los datos que se van ha ingresar en la tabla de empleados, pero antes los guardamos en las variables globales */
public NuevoEmpleado(String nombre, String apellido, int cedula, String sexo, String correo, String direccion, String area ) {
this.nombre=nombre;
this.apellido=apellido;
this.cedula=cedula;
this.correo=correo;
this.area=area;
this.sexo=sexo;
this.direccion=direccion;
conec = new Conexion();
insertarEnTabla();
}
/*Este método inserta en la tabla los datos de las variables globales declarados en la clase de acuerdo al orden de la sentencia sql
public void insertarEnTabla(){
try{
//boolean aceptacion=false;
Statement stm = conec.getConexion().createStatement();
stm.executeUpdate(”INSERT INTO empleados (nombres, apellidos, area, cedula, email, sexo, direccion, horas) VALUES (’”+ this.nombre+ “‘,’” +this.apellido+ “‘,’” +this.area+ “‘,’” +this.cedula+ “‘,’” +this.correo+ “‘,’” +this.sexo+ “‘,’” +this.direccion+ “‘,’” +this.horas+ “‘ )”);
}catch(SQLException e){
System.out.println(e);
}
}
}
La Clase Eliminar
// Importamos las librerías de java que contiene las clases para tratarse con las base de datos
import java.sql.*;
/*La clase Eliminar hace eso elimina el empleado de la tabla empleados mediante el numero de cédula. */
/*Esta clase tiene una variable global cédula la cual va ha almacenar la cédula para luego ser comparada con los datos del campos cédula de tabla empleado si es igual a alguno de los datos de ese campo lo elimina. Con la sentencia sql comparamos y eliminamos* /
public class Eliminar {
private String cedula;
Conexion conec;
/** Creates a new instance of Eliminar */
public Eliminar(String cedula) {
this.cedula=cedula;
conec = new Conexion();
try{
//boolean aceptacion=false;
Statement stm = conec.getConexion().createStatement();
stm.executeUpdate(”DELETE FROM empleados WHERE cedula=”+this.cedula);
}catch(SQLException e){
System.out.println(e);
}
}
}
La Clase Ingreso
/*Esta clase va ha permitir que un empleado registre tanto su hora de ingreso, digitando su numero de cédula para este propósito, captura la hora del sistema en el momento del registro y la guarda en la tabla de registro*/
import java.sql.*;
import javax.swing.JOptionPane;
public class Ingreso {
int id;
String cedula;
int hora;
String fecha;
int minuto;
int segundo;
String entrada;
String salida=”0:0:0″, total=”0:0:0″;
Conexion conec= new Conexion();
/** Crea una nueva instancia de Ingreso */
public Ingreso(String cedula, int hora, int minuto, int segundo, String fecha) {
this.cedula=cedula;
this.hora=hora;
this.minuto=minuto;
this.segundo=segundo;
this.entrada=hora+”:”+minuto+”:”+segundo;
this.fecha=fecha;
if(comprobarEmpleado()==true){
insertarEnTabla();
}else{
JOptionPane.showMessageDialog(null, “Se quiere registrar un intruso”,”Alerta”,1);
}
}
//Este es el metodo en el que insertamos en la tabla registro
public void insertarEnTabla(){
try{
//boolean aceptacion=false;
Statement stm = conec.getConexion().createStatement();
stm.executeUpdate(”INSERT INTO registro VALUES (’”+this.id+” ‘,’”+this.cedula+”‘,’”+this.fecha+”‘,’”+this.entrada+”‘,’”+this.salida+”‘,’”+this.total+”‘)”);
}catch(SQLException e){
System.out.println(e);
}
}
//En este metodo comprobamos que el usuario este en la tabla de empleados, mediante el numero de //cedula, si consta procede a insertar
public boolean comprobarEmpleado(){
boolean aceptacion=false;
try{
//boolean aceptacion=false;
Statement stm = conec.getConexion().createStatement();
ResultSet resultado=stm.executeQuery(”SELECT * FROM empleados”);
//StringBuffer resultados=new StringBuffer();
ResultSetMetaData metaDatos= resultado.getMetaData();
//int numerodecolumnas = metaDatos.getColumnCount();
while(resultado.next()){
int i=4;
System.out.println(resultado.getString(i));
String cedulabd=resultado.getString(i);
//String passwbd=resultado.getString(i+1);
if(cedulabd.equals(this.cedula)){
aceptacion=true;
break;
}else{
aceptacion=false;
}
}
}catch(SQLException e){
System.out.println(e);
}
return aceptacion;
}
}
La Clase Salida
/*En esta clase procedemos a ingresar el numero de cedula para comprobar la salida del empleado*/
import java.sql.*;
public class Salida {
double Ttotal2;
double Ttotal;
String cedula;
private int hora;
String fecha;
private int minuto;
private int segundo;
String entrada;
private String salida;
String total;
String compara = “00:00:00″;
Conexion conec;
Calculo_ingreso_horas_total totalhoras;
public Salida(String cedula, int hora, int minuto, int segundo, String fecha) {
this.cedula = cedula;
this.hora = hora;
this.minuto = minuto;
this.segundo = segundo;
this.salida = hora + “:” + minuto + “:” + segundo;
this.fecha = fecha;
conec = new Conexion();
if (sacaDatos() == true) {
totalhoras=new Calculo_ingreso_horas_total(this.entrada, this.hora, this.minuto, this.segundo);
this.total=totalhoras.subtotal();
actualizar();
}
}
/*Este metodo verifica que la cedula sea la correcta, y el campo salida este vacio dentro de la tabla registro, pasa al metodo actualizar*/
public boolean sacaDatos() {
boolean aceptacion = false;
try {
Statement stm = conec.getConexion().createStatement();
ResultSet resultado = stm.executeQuery(”SELECT * FROM registro”);
while (resultado.next()) {
int i = 2;
String cedulabd = resultado.getString(i);
String salidabd = resultado.getString(i + 3);
if (cedulabd.equals(this.cedula)&& salidabd.equals(this.compara)) {
aceptacion = true;
this.entrada = resultado.getString(i + 2);
break;
} else {
aceptacion = false;
}
}
} catch (SQLException e) {
System.out.println(e);
}
return aceptacion;
}
/* En este metodo, se actualiza los datos del ultimo registro de un empleado y ademas en la tabla empleados hace que se sume las nuevas horas ingresadas, al total del tiempo acumulado en el campo total de la tabla empleados */
public void actualizar() {
try {
Statement stm = conec.getConexion().createStatement();
stm.executeUpdate(”UPDATE registro SET salida=’”+this.salida+”‘, total=’”+this.total+”‘ WHERE salida=’”+this.compara+”‘ AND cedula=’”+this.cedula+”‘”);
ResultSet resultado = stm.executeQuery(”SELECT * FROM empleados”);
while (resultado.next()) {
int i = 4;
String cedulabd = resultado.getString(i);
System.out.println(cedulabd);
if (cedulabd.equals(this.cedula)) {
Ttotal2=Integer.parseInt(resultado.getString(8));
System.out.println(Ttotal2);
break;
}
}
this.Ttotal= totalhoras.horas() + Ttotal2;
System.out.println(Ttotal+” “+Ttotal2);
stm.executeUpdate(”UPDATE empleados SET horas=’”+this.Ttotal+”‘ WHERE cedula=’”+this.cedula+”‘”);
} catch (SQLException e) {
System.out.println(e);
}
}
}
La Clase Ingreso_horas_total
/*En esta clase, se hace el calculo de las horas, minutos y segundos que necesita la clase salida, y ademas transforma ese tiempo a horas */
public class Calculo_ingreso_horas_total {
int Thoras,Tminutos,Tsegundos,ME,SE,HE,aux;
String subtotal;
/*Este metodo extrae recibe un String de las horas de entrada y recibe los demas datos de la hora de salida como enteros, y los suma para calcular el numero de horas, minutos y segundos que realizo en es entrada y salida*/
public Calculo_ingreso_horas_total(String entrada,int hora,int minuto,int segundo){
HE=Integer.parseInt(entrada.substring(0,2));
ME=Integer.parseInt(entrada.substring(3,5));
SE=Integer.parseInt(entrada.substring(6,8));
System.out.println(HE+”:”+ME+”:”+SE);
System.out.println(hora+”:”+minuto+”:”+segundo);
if(segundo<SE){
segundo+=60;
minuto-=1;
}
Tsegundos=(segundo-SE);
if(minuto<ME){
minuto+=60;
hora-=1;
}
Tminutos+= (minuto-ME);
Thoras+=(hora-HE);
System.out.println(Thoras);
subtotal=Thoras+”:”+Tminutos+”:”+Tsegundos;
}
/*Este metodo retorna una variable tipo String la cual es el resultado del metodo Calculo_Ingreso_horas_total*/
public String subtotal(){
return this.subtotal;
}
/*Este metodo transforma los minutos y segundos a horas y los suma en la variable horas*/
public double horas(){
double tot;
tot= (double)Thoras+((double)Tminutos/60)+((double)Tsegundos/3600);
return tot;
}
}
La Clase DbEmpleado
/*Esta sentencia importa las librerias necesarias para la utilizacion de la base de datos SQL*/
import java.sql.*;
/*Esta clase se obtienen los datos de la tabla Empleado y los datos de la tabla registro*/
public class DbEmpleado {
Conexion cn;
/** Constructor de DbUser */
public DbEmpleado() {
cn = new Conexion();
}
/** Obtiene los datos personales de un empleado por su numero de cedula */
public Object[][] getHorasByEmpleado(String cod){
int registros = 0;
try{
Statement stm = cn.getConexion().createStatement();
PreparedStatement pstm = cn.getConexion().prepareStatement(”SELECT count(1) as cont” +
” FROM registro a ” +
” inner join empleados n ” +
” where n.cedula =? “);//le cambie el ? por la cedula para probar
pstm.setString(1, cod);
ResultSet res = pstm.executeQuery();
res.next();
registros = res.getInt(”cont”);
res.close();
}catch(SQLException e){
System.out.println(”error1″+e);
}
/*Este objeto almacena los datos de las tablas como una matriz bidimensional para luego ser presentados en un Jtable. Con la sentencia SQL inner join unimos la tabla empleados y registro, de la tabla empleados tomamos el apellido y de la tabla registro todos los datos*/
Object [][] data = new Object[registros][6];
try{
Statement stm = cn.getConexion().createStatement();
PreparedStatement pstm = cn.getConexion().prepareStatement(”SELECT empleados.apellidos, registro.cedula, registro.fecha, registro.entrada, registro.salida, registro.total FROM registro inner join empleados ON registro.cedula=empleados.cedula where empleados.cedula=?”);
pstm.setString(1, cod);
ResultSet res = pstm.executeQuery();
int i = 0;
while(res.next()){
String asiApellido = res.getString(”apellidos”);
String asiCedula = res.getString(”cedula”);
String asiFecha = res.getString(”fecha”);
String asiEntrada = res.getString(”entrada”);
String asiSalida = res.getString(”salida”);
String asiTotal = res.getString(”total”);
data[i][0] = asiApellido;
data[i][1] = asiCedula;
data[i][2] = asiFecha;
data[i][3] = asiEntrada;
data[i][4] = asiSalida;
data[i][5] = asiTotal;
i++;
}
res.close();
}catch(SQLException e){
System.out.println(”error2″+e);
}
return data;
}
/** trae todos los empleados */
/*Este objeto los utilizamos como matriz, primero se van a lamacenar los datos que se obtienen de la tabla, pero antes realiza un conteo de las filas de la tabla empleados*/
public Object[][] getEmpleados(){
int registros = 0;
try{
Statement stm = cn.getConexion().createStatement();
PreparedStatement pstm = cn.getConexion().prepareStatement(”SELECT count(1) as cont FROM empleados “);
ResultSet res = pstm.executeQuery();
res.next();
registros = res.getInt(”cont”);
res.close();
}catch(SQLException e){
System.out.println(e);
}
Object [][] data = new Object[registros][4];
try{
Statement stm = cn.getConexion().createStatement();
PreparedStatement pstm = cn.getConexion().prepareStatement(”SELECT nombres, ” +
” apellidos,” + “cedula,” + “horas”+
” FROM empleados ” +
” ORDER BY apellidos “);
ResultSet res = pstm.executeQuery();
int i = 0;
while(res.next()){
String estNombre = res.getString(”nombres”);
String estApellido = res.getString(”apellidos”);
String estcedula = res.getString(”cedula”);
String esthoras = res.getString(”horas”);
data[i][0] = estNombre;
data[i][1] = estApellido;
data[i][2] = estcedula;
data[i][3] = esthoras;
i++;
}
res.close();
}catch(SQLException e){
System.out.println(e);
}
return data;
}
}
La Clase BDInformeDatosGenerales
/*Eata clase obtiene los datos generales para presentar en el informe imprimible, el cual tiene un formato de salida que se almacena en una variable String*/
import java.sql.*;
public class BDInformeDatosGenerales {
Conexion cn;
public BDInformeDatosGenerales(){
cn = new Conexion();
}
public String getDatosGenerales(String cedula){
String informe=”";
try{
Statement stm = cn.getConexion().createStatement();
ResultSet resultado=stm.executeQuery(”SELECT * FROM empleados”);
ResultSetMetaData metaDatos= resultado.getMetaData();
while(resultado.next()){
int i=4;
String cedulabd=resultado.getString(i);
if(cedulabd.equals(cedula)){
informe+=”\t El siguiente informe es para indicar los datos del siguiente empleado:”+”\n\t Nombre: “
+resultado.getString(1)+” “+resultado.getString(2)+”\t\t Cedula: “
+resultado.getString(4)+”\n\t Sexo: “+resultado.getString(6)+”\t\t\t Area de Trabajo: “
+resultado.getString(3)+”\n\t E-mail: “+resultado.getString(5)
+”\t Dirección: “+resultado.getString(7)+”\n\t Total de Horas en la Empresa: “
+resultado.getString(8)+”\n”+”\n\t Acontinuación se presenta el informe del mes y su respectivo pago.”;
break;
}
}
}catch(SQLException e){
System.out.println(e);
}
return informe;
}
}
La Clase BDInformeRegistros
/*Esta clase extrae los datos de la tabla registro que van a ser presentados en el informe, los datos extraídos van a ser seleccionados mediante el numero de cédula del empleado que se solicita, y mediante la fecha que consta en el mes y el año del reporte*/
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;
public class BDInformeRegistros {
Conexion cn;
int min=0,seg=0, hras=0;
public BDInformeRegistros() {
cn = new Conexion();
}
public String getDatosRegistros(String cedula, String fchinicio, String fchfin) {
String informe = “\n\tfecha” + “\t\tentrada” + “\t\tsalida” + “\t\ttotal” + “\n\n”;
try {
Statement stm = cn.getConexion().createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
String a = “SELECT * FROM registro WHERE cedula=” + cedula+” AND fecha BETWEEN “+fchinicio+” AND “+fchfin;
System.out.println(”SQL: “+a);
ResultSet resultado = stm.executeQuery(a);
while (resultado.next()) {
System.out.println(”Imprime datos: “+resultado.getString(”cedula”));
informe += “\t”+resultado.getString(3) + “\t” + resultado.getString(4) + “\t\t” + resultado.getString(5) + “\t\t” + resultado.getString(6) + “\n”;
}
informe+=”\n”;
System.out.println(informe);
} catch (SQLException ex) {
Logger.getLogger(BDInformeRegistros.class.getName()).log(Level.SEVERE, null, ex);
}
return informe;
}
/*Este metodo proporciona un informe de las horas calculadas durante el mes especificado en los campos que recibe y presenta las horas en formato de hora, minutos y segundos, y de solo horas, ademas de calcular el pago por hora, que es de 2 dolares por hora */
public String getTotalHoras(String cedula, String fchinicio, String fchfin){
String informe=”00-00-00″;
try {
Statement stm = cn.getConexion().createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
String a = “SELECT total FROM registro WHERE cedula=” + cedula+” AND fecha BETWEEN “+fchinicio+” AND “+fchfin;
System.out.println(”SQL: “+a);
ResultSet resultado = stm.executeQuery(a);
while (resultado.next()) {
sumahorasmes(resultado.getString(1));
}
informe=”\t\t\t\tT. en formato Horas:”+”\t”+getTotalformatohoras()+”\n”
+”\t\t\t\tT. Horas:”+”\t”+getTotalHoras()+”\n”;
double sueldo=getTotalHoras()*2;
informe+=”\t\t\t\tSueldo a pagar”+”\t”+sueldo;
}catch(Exception e){
System.out.println(e);
}
return informe;
}
/* Este suma las horas del campo total de la tabla registro y la suma en variables de tipo int las cuales contienen las horas minutos y segundos*/
public void sumahorasmes(String sumar){
int HE=Integer.parseInt(sumar.substring(0,2));
System.out.println(sumar.substring(0,2));
int ME=Integer.parseInt(sumar.substring(3,5));
System.out.println(sumar.substring(3,5));
int SE=Integer.parseInt(sumar.substring(6,8));
System.out.println(sumar.substring(6,8));
this.min+=ME;
this.seg+=SE;
this.hras+=HE;
}
/*Este metodo, ademas de retornar al metodo getTotalHoras las horas en formato horas, minutos y segundos, de tipo String, tambien transforma los segundos a minutos y los minutos a horas */
public String getTotalformatohoras(){
while(seg>60){
seg-=60;
min++;
}
while(min>60){
min-=60;
hras++;
}
String tfhras=hras+”:”+min+”:”+seg;
return tfhras;
}
/*Este método devuelve una variable double de formato hora*/
public double getTotalHoras(){
double tot;
tot= (double)hras+((double)min/60)+((double)seg/3600);
return tot;
}
La Clase Impresora
/*importamos las librerias de para el tipo de fuente, y las librerias para impresión*/
import java.awt.*;
/*En esta clase vamos a poner todos los datos en un objeto tipo Graphics para que dibuje la impresora y mediante un objeto PrintJob enviarle a imprimir el trabajo.
public class Impresora
{
Font fuente = new Font(”Dialog”, Font.PLAIN, 10);
PrintJob pj;
Graphics pagina;
/*A continuación el constructor de la clase. Aquí lo único que hago es tomar un objeto de impresión.*/
public Impresora()
{
pj = Toolkit.getDefaultToolkit().getPrintJob(new Frame(), “SCAT”, null);
}
/* A continuación el método “imprimir(String)”, el encargado de colocar en el objeto gráfico la cadena que se le pasa como parámetro y se imprime.*/
public void imprimir(String Cadena)
{
/*LO COLOCO EN UN try/catch PORQUE PUEDEN CANCELAR LA IMPRESION*/
try
{
pagina = pj.getGraphics();
pagina.setFont(fuente);
pagina.setColor(Color.black);
pagina.drawString(Cadena, 60, 60);
pagina.dispose();
pj.end();
}catch(Exception e)
{
System.out.println(”LA IMPRESION HA SIDO CANCELADA…”);
}
}
//FIN DEL PROCEDIMIENTO imprimir(String…)
}//FIN DE LA CLASE Impresora
NOTA: Espero se me disculpe solo he documentado las clases que cree para desarrollar la logica del programa y todas las demas clases graficas (GUI) las pueden ver en el proyecto q voy adjuntar, y que esta hecho en netbeans 6 ademas voy adjuntar las librerias que utilice como la de mysql, la del lookandfeel que le da un poco de estilo a la aplicacion y la que de el reloj, que el codigo lo copie de por ahi de un blog o un ejemplo en la red no me acuerdo muy bien de donde lo saque (el reloj no es merito mio), bueno pero yo les facilite el trabajo asi que esta listo para q lo agregen a la libreria de swing como clockpanel es muy facil. Ademas les dejo una libreria swingx para q la revisen talvez pueda q falte esta libreria en el proyecto.
En este archivos encontrara todos las librerias y el proyecto.
http://up-file.com/download/38018a4f8cc7f02517041168c7727a071
Creacion de la Base de Datos en MYSQL
bueno la primera sentencia sql es para borrar por si acaso exista una base de datos de igual nombre.
drop database `registro_del_personal_empresarial`;
create database `registro_del_personal_empresarial`;
use `registro_del_personal_empresarial`;
CREATE TABLE `administradores` (
`Id` int(6) unsigned NOT NULL auto_increment,
`usuario` varchar(100) default NULL,
`clave` varchar(100) default NULL,
PRIMARY KEY (`Id`)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
INSERT INTO `administradores` VALUES (1,’admin’,'admin’);
CREATE TABLE `empleados` (
`nombres` varchar(50) default NULL,
`apellidos` varchar(50) default NULL,
`area` varchar(255) default NULL,
`cedula` varchar(11) default NULL,
`email` varchar(255) default NULL,
`sexo` varchar(50) default NULL,
`direccion` varchar(255) default NULL,
`horas` varchar(255) NOT NULL,
PRIMARY KEY (`cedula`));
CREATE TABLE `registro` (
`id` int(11) NOT NULL auto_increment,
`cedula` varchar(10) default NULL,
`fecha` date NOT NULL,
`entrada` time NOT NULL,
`salida` time NOT NULL,
`total` time NOT NULL,
PRIMARY KEY (`id`)
);
INSERT INTO `empleados` VALUES (’Cesar’,'Pesantez’,'desarrollo’,'1000000000′,’craupesantez@hotmail.com’,'hombre’,'leopoldo palacios entre JJ Peña y olmedo’,'18′);
INSERT INTO `empleados` VALUES (’Augusto’,'Cabrera’,'Ingenieria’,'1111111111′,’lacabrea@utpl.edu.ec’,'hombre’,'frente al colegio Daniel alvarez’,'18′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-7-23′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-7-23′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-2′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-2′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-3′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-3′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-5′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-5′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-10′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-10′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-20′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-20′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-8-30′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-8-30′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-9-23′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-9-23′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1000000000′,’2008-9-30′,’10:0:0′,’12:0:0′,’2:0:0′);
INSERT INTO `registro` VALUES (”,’1111111111′,’2008-9-30′,’10:0:0′,’12:0:0′,’2:0:0′);
Cualquier percanse con la base o con el programa o cualquier problema en la instalación comunicarmerlo a este correo yo estare dispuesto ayudarle solo por haber visitado mi blog.Mi correo es craupesantez@hotmail.com. Y disculpen si esta incompleto.
