package com.utils;
import com.GestDB.general.Trackbug;
import java.lang.Long;
import java.io.*;
import java.util.Date;
import java.util.Calendar;
import java.net.URL;
import java.util.Vector;
public final class utilidades
{
public static boolean copyFile(String source, String targetDir)
{
return copyFile(new File(source), new File(targetDir));
}
public static boolean copyFile(File archivo, File dirDestino)
{
if(archivo.exists() && archivo.canRead())
{
// si el directorio de destino no existe se crea.
if(!dirDestino.exists())
dirDestino.mkdirs();
File archivoDestino = new File(dirDestino,archivo.getName());
FileInputStream fin = null;
FileOutputStream fout = null;
byte buffer[] = new byte[10000];
int leido = 0;
try
{
fin = new FileInputStream(archivo);
fout = new FileOutputStream(archivoDestino);
while((leido=fin.read(buffer)) != -1)
{
fout.write(buffer,0,leido);
}
fin.close();
fout.close();
} catch (Exception ex)
{
if(fin != null)
{
try {
fin.close();
}catch(Exception ee){
;
}
}
if(fout != null)
{
try {
fout.close();
}catch(Exception ee){
;
}
}
// se tiene que borrar el archivo de destino
if(archivoDestino.exists())
archivoDestino.delete();
return false;
}
}
else
{
// Espa�ol: no se puee leer el archivo origen.
// English: Reading error with source file
return false;
}
return true;
}
public static synchronized String Inserta_Campo (String origen, Vector claves, Vector valores) {
int pos = 0;
int posfin = 0;
String cadaux;
while( (pos = origen.indexOf("<!--",posfin)) != -1)
{
posfin = origen.indexOf("-->",pos);
cadaux = origen.substring(0, pos);
String clave = origen.substring(pos,posfin+3);
int posicion = claves.indexOf((String)clave);
cadaux = cadaux + ((posicion!= -1)?(String)valores.elementAt(posicion):clave);
cadaux = cadaux + origen.substring(posfin+3);
origen = cadaux;
}
return origen;
} // fin Inserta_Campo
//*************************** Inserta_Campo *********************
/**
* Inserta una cadena dentro de otra cadena
* @param origen String de cadena origen
* @param calve String con la clave que se buscara en la cadena para localizar la posici�n de inserci�n
* @param valor String con lo que se desea insertar
*/
public String Inserta_Campo (String origen, String clave, String valor) {
StringBuffer miBuffer = new StringBuffer(origen);
int pos = origen.indexOf(clave);
if (pos == -1) // no encontr� la clave
return origen;
else
{
miBuffer.insert(pos,valor);
return (miBuffer.toString());
}
} // fin Inserta_Campo
/**
* Rellena un String con espacios, introduce tantos espacios
* como se indiquen en el parametro numero.
*
* @param numero Numero de espacios a introducir.
* @return El String de espacios.
*/
public static synchronized java.lang.String Espacios(int numero)
{
java.lang.String sTmp = new java.lang.String();
for(int i=0; i < numero ; i++)
sTmp += " ";
return sTmp;
}
/**
* Rellena un String con otro, un determinado numero de veces.
*
* @param numero Numero de repeticiones.
* @param cadena String con el que se rellena.
* @return El String relleno.
*/
public static synchronized java.lang.String RellenaString(int numero, String cadena)
{
java.lang.String sTmp = new java.lang.String();
for(int i=0; i < numero ; i++)
sTmp.concat(cadena);
return sTmp;
}
/**
* A�ade a un String espacios a la derecha hasta que
* tenga el tama�o indicado como par�metro
*
* @param numero Numero de caracteres del String.
* @param cadena String a utilizar.
* @return El String relleno.
*/
public static synchronized java.lang.String AddEspacios(int numero, String cadena)
{
java.lang.String sTmp = new java.lang.String(cadena);
int longi = sTmp.length();
if (longi < numero)
sTmp += Espacios(numero - longi);
return sTmp;
}
/**
* Devuelve un String con la longitud indicada rellenando con el caracter
* indicado si la cadena original es menor que dicha longitud.
*
* @param Cadena Cadena original a ser tratada
* @param longitud Longitud de la cadena a retornar.
* @param Caracter_relleno Caracter de relleno en caso de que la cadena original tenga menor
* longitud que la indicada.
*/
public static synchronized java.lang.String AddCadena(String Cadena, int longitud, String Caracter_relleno)
{
int Longitud_Original = Cadena.length();
int Longitud_Actual = Longitud_Original;
if (Longitud_Original <= longitud)
{
while (Longitud_Actual < longitud)
{
Cadena = Cadena + Caracter_relleno;
Longitud_Actual++;
}
return Cadena;
}
else if(longitud > 0)
{
return Cadena.substring(0,longitud);
}
else
return Cadena;
}
/**
* Devuelve un String con la longitud indicada rellenando con el caracter
* indicado por la Izquierda si la cadena original es menor que dicha longitud.
*
* @param Cadena Cadena original a ser tratada
* @param longitud Longitud de la cadena a retornar.
* @param Caracter_relleno Caracter de relleno por la izquierda en caso de que
* la cadena original tenga menor longitud de la indicada.
*/
public static synchronized java.lang.String AddLeftCadena(String Cadena, int longitud, String Caracter_relleno)
{
int Longitud_Original = Cadena.length();
int Longitud_Actual = Longitud_Original;
if (Longitud_Original <= longitud)
{
while (Longitud_Actual < longitud)
{
Cadena = Caracter_relleno + Cadena;
Longitud_Actual++;
}
return Cadena;
}
else if(longitud > 0)
{
return Cadena.substring(0,longitud);
}
else
return Cadena;
}
/**
* Devuelve un String con la longitud indicada rellenando con el caracter
* indicado por la Dcha si la cadena original es menor que dicha longitud.
*
* @param Cadena Cadena original a ser tratada
* @param longitud Longitud de la cadena a retornar.
* @param Caracter_relleno Caracter de relleno por la dcha en caso de que
* la cadena original tenga menor longitud de la indicada.
*/
public static synchronized java.lang.String AddRightCadena(String Cadena, int longitud, String Caracter_relleno)
{
int Longitud_Original = Cadena.length();
int Longitud_Actual = Longitud_Original;
if (Longitud_Original <= longitud)
{
while (Longitud_Actual < longitud)
{
Cadena = Cadena + Caracter_relleno;
Longitud_Actual++;
}
return Cadena;
}
else if(longitud > 0)
{
return Cadena.substring(0,longitud);
}
else
return Cadena;
}
/**
* Metodo para convertir un Array de objetos a un Vector (java)
*
* @param Objs Array de objetos que se desea convertir.
* @return Un vector con la misma dimension y objetos que el array Objs.
*/
public static synchronized java.util.Vector ArrayObjToVector(Object Objs[])
{
java.util.Vector ObjsVec = new java.util.Vector();
for (int i = 0; i <= (Objs.length - 1); i++)
{
ObjsVec.addElement(Objs[i]);
}
return ObjsVec;
}
/**
* Comprueba si una fecha pasada por parametro es valida.
*
* @param fecha String con la fecha en formato dd-mm-aaaa
* @return true - La fecha es correcta.
* false - No es correcta
*/
public static synchronized boolean CompruebaFecha(String fecha)
{
Integer dia = new Integer(0);
Integer mes = new Integer(0);
Integer ano = new Integer(0);
boolean FechaCorrecta = true;
try
{
//Compruebar que existen los slash en las posiciones 2 y 5
int pos1=fecha.indexOf('-');
if ((pos1==-1) || (pos1==fecha.length()))
return false;
int pos2=fecha.indexOf('-', pos1+1);
if ((pos2==-1) || (pos2==fecha.length()))
return false;
//Regogemos los valores de dia, mes y a�o.
dia = dia.valueOf(fecha.substring(0,pos1));
mes = mes.valueOf(fecha.substring(pos1+1,pos2));
ano = ano.valueOf(fecha.substring(pos2+1));
if (ano.intValue() < 1800) // A�o minimo 1800
FechaCorrecta = false;
else if (mes.intValue() < 1 || mes.intValue() > 12)
FechaCorrecta = false;
else if (dia.intValue() < 1 || dia.intValue() > getDiasMes(mes.intValue(),ano.intValue()))
FechaCorrecta = false;
}
catch (Exception e)
{
FechaCorrecta = false;
}
return FechaCorrecta;
}
/**
* Devuelve el numero de dias en un mes de una a�o en concreto.
*
* @param m Mes del que se quiere saber el numero de dias.
* @param a A�o para el mes solicitado.
* @return int Numero de dias.
*/
public static synchronized int getDiasMes(int m, int a)
{
switch (m)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: return 31;
case 4:
case 6:
case 9:
case 11: return 30;
//Si mes es febrero comprobar a�os bisiestos.
case 2:
if (a%4 == 0)
if (a%100 == 0)
if (a%400 == 0)
return 29;
else
return 28;
else
return 29;
else
return 28;
//Si no es mes valido retornamos 0
default: return 0;
}
}
/**
* Comprueba la valided de una hora.
*
* @param hora String con la hora en formato hh:mm:ss (de 00:00:00 a 23:59:59)
* @return true si la hora es correcta o false si no lo es.
*/
public static synchronized boolean CompruebaHora(String hora)
{
Integer hh = new Integer(0);
Integer mm = new Integer(0);
Integer ss = new Integer(0);
boolean HoraCorrecta = true;
try
{
//Regogemos los valores de dia, mes y a�o.
//Compruebar que existe el caracter ':' en las posiciones 2 y 5
int pos1=hora.indexOf(':');
if ((pos1==-1) || (pos1==hora.length()))
return false;
int pos2=hora.indexOf(':', pos1+1);
if ((pos2==-1) || (pos2==hora.length()))
return false;
//Regogemos los valores de hora, minuto y segundo.
hh = hh.valueOf(hora.substring(0,pos1));
mm = mm.valueOf(hora.substring(pos1+1,pos2));
ss = ss.valueOf(hora.substring(pos2+1));
if (hh.intValue() > 23)
HoraCorrecta = false;
else if (mm.intValue() > 59)
HoraCorrecta = false;
else if (ss.intValue() > 59)
HoraCorrecta = false;
}
catch (Exception e)
{
HoraCorrecta = false;
}
return HoraCorrecta;
}
/**
* Metodo para comprobar si una cadena contiene una fecha y hora.
*
* @param FechaHora Cadena con la fecha y hora
* en formato "dd-mm-yyyy hh:ii:ss"
* @return true si la cadena contiene una fecha y hora valida y
* false en caso contrario.
*/
public static synchronized boolean isDate(String FechaHora)
{
String sTemp="";
String sFecha="";
String sHora="";
int pos=-1;
if (FechaHora!=null)
sTemp=FechaHora.trim();
else
return false;
if(sTemp.length()==0)
return false;
pos=sTemp.indexOf(" ");
if(pos != -1)
{
sFecha=sTemp.substring(0,pos);
if(sFecha.trim().length()==0)
return false;
}
else
return false;
if (pos<sTemp.length())
{
sHora=sTemp.substring(pos+1,sTemp.length());
if(sHora.trim().length()==0)
return false;
}else
return false;
if (CompruebaFecha(sFecha.trim()) && CompruebaHora(sHora.trim()))
return true;
return false;
}
/**
* Metodo para comprobar si un String contiene un entero.
*
* @param cadena Cadena a comprobar.
* @return true si la cadena contiene un numero entero y
* false en caso contrario
*/
public static synchronized boolean isInteger(String cadena)
{
boolean isint=true;
if((cadena.trim().length()==0)||(cadena==null))
return false;
String sTemp=cadena.trim();
int conta = 0;
if (sTemp.charAt(0)=='+' || sTemp.charAt(0)=='-')
conta = 1;
for(int i=conta;i<sTemp.length();++i)
{
if (!(java.lang.Character.isDigit(sTemp.charAt(i))))
isint=false;
}
return isint;
}
/**
* Comprueba que una fecha y hora (inicial) sea menor que la otra (final).
*
* @param Fx_Ini Cadena con la fecha y/u hora inicial en formato dd-mm-yyyy hh:mm:ss
* @param FX_Fin Cadena con la fecha y/u hora inicial en formato dd-mm-yyyy hh:mm:ss
* @return true si la fecha Fx_ini es menor que la fecha Fx_fin, false si es mayor o igual.
*/
public static synchronized boolean ComprobarFxHoraIniFin(String Fx_Ini, String Fx_Fin) throws Exception
{
java.util.Calendar calIni = java.util.Calendar.getInstance();
java.util.Calendar calFin = java.util.Calendar.getInstance();
int diaIni = 0,diaFin = 0,mesIni = 0,mesFin = 0,anoIni = 0,anoFin = 0,
horaIni = 0,horaFin = 0,minIni = 0,minFin = 0,segIni = 0,segFin = 0;
if (!CompruebaFecha(Fx_Ini.substring(0,Fx_Ini.indexOf(" "))))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
if (!CompruebaFecha(Fx_Fin.substring(0,Fx_Fin.indexOf(" "))))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
if (!CompruebaHora(Fx_Ini.substring(Fx_Ini.indexOf(" ") + 1)))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
if (!CompruebaHora(Fx_Fin.substring(Fx_Fin.indexOf(" ") + 1)))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
java.util.StringTokenizer sFechaIni = new java.util.StringTokenizer(Fx_Ini.substring(0,Fx_Ini.indexOf(" ")), "-");
java.util.StringTokenizer sFechaFin = new java.util.StringTokenizer(Fx_Fin.substring(0,Fx_Fin.indexOf(" ")), "-");
java.util.StringTokenizer sHoraIni = new java.util.StringTokenizer(Fx_Ini.substring(Fx_Ini.indexOf(" ") + 1), ":");
java.util.StringTokenizer sHoraFin = new java.util.StringTokenizer(Fx_Fin.substring(Fx_Fin.indexOf(" ") + 1), ":");
diaIni = Integer.parseInt(sFechaIni.nextToken());
mesIni = Integer.parseInt(sFechaIni.nextToken()) - 1;
anoIni = Integer.parseInt(sFechaIni.nextToken());
horaIni = Integer.parseInt(sHoraIni.nextToken());
minIni = Integer.parseInt(sHoraIni.nextToken());
segIni = Integer.parseInt(sHoraIni.nextToken());
diaFin = Integer.parseInt(sFechaFin.nextToken());
mesFin = Integer.parseInt(sFechaFin.nextToken()) - 1;
anoFin = Integer.parseInt(sFechaFin.nextToken());
horaFin = Integer.parseInt(sHoraFin.nextToken());
minFin = Integer.parseInt(sHoraFin.nextToken());
segFin = Integer.parseInt(sHoraFin.nextToken());
calIni.set( anoIni, mesIni, diaIni, horaIni, minIni, segIni);
calFin.set( anoFin, mesFin, diaFin, horaFin, minFin, segFin);
if (calIni.before(calFin)) // || calIni.equals(calFin))
return true;
else
return false;
}
/**
* Devuelve la fecha y hora actual del sistema.
*
* @param Formated True para indicar que devolver� una fecha formateada (dd-mm-yyyy hh:ii:ss)
* Si es false indicamos que se devolver� sin formato (ddmmyyyyhhiiss).
* @return Fecha y Hora actual con formato si Formated = true.
*/
public synchronized static String GenDateString(Calendar calTmp, boolean ConMilisegundos, java.lang.Class clase)
{
return GenDateString(calTmp, ConMilisegundos, clase, null);
}
/**
* Devuelve la fecha y hora actual del sistema.
*
* @param Formated True para indicar que devolver� una fecha formateada (dd-mm-yyyy hh:ii:ss)
* Si es false indicamos que se devolver� sin formato (ddmmyyyyhhiiss).
* @return Fecha y Hora actual con formato si Formated = true.
*/
public synchronized static String GenDateString(Calendar calTmp, boolean ConMilisegundos, java.lang.Class clase, Object value)
{
String fxTmp = new String();
String MinStr = new String();
if (calTmp.get(calTmp.MINUTE) <= 9)
MinStr = "0" + calTmp.get(calTmp.MINUTE);
else
MinStr = "" + calTmp.get(calTmp.MINUTE);
String SegStr = new String();
if (calTmp.get(calTmp.SECOND) <= 9)
SegStr = "0" + calTmp.get(calTmp.SECOND);
else
SegStr = "" + calTmp.get(calTmp.SECOND);
String CentStr = new String();
if ((calTmp.get(calTmp.MILLISECOND) / 10) <= 9)
CentStr = "0" + (calTmp.get(calTmp.MILLISECOND) / 10);
else
CentStr = "" + (calTmp.get(calTmp.MILLISECOND) / 10);
String DiaStr = new String();
if (calTmp.get(calTmp.DAY_OF_MONTH) <= 9)
DiaStr = "0" + calTmp.get(calTmp.DAY_OF_MONTH);
else
DiaStr = "" + calTmp.get(calTmp.DAY_OF_MONTH);
String MesStr = new String();
if ((calTmp.get(calTmp.MONTH) + 1) <= 9)
MesStr = "0" + (calTmp.get(calTmp.MONTH) + 1);
else
MesStr = "" + (calTmp.get(calTmp.MONTH) + 1);
String HoraStr = new String();
if (calTmp.get(calTmp.HOUR_OF_DAY) <= 9)
HoraStr = "0" + calTmp.get(calTmp.HOUR_OF_DAY);
else
HoraStr = "" + calTmp.get(calTmp.HOUR_OF_DAY);
if(clase == null && value == null)
{
fxTmp = DiaStr + "-" + MesStr + "-" + calTmp.get(calTmp.YEAR) + " " +
HoraStr + ":" + MinStr + ":" + SegStr + ((ConMilisegundos)?("." + CentStr):"");
}
if((value == null && clase == java.sql.Date.class) || (value != null && value instanceof java.sql.Date))
{
fxTmp = DiaStr + "-" + MesStr + "-" + calTmp.get(calTmp.YEAR);
}
else if((value == null && clase == java.sql.Time.class) || (value != null && value instanceof java.sql.Time))
{
fxTmp = HoraStr + ":" + MinStr + ":" + SegStr + ((ConMilisegundos)?("." + CentStr):"");
}
else if((value == null && clase == java.sql.Timestamp.class) || (value != null && value instanceof java.sql.Timestamp) || ConMilisegundos)
{
fxTmp = DiaStr + "-" + MesStr + "-" + calTmp.get(calTmp.YEAR);
if(calTmp.get(calTmp.HOUR_OF_DAY) != 0 || calTmp.get(calTmp.MINUTE) != 0 || calTmp.get(calTmp.SECOND) != 0 ||
calTmp.get(calTmp.MILLISECOND) != 0)
fxTmp += " " + HoraStr + ":" + MinStr + ":" + SegStr + ((ConMilisegundos)?("." + CentStr):"");
}
return fxTmp;
}
/**
* Comprueba que una fecha (inicial) sea menor que la otra (final).
*
* @param Fx_Ini Cadena con la fecha inicial en formato dd-mm-yyyy
* @param FX_Fin Cadena con la fecha final en formato dd-mm-yyyy
* @return true si la fecha Fx_ini es menor que la fecha Fx_fin, false si es mayor o igual.
*/
public static synchronized boolean ComprobarFxIniFin(String Fx_Ini, String Fx_Fin) throws Exception
{
java.util.Calendar calIni = java.util.Calendar.getInstance();
java.util.Calendar calFin = java.util.Calendar.getInstance();
int diaIni = 0,diaFin = 0,mesIni = 0,mesFin = 0,anoIni = 0,anoFin = 0;
if (!CompruebaFecha(Fx_Ini))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
if (!CompruebaFecha(Fx_Fin))
throw new Exception("dg.dgutilidades.ComprobarFxIniFin - Formato de fechas incorrectas (usar 'dd-mm-yyyy hh:mm:ss')");
java.util.StringTokenizer sFechaIni = new java.util.StringTokenizer(Fx_Ini, "-");
java.util.StringTokenizer sFechaFin = new java.util.StringTokenizer(Fx_Fin, "-");
diaIni = Integer.parseInt(sFechaIni.nextToken());
mesIni = Integer.parseInt(sFechaIni.nextToken()) - 1;
anoIni = Integer.parseInt(sFechaIni.nextToken());
diaFin = Integer.parseInt(sFechaFin.nextToken());
mesFin = Integer.parseInt(sFechaFin.nextToken()) - 1;
anoFin = Integer.parseInt(sFechaFin.nextToken());
calIni.set(anoIni, mesIni, diaIni);
calFin.set(anoFin, mesFin, diaFin);
if (calIni.before(calFin))
return true;
else
return false;
}
/**
* Devuelve la fecha y hora actual del sistema en formato yyyymmddhhmmss.
* @return Fecha actual del sistema en formato yyyymmddhhmmss.
*/
public synchronized static String GetSysDateTime()
{
java.util.Calendar calTmp = java.util.Calendar.getInstance();
calTmp.setTime(new java.util.Date());
return String.valueOf(calTmp.get(Calendar.YEAR)) +
((calTmp.get(Calendar.MONTH) < 9)?"0":"") + (calTmp.get(Calendar.MONTH) + 1) +
((calTmp.get(Calendar.DAY_OF_MONTH) < 10)?"0":"") + calTmp.get(Calendar.DAY_OF_MONTH) +
((calTmp.get(Calendar.HOUR_OF_DAY) < 10)?"0":"") + calTmp.get(Calendar.HOUR_OF_DAY) +
((calTmp.get(Calendar.MINUTE) < 10)?"0":"") + calTmp.get(Calendar.MINUTE) +
((calTmp.get(Calendar.SECOND) < 10)?"0":"") + calTmp.get(Calendar.SECOND);
}
/**
* Devuelve la fecha y hora actual del sistema en formato yyyy-mm-dd hh:mm:ss.
* @return Fecha actual del sistema en formato yyyy-mm-dd hh:mm:ss.
*/
public synchronized static String GetSysDateTime2()
{
java.util.Calendar calTmp = java.util.Calendar.getInstance();
calTmp.setTime(new java.util.Date());
return String.valueOf(calTmp.get(Calendar.YEAR)) + "-" +
((calTmp.get(Calendar.MONTH) < 9)?"0":"") + (calTmp.get(Calendar.MONTH) + 1) + "-" +
((calTmp.get(Calendar.DAY_OF_MONTH) < 10)?"0":"") + calTmp.get(Calendar.DAY_OF_MONTH) + " " +
((calTmp.get(Calendar.HOUR_OF_DAY) < 10)?"0":"") + calTmp.get(Calendar.HOUR_OF_DAY) + ":" +
((calTmp.get(Calendar.MINUTE) < 10)?"0":"") + calTmp.get(Calendar.MINUTE) + ":" +
((calTmp.get(Calendar.SECOND) < 10)?"0":"") + calTmp.get(Calendar.SECOND);
}
/**
* Devuelve la fecha actual del sistema en formato yyyymmdd.
* @return Fecha actual del sistema en formato yyyymmdd.
*/
public synchronized static String GetSysDate()
{
java.util.Calendar calTmp = java.util.Calendar.getInstance();
calTmp.setTime(new java.util.Date());
return String.valueOf(calTmp.get(Calendar.YEAR)) +
((calTmp.get(Calendar.MONTH) < 9)?"0":"") + (calTmp.get(Calendar.MONTH) + 1) +
((calTmp.get(Calendar.DAY_OF_MONTH) < 10)?"0":"") + calTmp.get(Calendar.DAY_OF_MONTH);
}
/**
* Devuelve la hora actual del sistema en formato hhmmss.
* @return hora actual del sistema en formato hhmmss.
*/
public synchronized static String GetSysTime()
{
java.util.Calendar calTmp = java.util.Calendar.getInstance();
calTmp.setTime(new java.util.Date());
return ((calTmp.get(Calendar.HOUR_OF_DAY) < 10)?"0":"") + calTmp.get(Calendar.HOUR_OF_DAY) +
((calTmp.get(Calendar.MINUTE) < 10)?"0":"") + calTmp.get(Calendar.MINUTE) +
((calTmp.get(Calendar.SECOND) < 10)?"0":"") + calTmp.get(Calendar.SECOND);
}
/**
* Devuelve la fecha y hora actual del sistema.
*
* @param Formated True para indicar que devolver� una fecha formateada (dd-mm-yyyy hh:ii:ss)
* Si es false indicamos que se devolver� sin formato (ddmmyyyyhhiiss).
* @return Fecha y Hora actual con formato si Formated = true.
*/
public synchronized static String GenFechaHora(boolean Formated)
{
String fxTmp = new String();
java.util.Calendar calTmp = java.util.Calendar.getInstance();
java.util.Date dTmp = new java.util.Date();
calTmp.setTime(dTmp);
String MinStr = new String();
if (calTmp.get(calTmp.MINUTE) <= 9)
MinStr = "0" + calTmp.get(calTmp.MINUTE);
else
MinStr = "" + calTmp.get(calTmp.MINUTE);
String SegStr = new String();
if (calTmp.get(calTmp.SECOND) <= 9)
SegStr = "0" + calTmp.get(calTmp.SECOND);
else
SegStr = "" + calTmp.get(calTmp.SECOND);
String CentStr = new String();
if ((calTmp.get(calTmp.MILLISECOND) / 10) <= 9)
CentStr = "0" + (calTmp.get(calTmp.MILLISECOND) / 10);
else
CentStr = "" + (calTmp.get(calTmp.MILLISECOND) / 10);
String DiaStr = new String();
if (calTmp.get(calTmp.DAY_OF_MONTH) <= 9)
DiaStr = "0" + calTmp.get(calTmp.DAY_OF_MONTH);
else
DiaStr = "" + calTmp.get(calTmp.DAY_OF_MONTH);
String MesStr = new String();
if ((calTmp.get(calTmp.MONTH) + 1) <= 9)
MesStr = "0" + (calTmp.get(calTmp.MONTH) + 1);
else
MesStr = "" + (calTmp.get(calTmp.MONTH) + 1);
String HoraStr = new String();
if (calTmp.get(calTmp.HOUR_OF_DAY) <= 9)
HoraStr = "0" + calTmp.get(calTmp.HOUR_OF_DAY);
else
HoraStr = "" + calTmp.get(calTmp.HOUR_OF_DAY);
fxTmp = DiaStr + MesStr + calTmp.get(calTmp.YEAR) +
HoraStr + MinStr + SegStr; //+ CentStr;
if (Formated)
return FormateaFechaHora(fxTmp);
else
return fxTmp;
}
/**
* Metodo para coger el dia del sistema
**/
public synchronized static String GetDia()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(1, 2);
}
/**
* Metodo para coger el mes del sistema
**/
public synchronized static String GetMes()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(2, 4);
}
/**
* Metodo para coger el mes en texto del sistema
**/
public synchronized static String GetMesT()
{
String meses[] = { "Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio",
"Agosto","Septiembre","Octubre","Noviembre","Diciembre" };
java.util.Calendar calTmp = java.util.Calendar.getInstance();
java.util.Date dTmp = new java.util.Date();
calTmp.setTime(dTmp);
return meses[calTmp.get(calTmp.MONTH)];
}
/**
* Metodo para coger el mes en texto Introducido por el usuario
**/
public synchronized static String GetMesT(int mes)
{
String meses[] = { "Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio",
"Agosto","Septiembre","Octubre","Noviembre","Diciembre" };
return meses[mes];
}
/**
* Metodo para coger el A�o del sistema
**/
public synchronized static String GetAnio()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(4, 8);
}
/**
* Metodo para coger la hora del sistema
**/
public synchronized static String GetHora()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(8, 10);
}
/**
* Metodo para coger el minuto del sistema
**/
public synchronized static String GetMinuto()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(10, 12);
}
/**
* Metodo para coger el segundo del sistema
**/
public synchronized static String GetSegundo()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(false);
return sFechaHora.substring(12);
}
/**
* Metodo para coger el d�a de la semana de la fecha que pase el usuario
**/
public synchronized static String GetDiaSemana(int dia, int mes, int anio)
{
String dias[] = { "", "Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado" };
// comprueba el dia, mes y a�o
if (dia < 1 || dia > 31 || mes < 1 || mes > 12 || anio < 1000)
return "";
java.util.Calendar calTmp = java.util.Calendar.getInstance();
java.util.Date dTmp = new java.util.Date();
calTmp.setTime(dTmp);
calTmp.set(anio, mes-1, dia);
return dias[calTmp.get(calTmp.DAY_OF_WEEK)];
}
/**
* Metodo para coger el d�a de la semana del sistema
**/
public synchronized static String GetDiaSemana()
{
String dias[] = { "", "Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sabado" };
java.util.Calendar calTmp = java.util.Calendar.getInstance();
java.util.Date dTmp = new java.util.Date();
calTmp.setTime(dTmp);
return dias[calTmp.get(calTmp.DAY_OF_WEEK)];
}
/**
* Metodo para coger el d�a de la semana de la fecha que pase el usuario
**/
public synchronized static String GetDiaSemanaL(int dia, int mes, int anio)
{
String dias[] = { "", "D","L","M","X","J","V","S" };
// comprueba el dia, mes y a�o
if (dia < 1 || dia > 31 || mes < 1 || mes > 12 || anio < 1000)
return "";
Calendar calTmp = Calendar.getInstance();
Date dTmp = new Date();
calTmp.setTime(dTmp);
calTmp.set(anio, mes-1, dia);
return dias[calTmp.get(calTmp.DAY_OF_WEEK)];
}
/**
* Metodo para coger el d�a de la semana del sistema
**/
public synchronized static String GetDiaSemanaL()
{
String dias[] = { "", "D","L","M","X","J","V","S" };
java.util.Calendar calTmp = java.util.Calendar.getInstance();
java.util.Date dTmp = new java.util.Date();
calTmp.setTime(dTmp);
return dias[calTmp.get(calTmp.DAY_OF_WEEK)];
}
/**
* Metodo para coger la Fecha actual del sistema en
* formato yyyy-mm-dd
**/
public synchronized static String GenFechaCics()
{
// dd-mm-yyyy hh:ii:ss
String sFechaHora = GenFechaHora(true);
return ConvertDateToCics(sFechaHora.substring(0, 10));
}
/**
* Metodo para coger la hora actual del sistema en
* formato hh:mm:ss
**/
public synchronized static String GenHoraCics()
{
// ddmmyyyyhhiiss
String sFechaHora = GenFechaHora(true);
return sFechaHora.substring(11);
}
/**
* Metodo para dar formato a una fecha/hora.
*
* @param FH Cadena con fecha y hora a formatear. ("ddmmyyyyhhiiss")
* @return Una cadena que contiene la fecha y hora en formato "dd-mm-yyyy hh:ii:ss"
*/
public static synchronized String FormateaFechaHora(String FH)
{
return FH.substring(0, 2) + "-" +
FH.substring(2, 4) + "-" +
FH.substring(4, 8) + " " +
FH.substring(8, 10) + ":" +
FH.substring(10, 12) + ":" +
FH.substring(12);
}
/**
* Metodo para dar formato a una fecha
*
* @param FH Cadena con fecha a formatear. ("yyyymmdd")
* @return Una cadena que contiene la fecha en formato "dd-mm-yyyy"
*/
public static synchronized String FormateaFecha(String sFecha)
{
if (sFecha.length() == 8)
return sFecha.substring(6, 8) + "-" +
sFecha.substring(4, 6) + "-" +
sFecha.substring(0, 4);
else
return "";
}
/**
* Este m�todo ejecuta una aplicaci�n Windows o
* abre un documento cuyo tipo est� registrado
* en Windows
*
* @param documento String con la ruta completa del documento o ejecutable que se desea abrir.
* @exception java.lang.Exception
*/
public static synchronized void winEjecuta (String documento) throws Exception
{
Runtime r = Runtime.getRuntime();
Process p = null;
String doc = "start /w /m " + documento;
p = r.exec(doc);
p.waitFor();
int Err = p.exitValue();
if (!(Err == 0))
throw new Exception("utilidades.winEjecuta: No existe el programa o documento");
}
/**
* Saca un valor de un Vector que esta compuesto por la
* combinaci�n nombre campo y valor campo.
*/
public static synchronized Object getValor (Vector sVector, String sCampo) throws Exception
{
int i;
i = sVector.indexOf((String)sCampo);
if (i >= 0)
return (String)sVector.elementAt(i + 1);
else
return "";
}
/**
* Metodo para asignar true o false en un objeto de tipo radio
* en una pagina html
*
* @param Valor ValorMaximo
* @return Una cadena que contiene o tru o false
*/
public static synchronized String ValorLogico(int ivalor, int maximo)
{
if ((ivalor>=0)&&(ivalor<=maximo))
return "true";
else
return "false";
}
/**
* Metodo para devolver el string de un numero
*
* @param Valor Número a convertir
* @return Una cadena que el string del numero
*/
public static synchronized String ValorCaracter(int ivalor)
{
return ""+ivalor;
}
public static synchronized String ValorCaracter(double dvalor)
{
return ""+dvalor;
}
/**
* Metodo para devolver el valor numerico de un string
*
* @param String Cadena a convertir
* @return Un numero
*/
public static synchronized int ValorNumerico(String sTemp)
{
if((sTemp==null) || (sTemp.length()==0))
return 0;
else return new Integer(sTemp).intValue();
}
/**
* Metodo para convertir una fecha-string de CICS - Normal
*
* @param String Cadena a convertir
* @return String
*/
public static synchronized String ConvertDateFromCics(String sTemp)
{
if ((sTemp==null) || (sTemp.length()==0))
return "";
if (sTemp.indexOf("-")<0) // el formato es AAAAMMDD
return sTemp.substring(6,8)+"-"+sTemp.substring(4,6)+"-"+sTemp.substring(0,4);
else
return sTemp.substring(8, 10)+"-"+sTemp.substring(5,7)+"-"+sTemp.substring(0,4);
}
/**
* Metodo para convertir una fecha-string de Normal - CICS
*
* @param String Cadena a convertir
* @return String
*/
public static synchronized String ConvertDateToCics(String sTemp)
{
if ((sTemp==null) || (sTemp.length()!=10))
return "";
return sTemp.substring(6, 10)+"-"+sTemp.substring(3,5)+"-"+sTemp.substring(0,2);
}
/**
* Metodo para convertir una cifra decimal de Normal - CICS
*
* @param String Cadena a convertir
* @return String
*/
public static synchronized String FormateaDecimalesCics(String sTemp)
{
if (sTemp==null)
return "";
// El formato es zzzzzzzzzz,zz
// quita los puntos de los miles
while(sTemp.indexOf(".") != -1)
{
sTemp = sTemp.substring(0, sTemp.indexOf(".")) +
sTemp.substring(sTemp.indexOf(".") + 1);
}
// cuenta los enteros y los decimales
int ent = 0, dec = 0,posdec=0;
String sent = "";
String sdec = "";
posdec = sTemp.indexOf(",");
if(posdec != -1) // hay decimales
sdec = sTemp.substring(posdec+1).trim();
if(posdec != -1)
sent = sTemp.substring(0,posdec).trim();
else
sent = sTemp.trim();
dec = sdec.length();
ent = sent.length();
sent = utilidades.AddLeftCadena(sent, 10, "0");
sdec = utilidades.AddRightCadena(sdec, 2, "0");
return sent + "," + sdec;
}
public static synchronized Vector CalculaPorcentajes(Vector xTemp, int decimales, boolean WithTotal)
{
//System.out.println("entro en calcula Porcentajes");
Vector vPorcentajes=new Vector();
long suma=0L;
String porcentaje="";
int indicepunto=-1;
for(int i=0;i<xTemp.size();i++)
{
suma+=(long)utilidades.ValorNumerico((String)xTemp.elementAt(i));
}
//sTemp=(new Integer(((Number)obj).intValue()).toString())
for(int i=0;i<xTemp.size();i++)
{
vPorcentajes.addElement((String) xTemp.elementAt(i));
porcentaje=utilidades.ValorCaracter((double)utilidades.ValorNumerico((String) xTemp.elementAt(i))/suma);
//System.out.println(porcentaje);
indicepunto =porcentaje.indexOf(".");
if (!(porcentaje.length()<(indicepunto+decimales+1)))
porcentaje=porcentaje.substring(0, indicepunto+decimales+1);
vPorcentajes.addElement(porcentaje);
}
if (WithTotal)
{
Long LTemp= new Long(suma);
vPorcentajes.addElement(LTemp.toString());
}
//for(int i=0;i<vPorcentajes.size();i++)
//System.out.println(vPorcentajes.elementAt(i));
return vPorcentajes;
}
public static synchronized Vector CalculaSuma(Vector xTemp)
{
Vector vSumas=new Vector();
long suma=0L;
for(int i=0;i<xTemp.size();i++)
{
suma+=(long)utilidades.ValorNumerico((String)xTemp.elementAt(i));
}
for(int i=0;i<xTemp.size();i++)
{
vSumas.addElement((String) xTemp.elementAt(i));
}
Long LTemp= new Long(suma);
vSumas.addElement(LTemp.toString());
return vSumas;
}
public static synchronized Vector DatosExcluidos(Vector xTemp, Vector yTemp, boolean bVacios)
{
Vector vResultado=new Vector();
Vector vTabla1=new Vector();
Vector vTabla2=new Vector();
if (bVacios)
for(int i=0;i<xTemp.size();i++)
{
Vector vTemp = (Vector)xTemp.elementAt(i);
if (yTemp.indexOf(vTemp.elementAt(2))>=0)
{
vTabla2.addElement(vTemp.elementAt(0));
vTabla2.addElement(vTemp.elementAt(1));
} else if (((String)vTemp.elementAt(2)).length()==0)
{
vTabla1.addElement(vTemp.elementAt(0));
vTabla1.addElement(vTemp.elementAt(1));
}
}
else
for(int i=0;i<xTemp.size();i++)
{
Vector vTemp = (Vector)xTemp.elementAt(i);
if (yTemp.indexOf(vTemp.elementAt(0))<0)
{
vTabla1.addElement(vTemp.elementAt(0));
vTabla1.addElement(vTemp.elementAt(1));
} else {
vTabla2.addElement(vTemp.elementAt(0));
vTabla2.addElement(vTemp.elementAt(1));
}
}
vResultado.addElement(vTabla1);
vResultado.addElement(vTabla2);
return vResultado;
}
public static String ParametrosSalida(Vector vParameters, Vector vValues,int NumeroColumnas)
{
int LongitudLinea=79;
String sLinea="";
String sTexto="";
int EspacioPorParametro=LongitudLinea/NumeroColumnas;
int contador=0;
for(int i=0;i<vParameters.size();i++)
{
String sTemp=vParameters.elementAt(i)+"->"+vValues.elementAt(i);
sTemp =AddEspacios(EspacioPorParametro,sTemp);
contador++;
if (contador <= NumeroColumnas)
{
sLinea+=sTemp;
}else{
sTexto+=sLinea+"\n";
contador=1;
sLinea=sTemp;
}
}
if(sLinea.trim().length()>0)
sTexto+=sLinea+"\n";
return sTexto;
}
/**
* Metodo que elimina el caractr enviado como parametro
* de la cadena
* @param String cadena: cadena de la que se elimina el caracter
* @param String car: caracter a eliminar
* @return String
*/
public static synchronized String DeleteChar(String cadena, String car)
{
String sResultado = "";
java.util.StringTokenizer elemento = new java.util.StringTokenizer(cadena,car);
while (elemento.hasMoreTokens()){
sResultado+=elemento.nextToken();
}
return sResultado;
}
/**
* Metodo que eliminar los item repetidos en un vector
* @param Vector vEntrada: vector de entrada
* @param int columna: columna sobre la que se efectua la eliminacion
* @return String
*/
public static synchronized Vector EliminaRepetidos(Vector vEntrada, int posicion)
{
Vector vResultado = new Vector();
String Codigo ="";
Trackbug.info("Tama�o: "+vEntrada.size());
for(int i=0; i<vEntrada.size(); i++)
{
Trackbug.info(vEntrada.elementAt(i).toString());
}
for(int i=0; i<vEntrada.size(); i++)
{
Codigo = (String)((Vector)vEntrada.elementAt(i)).elementAt(posicion);
boolean encontrado = false;
for(int j=(i+1);j<vEntrada.size();j++)
{
String newCodigo= (String)((Vector)vEntrada.elementAt(j)).elementAt(posicion);
if(newCodigo.equals(Codigo))
{
encontrado=true;
}
}
if(!(encontrado))
{
Trackbug.info("Salvo posicion "+i);
vResultado.addElement(vEntrada.elementAt(i));
}
}
return vResultado;
}
public static byte[] lee_Archivo (String dirBase, String fichero) throws IOException{
return lee_Archivo((new File(dirBase,fichero)).getAbsolutePath());
}
public static byte[] lee_Archivo (String fichero) throws IOException{
String cadena = "";
try{
File archivo = new File(fichero);
FileInputStream fin = new FileInputStream(archivo);
byte b[] = new byte[6000];
int conta = 0;
while ((conta = fin.read(b,0,6000))!=-1)
{
String cad = new String (b);
if (conta < 60000)
cad = cad.substring(0,conta);
cadena = cadena + cad;
b = new byte[60000];
}
fin.close();
}catch(IOException e) {
Trackbug.error(e, e.getMessage());
return new String("<center><B>ERROR<BR>No ha podido cargar el archivo<BR>" + fichero).getBytes();
}
return cadena.getBytes();
}
public static byte[] lee_Archivo2 (String fichero) throws IOException{
ByteArrayOutputStream bout = new ByteArrayOutputStream();
File archivo = new File(fichero);
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(archivo));
byte b[] = new byte[6000];
int conta = 0;
while ((conta = bin.read(b,0,6000))!=-1)
{
bout.write(b, 0, conta);
}
bin.close();
return bout.toByteArray();
}
public static void crea_Archivo (String fichero, byte [] b) throws IOException
{
try{
File archivo = new File(fichero);
FileOutputStream fout = new FileOutputStream(archivo);
fout.write(b);
fout.close();
}catch(IOException e) {
Trackbug.error(e, e.getMessage());
}
}
//*************************** getURLFile *********************
/**
* Devuelve un array de bytes que lee del fichero que se trae del host o file indicado en la url
* @param fichero Url que que indica de donde coger el fichero
*/
public static byte[] getURLFile(URL url) throws IOException{
InputStream fin = url.openStream();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
byte b[] = new byte[6000];
int conta = 0;
while ((conta = fin.read(b,0,6000))!=-1)
bout.write(b,0,conta);
fin.close();
return bout.toByteArray();
}
//*************************** lee_HTML *********************
/**
* Devuelve un array de bytes que lee del fichero especificado
* @param fichero String que describe el nombre del fichero del que se desea leer.
* Se utiliza la variable PATH est�tica de esta clase para localizar el fichero.
*/
public static byte[] lee_HTML (String fichero) throws IOException{
InputStream fin =null;
String cadena = "";
try{
URL miurl = new URL("file://" + fichero);
fin = miurl.openStream();
byte b[] = new byte[6000];
int conta = 0;
while ((conta = fin.read(b,0,6000))!=-1)
{
String cad = new String (b);
if (conta < 6000)
cad = cad.substring(0,conta);
cadena = cadena + cad;
b = new byte[6000];
}
fin.close();
}catch(IOException e) {
return new String("<center><B>ERROR<BR>No se ha podido conectar con el sistema de plantillas<BR>"+
"al intentar cargar "+fichero).getBytes();
}
return cadena.getBytes();
}
//*************************** lee_HTML *********************
/**
* Devuelve un array de bytes que lee del fichero especificado
* @param fichero String que describe el nombre del fichero del que se desea leer.
*/
public static byte[] lee_HTML (String fichero, String pathimagenes, String pathhtml) throws IOException{
InputStream fin =null;
String cadena = "";
try{
URL miurl = new URL(fichero);
fin = miurl.openStream();
byte b[] = new byte[6000];
int conta = 0;
while ((conta = fin.read(b,0,6000))!=-1)
{
String cad = new String (b);
if (conta < 6000)
cad = cad.substring(0,conta);
cadena = cadena + cad;
b = new byte[6000];
}
fin.close();
}catch(IOException e) {
return new String("<center><B>ERROR<BR>No se ha podido conectar con el sistema de plantillas<BR>"+
"al intentar cargar "+fichero).getBytes();
}
Vector micla = new Vector();
Vector mival = new Vector();
micla.addElement("<!--pathimages-->");
mival.addElement(pathimagenes);
micla.addElement("<!--pathhtml-->");
mival.addElement(pathhtml);
cadena = Inserta_Campo(cadena,micla,mival);
return cadena.getBytes();
}
//*************************** open_Log *********************
/**
* Abrir el fichero de Log con el nombre especificado
* @param filename String que describe el nombre del fichero de Log que se desea abrir
*/
public static void open_Log(String filename)
{
/*if (null == ps)
{
try
{
FileOutputStream fos = new FileOutputStream(filename, true);
ps = new PrintStream(fos);
ps.println ("------- APERTURA FICHERO DE LOG -------");
ps.println ("Fecha:" + (new Date().toString()));
ps.println (" ");
// System.setOut(ps); //Texto de consola a fichero de Log
}catch (IOException ioe)
{
System.out.println (" !!! ERROR... comun.open_Log ");
System.out.println (" " + ioe);
} // end of CATCH
} // end of IF
else
{
// Fichero de Log ya estaba abierto
} //
*/
} // Fin open_Log
//*************************** print_Log *********************
/**
* Imprime en el fichero de Log (siempre que est� abierto) el texto especificado.
* @param texto String con el texto que se quiere imprimir.
*/
public static void print_Log(String texto)
{
/*
if (debug==true && null != ps) {
ps.println(texto+" **"+(new Date().toString())+"**");
}
*/
} // fin print_Log
public static String Limpia_Pagina (String origen) {
int pos = 0;
int posfin = 0;
String cadaux;
while( (pos = origen.indexOf("<!--",posfin)) != -1)
{
posfin = origen.indexOf("-->",pos);
cadaux = origen.substring(0, pos);
cadaux = cadaux + origen.substring(posfin+3);
origen = cadaux;
}
return origen;
} // fin Limpia_Pagina
private static String SEMILLA = "super1274caLIFRAS417TicoESPIa0673dIdOsoMega6s7u3er9cha)ch$ide01la75m4u3er8t6e981";
private static int LENGSEMILLA = 80;
public static String XOR (String texto) {
int pos = 0;
int limite = texto.length();
char resultado[] = new char[limite];
int possemi = 0;
while( pos <limite )
{
if(possemi >= LENGSEMILLA)
possemi = 0;
resultado[pos] = (char)(SEMILLA.charAt(possemi++) ^ texto.charAt(pos++));
}
return new String(resultado);
} // fin Limpia_Pagina
}