1263 lines
39 KiB
Java
1263 lines
39 KiB
Java
/**
|
|
* @(#) Utilidades.java
|
|
*/
|
|
|
|
|
|
package com.tarisan.util;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileReader;
|
|
import java.io.FilenameFilter;
|
|
import java.io.IOException;
|
|
import java.sql.Connection;
|
|
import java.text.NumberFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.Enumeration;
|
|
import java.util.GregorianCalendar;
|
|
import java.util.Locale;
|
|
import java.util.Hashtable;
|
|
import java.util.MissingResourceException;
|
|
import java.util.Properties;
|
|
import java.util.PropertyResourceBundle;
|
|
import java.util.Random;
|
|
import java.util.ResourceBundle;
|
|
import java.util.StringTokenizer;
|
|
import java.util.Vector;
|
|
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
import jakarta.servlet.http.HttpSession;
|
|
|
|
import com.tarisan.control.Paginacion;
|
|
import com.tarisan.control.ParametrosConfiguracion;
|
|
import com.tarisan.data.Ttactmed;
|
|
import com.tarisan.excepcion.*;
|
|
import com.tarisan.log.*;
|
|
|
|
|
|
/**
|
|
* Clase con métodos útiles para la aplicación Tarisan.
|
|
* @author <a href="mailto:sistemas@imqnavarra.com">Dpto. Informática</a>.
|
|
* @version 1.0, 24/09/2003
|
|
*/
|
|
public abstract class Utilidades
|
|
{
|
|
|
|
|
|
/**
|
|
* El objeto <code>Paginacion</code> que controla el número de filas a mostrar por cada página.
|
|
*/
|
|
private Paginacion objPaginacion = new Paginacion();
|
|
|
|
|
|
/**
|
|
* Obtiene el valor del objeto <code>Paginacion</code> para saber que página se está visualizando.
|
|
* @return El objeto <code>Paginacion</code>.
|
|
*/
|
|
public Paginacion getPaginacion()
|
|
{
|
|
return objPaginacion;
|
|
}
|
|
|
|
/**
|
|
* Transforma una sentencia SQL proveniente de un StringBuffer, junto con los arrays de parámetros utilizados a un objeto <code>String</code> conteniendo la sentencia SQL completa, con sus correspondientes valores.
|
|
* <br>Este método se utiliza para grabar datos en la tabla TAREGLOG, donde se almacenan los movimientos de los usuarios por la aplicación, y en la que uno de sus campos es la consulta SQL utilizada.
|
|
* <br>Como en nuestro caso utilizamos prepared statements para realizar las consultas (valores de la consulta se pasan por parámetro), es necesario este método para construir una sentencia SQL que contenga los valores utilizados en la consulta.
|
|
* <br>Destacar que al construir la sentencia SQL no se hace ningún tratamiento especial sobre los valores de la sentencia, no distinguiendo entre valores numéricos o valores de tipo carácter.
|
|
* @param sentencia Objeto <code>StringBuffer</code> que contiene la sentencia SQL utilizada.
|
|
* @param aValores Array que contiene los valores de los parámetros utilizados en la sentencia.
|
|
* @param aCondiciones Array que contiene los parametros de la condicion utilizados en la sentencia.
|
|
* @return Un objeto <code>String</code> conteniendo la sentencia SQL utilizada, incluyendo los valores utilizados por la consulta.
|
|
* @throws
|
|
*/
|
|
public static String obtenerSentenciaSQL(StringBuffer sentencia, Object[] aValores, Object[] aCondiciones) throws ExcepcionTarisan
|
|
{
|
|
StringBuffer strSql = new StringBuffer(sentencia.toString().toUpperCase());
|
|
int i=0;
|
|
|
|
try
|
|
{
|
|
if (strSql.indexOf("INSERT")==0) //sentencia insert
|
|
{
|
|
for (i=0;i<aValores.length;i++)
|
|
strSql = strSql.replace(strSql.indexOf("?"), strSql.indexOf("?") + 1, aValores[i].toString());
|
|
}
|
|
else if(strSql.indexOf("UPDATE")==0) //sentencia update
|
|
{
|
|
for (i=0;i<aValores.length;i++)
|
|
strSql = strSql.replace(strSql.indexOf("?"), strSql.indexOf("?") + 1, aValores[i].toString());
|
|
|
|
for (i=0;i<aCondiciones.length;i++)
|
|
strSql = strSql.replace(strSql.indexOf("?"), strSql.indexOf("?") + 1, aCondiciones[i].toString());
|
|
}
|
|
else if(strSql.indexOf("DELETE")==0) //sentencia delete
|
|
{
|
|
for (i=0;i<aCondiciones.length;i++)
|
|
strSql = strSql.replace(strSql.indexOf("?"), strSql.indexOf("?") + 1, aCondiciones[i].toString());
|
|
}
|
|
else if (strSql.indexOf("SELECT")==0) //sentencia select
|
|
{
|
|
for (i=0;i<aCondiciones.length;i++)
|
|
strSql = strSql.replace(strSql.indexOf("?"), strSql.indexOf("?") + 1, aCondiciones[i].toString());
|
|
}
|
|
else
|
|
{
|
|
LogTarisan.logger.log(NivelLog.ERROR, "Error al intentar obtener la sentencia sql completa para introducirla en la tabla TAREGLOG");
|
|
throw new ExcepcionTarisan("Error al intentar guardar datos en la tabla TAREGLOG.");
|
|
}
|
|
|
|
return strSql.toString();
|
|
}
|
|
catch (ExcepcionTarisan ex)
|
|
{
|
|
LogTarisan.logger.log(NivelLog.ERROR, "ExcepcionTarisan: " + ex.getMensaje());
|
|
throw (ExcepcionTarisan)ex;
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
LogTarisan.logger.log(NivelLog.ERROR, "Exception: " + ex);
|
|
throw new ExcepcionTarisan(ex.getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Tratamiento de un recurso para generar las propiedades definidas en el mismo.
|
|
* @param res El recurso: objeto <code>ResourceBundle</code>.
|
|
* @return Las propiedades cargadas desde el recurso.
|
|
*/
|
|
public static Properties resourceToProperties(ResourceBundle res)
|
|
{
|
|
Properties prop = new Properties ();
|
|
Enumeration keys = res.getKeys ();
|
|
while (keys.hasMoreElements ())
|
|
{
|
|
String key = (String) keys.nextElement ();
|
|
String value = res.getString(key);
|
|
prop.put (key, value);
|
|
}
|
|
return prop;
|
|
}
|
|
|
|
|
|
/**
|
|
* Elimina los objetos de la sesión del usuario al desconectarse de la web.
|
|
* @param sesion La sesión del usuario.
|
|
*/
|
|
public static void eliminarSesion(HttpSession sesion)
|
|
{
|
|
Enumeration listaSession = sesion.getAttributeNames();
|
|
for(; listaSession.hasMoreElements();)
|
|
{
|
|
sesion.removeAttribute((String)listaSession.nextElement());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Genera una cadena con los elementos de un array de <code>Object</code> tomados como entrada.
|
|
* @param elementos[] El array de objetos (instancias de la clase <code>Object</code>).
|
|
* @return La cadena con los elementos del array separados por punto y coma (;).
|
|
*/
|
|
public static String generarStringDeArray(Object[] elementos)
|
|
{
|
|
StringBuffer salida = new StringBuffer();
|
|
|
|
for(int i = 0; i < elementos.length; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
salida.append("; ");
|
|
}
|
|
salida.append(elementos[i]);
|
|
}
|
|
|
|
return salida.toString();
|
|
}
|
|
|
|
/**
|
|
* Genera una cadena con los elementos de un array de <code>double</code> tomados como entrada.
|
|
* @param elementos[] El array de elementos <code>double</code>).
|
|
* @param numDecimales Número de decimales a representar por cada elemento.
|
|
* @return La cadena con los elementos del array separados por punto y coma (;).
|
|
*/
|
|
public static String generarStringDeArray(double[] elementos, int numDecimales)
|
|
{
|
|
StringBuffer salida = new StringBuffer();
|
|
NumberFormat formato = NumberFormat.getInstance();
|
|
formato.setMinimumFractionDigits(numDecimales);
|
|
formato.setMaximumFractionDigits(numDecimales);
|
|
|
|
for(int i = 0; i < elementos.length; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
salida.append("; ");
|
|
}
|
|
salida.append(formato.format(elementos[i]));
|
|
}
|
|
|
|
return salida.toString();
|
|
}
|
|
|
|
/**
|
|
* Genera una cadena con los elementos de un <code>Vector</code> tomados como entrada.
|
|
* @param elementos El <code>Vector</code> de objetos.
|
|
* @return La cadena con los elementos del Vector separados por punto y coma (;).
|
|
*/
|
|
public static String generarStringDeVector(Vector elementos)
|
|
{
|
|
StringBuffer salida = new StringBuffer();
|
|
|
|
for(int i = 0; i < elementos.size(); i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
salida.append("; ");
|
|
}
|
|
salida.append(elementos.elementAt(i));
|
|
}
|
|
|
|
return salida.toString();
|
|
}
|
|
|
|
/**
|
|
* Genera una cadena con los valores de un <code>Hashtable</code> tomados como entrada.
|
|
* @param elementos El <code>Hashtable</code> de objetos.
|
|
* @return La cadena con los valores del Hashtable separados por punto y coma (;).
|
|
*/
|
|
public static String generarStringDeHashtable(Hashtable elementos)
|
|
{
|
|
StringBuffer salida = new StringBuffer();
|
|
int cont = 0;
|
|
|
|
for(Enumeration enum2 = elementos.elements(); enum2.hasMoreElements();)
|
|
{
|
|
if (cont > 0)
|
|
{
|
|
salida.append("; ");
|
|
}
|
|
salida.append(enum2.nextElement());
|
|
cont++;
|
|
}
|
|
|
|
return salida.toString();
|
|
}
|
|
|
|
|
|
/**
|
|
* Obtiene el valor entero (tipo <code>int</code>) correspondiente a una propiedad del fichero de propiedades indicado.
|
|
* <br>Si no existe dicha propiedad o es incorrecta se retorna el valor por defecto indicado.
|
|
* @param propiedades El fichero de propiedades (objeto de la clase <code>PropertyResourceBundle</code>) que contiene la propiedad.
|
|
* @param nombre El nombre de la propiedad definido en el fichero.
|
|
* @param defecto El valor <code>int</code> que toma por defecto la propiedad.
|
|
* @return El valor entero indicado en la propiedad.
|
|
*/
|
|
public static int cargarPropiedadInt(PropertyResourceBundle propiedades, String nombre, int defecto)
|
|
{
|
|
int retorno;
|
|
String valor;
|
|
|
|
try
|
|
{
|
|
valor = propiedades.getString(nombre);
|
|
if (valor == null)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
|
|
{
|
|
|
|
retorno = Integer.parseInt(valor);
|
|
}
|
|
catch(NumberFormatException e)
|
|
{
|
|
|
|
retorno = defecto;
|
|
}
|
|
}
|
|
}
|
|
catch(MissingResourceException ex)
|
|
{
|
|
|
|
retorno = defecto;
|
|
}
|
|
|
|
|
|
return retorno;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor entero largo (tipo <code>long</code>) correspondiente a una propiedad del fichero de propiedades indicado.
|
|
* <br>Si no existe dicha propiedad o es incorrecta se retorna el valor por defecto indicado.
|
|
* @param propiedades El fichero de propiedades (objeto de la clase <code>PropertyResourceBundle</code>) que contiene la propiedad.
|
|
* @param nombre El nombre de la propiedad definido en el fichero.
|
|
* @param defecto El valor <code>long</code> que toma por defecto la propiedad.
|
|
* @return El valor entero largo indicado en la propiedad.
|
|
*/
|
|
public static long cargarPropiedadLong(PropertyResourceBundle propiedades, String nombre, long defecto)
|
|
{
|
|
long retorno;
|
|
String valor;
|
|
|
|
try
|
|
{
|
|
valor = propiedades.getString(nombre);
|
|
if (valor == null)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
retorno = Long.parseLong(valor);
|
|
}
|
|
catch(NumberFormatException e)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
}
|
|
}
|
|
catch(MissingResourceException ex)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
|
|
return retorno;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor doble (tipo <code>double</code>) correspondiente a una propiedad del fichero de propiedades indicado.
|
|
* <br>Si no existe dicha propiedad o es incorrecta se retorna el valor por defecto indicado.
|
|
* @param propiedades El fichero de propiedades (objeto de la clase <code>PropertyResourceBundle</code>) que contiene la propiedad.
|
|
* @param nombre El nombre de la propiedad definido en el fichero.
|
|
* @param defecto El valor <code>double</code> que toma por defecto la propiedad.
|
|
* @return El valor doble indicado en la propiedad.
|
|
*/
|
|
public static double cargarPropiedadDouble(PropertyResourceBundle propiedades, String nombre, double defecto)
|
|
{
|
|
double retorno;
|
|
String valor;
|
|
|
|
try
|
|
{
|
|
valor = propiedades.getString(nombre);
|
|
if (valor == null)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
retorno = Double.parseDouble(valor);
|
|
}
|
|
catch(NumberFormatException e)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
}
|
|
}
|
|
catch(MissingResourceException ex)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
|
|
return retorno;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor carácter (tipo <code>char</code>) correspondiente a una propiedad del fichero de propiedades indicado.
|
|
* <br>Si no existe dicha propiedad o es incorrecta se retorna el valor por defecto indicado.
|
|
* @param propiedades El fichero de propiedades (objeto de la clase <code>PropertyResourceBundle</code>) que contiene la propiedad.
|
|
* @param nombre El nombre de la propiedad definido en el fichero.
|
|
* @param defecto El valor <code>char</code> que toma por defecto la propiedad.
|
|
* @return El valor carácter indicado en la propiedad.
|
|
*/
|
|
public static char cargarPropiedadChar(PropertyResourceBundle propiedades, String nombre, char defecto)
|
|
{
|
|
char retorno;
|
|
String valor;
|
|
|
|
try
|
|
{
|
|
valor = propiedades.getString(nombre);
|
|
if (valor == null)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else if (valor.length() != 1)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
retorno = valor.charAt(0);
|
|
}
|
|
}
|
|
catch(MissingResourceException ex)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
|
|
return retorno;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor cadena (tipo <code>String</code>) correspondiente a una propiedad del fichero de propiedades indicado.
|
|
* <br>Si no existe dicha propiedad o es incorrecta se retorna el valor por defecto indicado.
|
|
* @param propiedades El fichero de propiedades (objeto de la clase <code>PropertyResourceBundle</code>) que contiene la propiedad.
|
|
* @param nombre El nombre de la propiedad definido en el fichero.
|
|
* @param defecto El valor <code>String</code> que toma por defecto la propiedad.
|
|
* @return El valor cadena indicado en la propiedad.
|
|
*/
|
|
public static String cargarPropiedadString(PropertyResourceBundle propiedades, String nombre, String defecto)
|
|
{
|
|
String retorno;
|
|
String valor;
|
|
|
|
try
|
|
{
|
|
valor = propiedades.getString(nombre);
|
|
if (valor == null)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
if (valor.compareTo("") == 0)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
else
|
|
{
|
|
retorno = valor;
|
|
}
|
|
}
|
|
}
|
|
catch(MissingResourceException ex)
|
|
{
|
|
retorno = defecto;
|
|
}
|
|
|
|
return retorno;
|
|
}
|
|
|
|
/**
|
|
* Formatea un valor <code>double</code> con el número de decimales indicado, retornando una cadena <code>String</code> como resultado.
|
|
* @param valor La cantidad numérica a formatear.
|
|
* @param numDecimales El número de decimales a representar.
|
|
* @return La cadena con el número formateado.
|
|
*/
|
|
public static String formatearDouble(double valor, int numDecimales)
|
|
{
|
|
NumberFormat formato = NumberFormat.getInstance(new Locale("ES"));
|
|
formato.setMinimumFractionDigits(numDecimales);
|
|
formato.setMaximumFractionDigits(numDecimales);
|
|
return formato.format(valor);
|
|
}
|
|
|
|
/**
|
|
* Formatea un valor <code>double</code> con el número de enteros indicado rellenando con ceros por la izquierda la parte entera,
|
|
* además no escribe el caracter separador de miles, retornando una cadena <code>String</code> como resultado.
|
|
* @param valor La cantidad numérica a formatear.
|
|
* @param numEnteros El número de posiciones a representar en la parte entera.
|
|
* @param numDecimales El número de decimales a representar.
|
|
* @return La cadena con el número formateado.
|
|
*/
|
|
public static String formatearEntero(double valor, int numEnteros, int numDecimales)
|
|
{
|
|
NumberFormat formato = NumberFormat.getInstance(new Locale("ES"));
|
|
|
|
formato.setGroupingUsed(false);
|
|
|
|
formato.setMinimumIntegerDigits(numEnteros);
|
|
formato.setMaximumIntegerDigits(numEnteros);
|
|
|
|
formato.setMinimumFractionDigits(numDecimales);
|
|
formato.setMaximumFractionDigits(numDecimales);
|
|
|
|
return formato.format(valor);
|
|
}
|
|
|
|
/**
|
|
* Formatea un valor <code>int</code> con el número de enteros indicado rellenando con ceros por la izquierda la parte entera,
|
|
* además no escribe el caracter separador de miles, retornando una cadena <code>String</code> como resultado.
|
|
* @param valor La cantidad numérica a formatear.
|
|
* @param numEnteros El número de posiciones a representar en la parte entera.
|
|
* @return La cadena con el número formateado.
|
|
*/
|
|
public static String formatearEntero(int valor, int numEnteros)
|
|
{
|
|
NumberFormat formato = NumberFormat.getInstance(new Locale("ES"));
|
|
|
|
formato.setGroupingUsed(false);
|
|
|
|
formato.setMinimumIntegerDigits(numEnteros);
|
|
formato.setMaximumIntegerDigits(numEnteros);
|
|
|
|
return formato.format(valor);
|
|
}
|
|
|
|
|
|
/**
|
|
* Encripta el valor de un texto a partir de una clave de cifrado.
|
|
* @param texto El valor del texto a encriptar.
|
|
* @param clave La clave de cifrado.
|
|
* @return El texto encriptado.
|
|
*/
|
|
public static String encripta(String texto, String clave)
|
|
{
|
|
if (texto == null || texto.equals("") || clave == null || clave.equals(""))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
byte[] src = null;
|
|
byte[] key = null;
|
|
|
|
try
|
|
{
|
|
key = clave.getBytes("ISO-8859-1");
|
|
src = texto.getBytes("ISO-8859-1");
|
|
}
|
|
catch (java.io.UnsupportedEncodingException uee)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
StringBuffer temp = new StringBuffer();
|
|
|
|
for (int i = 0; i < src.length; i++)
|
|
{
|
|
byte result = (byte)(src[i] ^ key[i % key.length]);
|
|
byte tmpResult;
|
|
tmpResult = (byte)((result >> 4)&(byte)15);
|
|
temp.append(Integer.toHexString(tmpResult).toUpperCase());
|
|
tmpResult = (byte)(result & (byte)15);
|
|
temp.append(Integer.toHexString(tmpResult).toUpperCase());
|
|
}
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "Contraseña encriptada:"+temp.toString());
|
|
return temp.toString();
|
|
}
|
|
|
|
/**
|
|
* Desencripta el valor de un texto a partir de una clave de cifrado.
|
|
* @param texto El valor del texto a desencriptar.
|
|
* @param clave La clave de cifrado.
|
|
* @return El texto desencriptado.
|
|
*/
|
|
public static String desencripta(String texto, String clave)
|
|
{
|
|
if (texto == null || texto.equals("") || texto.length() % 2 != 0 || clave == null || clave.equals(""))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
byte[] key;
|
|
try
|
|
{
|
|
key = clave.getBytes("ISO-8859-1");
|
|
}
|
|
catch (java.io.UnsupportedEncodingException e)
|
|
{
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
|
|
StringBuffer temp = new StringBuffer();
|
|
|
|
for (int i = 0; i < texto.length(); i+=2)
|
|
{
|
|
String part = texto.substring(i, i+2);
|
|
byte[] result = new byte[1];
|
|
result[0] = (byte)(Integer.parseInt(part,16) ^ key[(i/2) % key.length]);
|
|
try
|
|
{
|
|
temp.append(new String(result,"ISO-8859-1"));
|
|
}
|
|
catch (java.io.UnsupportedEncodingException e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
return temp.toString();
|
|
}
|
|
|
|
|
|
/**
|
|
* Formatea la demora entre dos fechas (a partir de su diferencia numérica).
|
|
* @param demora El valor numérico de la demora.
|
|
* @return El valor de la demora formateado.
|
|
*/
|
|
public static String calcularDemora(long demora)
|
|
{
|
|
SimpleDateFormat sdf;
|
|
|
|
if (demora < 1000)
|
|
{
|
|
//Demora menor de 1 segundo
|
|
sdf = new SimpleDateFormat("SSS'ms'");
|
|
}
|
|
else if (demora < 60000)
|
|
{
|
|
//Demora menor de 1 minuto
|
|
sdf = new SimpleDateFormat("ss's' SSS'ms'");
|
|
}
|
|
else if (demora < 3600000)
|
|
{
|
|
//Demora menor de 1 hora
|
|
sdf = new SimpleDateFormat("mm'm' ss's' SSS'ms'");
|
|
}
|
|
else
|
|
{
|
|
//Demora mayor de 1 hora
|
|
sdf = new SimpleDateFormat("HH'h' mm'm' ss's' SSS'ms'");
|
|
}
|
|
|
|
return sdf.format(new Date(demora));
|
|
}
|
|
|
|
/**
|
|
* Devuelve si el número de tarjeta pasado como parámetro cumple el algoritmo Luhn
|
|
* @param tarjeta El número de tarjeta
|
|
* @return Boolean, cumple Lhun o no
|
|
*/
|
|
public static boolean calcularLuhn(String tarjeta)
|
|
{
|
|
boolean resul = false;
|
|
int comprobante = Integer.valueOf(tarjeta.substring(tarjeta.length()-1));
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "Comprobamos el luhn de la tarjeta: "+tarjeta+", con el comprobante de: "+comprobante);
|
|
int pares = 0;
|
|
int impares = 0;
|
|
try
|
|
{
|
|
for (int i=tarjeta.length()-2; i>=0; i--)
|
|
{
|
|
if(i%2 == 0)
|
|
{
|
|
//impares (al empezar de 0, la posición 0 es la 1)
|
|
impares += Integer.valueOf(tarjeta.substring(i, i+1));
|
|
}
|
|
else
|
|
{
|
|
//pares
|
|
pares += Integer.valueOf(tarjeta.substring(i, i+1));
|
|
}
|
|
}
|
|
int suma = (impares * 2)+pares;
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "La suma final es: "+suma);
|
|
String ultimaposicion = String.valueOf(suma).substring(String.valueOf(suma).length()-1);
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "La última posicion es: "+ultimaposicion);
|
|
int resta = 10-Integer.valueOf(ultimaposicion);
|
|
if(comprobante == resta)
|
|
{
|
|
resul = true;
|
|
}
|
|
|
|
else if(comprobante == 0 && resta == 10)
|
|
{
|
|
resul = true;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LogTarisan.logger.log(NivelLog.ERROR, "Error al comprobar el luhn");
|
|
return resul;
|
|
}
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "El resultado de comprobar el Luhn es: "+resul);
|
|
return resul;
|
|
}
|
|
|
|
/**
|
|
* Devuelve una cadena invertida
|
|
* @param normal
|
|
* @return
|
|
*/
|
|
public static String invertir_string(String normal)
|
|
{
|
|
String invertida = new String();
|
|
for (int x=normal.length()-1;x>=0;x--)
|
|
invertida = invertida + normal.charAt(x);
|
|
|
|
return invertida;
|
|
}
|
|
|
|
/**
|
|
* Funcion que me devolverá si tengo que mostrar el botón de ver resultados o no en función de si el paciente ha firmado la autorización
|
|
* o si el análisis que queremos ver lo pidió el médico que se ha logado en tarisan.
|
|
* @param Colectivo, Poliza, Orden y Médico solicitante
|
|
* @return Verdadero o falso, para mostrar o no el botón de "Ver resultados"
|
|
*/
|
|
public static boolean mostrarBtnVerResultados(String col, String pol, String ord, int med)
|
|
{
|
|
boolean resultado = true;
|
|
|
|
return resultado;
|
|
}
|
|
|
|
/**
|
|
* DEPRECIADO -- LEEMOS DE BBDD
|
|
* Función que me devolverá un string con las noticias que existán en el fichero
|
|
* @param ruta Ruta al fichero de texto con las noticias.
|
|
* @return String con las noticias
|
|
*/
|
|
public static String leerNoticias(String ruta)
|
|
{
|
|
String noticias = "";
|
|
try {
|
|
BufferedReader br = new BufferedReader(new FileReader(ruta));
|
|
try {
|
|
StringBuilder sb = new StringBuilder();
|
|
String line = br.readLine();
|
|
|
|
while (line != null) {
|
|
sb.append(line);
|
|
sb.append("\n");
|
|
line = br.readLine();
|
|
}
|
|
noticias = sb.toString();
|
|
br.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
} catch (FileNotFoundException e) {
|
|
LogTarisan.logger.log(NivelLog.WARN, "No existe el fichero de noticias. No se mostrará nada");
|
|
}
|
|
|
|
return noticias;
|
|
}
|
|
|
|
public static Vector consultaGenerica(String sqlSelect)
|
|
{
|
|
Vector rs = null;
|
|
try {
|
|
Connection conexion = ParametrosConfiguracion.dataStore.obtenerConexion();
|
|
rs = ParametrosConfiguracion.dataStore.seleccionar(sqlSelect);
|
|
} catch (ExcepcionTarisan e) {
|
|
e.printStackTrace();
|
|
}
|
|
return rs;
|
|
}
|
|
|
|
public static int calcularEdad(Date fechaNacimiento, Date fechaActual){
|
|
Calendar fechaAct = Calendar.getInstance();
|
|
fechaAct.setTime(fechaActual);
|
|
|
|
Calendar fechaNac = Calendar.getInstance();
|
|
fechaNac.setTime(fechaNacimiento);
|
|
|
|
int dif_anios = fechaAct.get(Calendar.YEAR) - fechaNac.get(Calendar.YEAR);
|
|
int dif_meses = fechaAct.get(Calendar.MONTH) - fechaNac.get(Calendar.MONTH);
|
|
int dif_dias = fechaAct.get(Calendar.DAY_OF_MONTH) - fechaNac.get(Calendar.DAY_OF_MONTH);
|
|
|
|
//Si está en ese año pero todavía no los ha cumplido
|
|
if(dif_meses<0 || (dif_meses==0 && dif_dias<0)){
|
|
dif_anios--;
|
|
}
|
|
return dif_anios;
|
|
}
|
|
|
|
public static boolean tarjetaNuestraoDesplazado(String tarjeta)
|
|
{
|
|
boolean nuestra = true;
|
|
if(tarjeta.compareTo(ParametrosConfiguracion.bin_chipcard_propios) == 0)
|
|
nuestra = true;
|
|
else
|
|
nuestra = false;
|
|
|
|
return nuestra;
|
|
}
|
|
|
|
public static String extraerPista2(String pistas1y2)
|
|
{
|
|
String resultado ="";
|
|
StringTokenizer st = new StringTokenizer(pistas1y2, "%");
|
|
while (st.hasMoreTokens())
|
|
{
|
|
//obtenemos los String correspondientes a cada pista
|
|
String strtarjeta = st.nextToken() ;
|
|
//boolean desplazado = false;
|
|
if(strtarjeta.length()>50 && strtarjeta.length()<80)
|
|
{
|
|
//Pista1
|
|
}
|
|
else
|
|
{
|
|
//pista2
|
|
resultado = strtarjeta;
|
|
}
|
|
}
|
|
|
|
return resultado;
|
|
}
|
|
|
|
public static String formatear_fecha(java.sql.Date fecha)
|
|
{
|
|
String resul = "";
|
|
resul = fecha.toString().substring(8)+"/"+fecha.toString().substring(5, 7)+"/"+fecha.toString().substring(0, 4);
|
|
return resul;
|
|
}
|
|
|
|
//Sumarle dias a una fecha determinada
|
|
//@param fch La fecha para sumarle los dias
|
|
//@param dias Numero de dias a agregar
|
|
//@return La fecha agregando los dias
|
|
public static java.sql.Date sumarFechasDias(java.sql.Date fch, int dias) {
|
|
Calendar cal = new GregorianCalendar();
|
|
cal.setTimeInMillis(fch.getTime());
|
|
cal.add(Calendar.DATE, dias);
|
|
return new java.sql.Date(cal.getTimeInMillis());
|
|
}
|
|
|
|
public static int contar_coincidencias(String cadena, String texto_a_buscar)
|
|
{
|
|
int contador = 0;
|
|
while (cadena.indexOf(texto_a_buscar) > -1) {
|
|
cadena = cadena.substring(cadena.indexOf(
|
|
texto_a_buscar)+texto_a_buscar.length(),cadena.length());
|
|
contador++;
|
|
}
|
|
|
|
return contador;
|
|
}
|
|
|
|
/*
|
|
* String pr="cadena a comparar";
|
|
char _toCompare='c';
|
|
int veces=0;
|
|
char []caracteres=pr.toCharArray();
|
|
for(int i=0;i<=caracteres.length-1;i++){
|
|
if(_toCompare ==caracteres[i]){
|
|
veces++;
|
|
}
|
|
|
|
}
|
|
System.out.println("Se encontro: "+veces+" veces");
|
|
*/
|
|
/**
|
|
* Función que nos devuelve el último día del mes y año pasado por parametros
|
|
* @param mes
|
|
* @param anio
|
|
* @return
|
|
*/
|
|
public static int ultimo_dia_mes(int mes, int anio)
|
|
{
|
|
int resul=0;
|
|
Calendar cal = Calendar.getInstance();
|
|
cal.set(anio, mes-1, 1);
|
|
resul = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
|
|
return resul;
|
|
}
|
|
|
|
|
|
/**
|
|
* Función que nos devuelve el nombre del fichero pdf de facturacion de un médico determinado
|
|
* @param medico el código del medico para el que generar el pdf
|
|
* @param opcion si es 1 crea un fichero nuevo, que no exista, si es 0 busca el último que se ha creado para mostrarlo
|
|
* @return
|
|
*/
|
|
public static String Nombre_fact_pdf(int medico, int opcion)
|
|
{
|
|
String resul ="";
|
|
if(opcion == 1)
|
|
{
|
|
Random rnd = new Random();
|
|
Integer next = rnd.nextInt(100);
|
|
/*resul = ParametrosConfiguracion.ruta_pdf+"Fact_" + medico + "_"+next+".pdf";*/
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones_facturas + medico + "_"+next+".pdf";
|
|
File fichero = new File(resul);
|
|
while(fichero.exists())
|
|
{
|
|
next = rnd.nextInt(100);
|
|
/*resul = ParametrosConfiguracion.ruta_pdf+"Fact_" + medico + "_"+next+".pdf";*/
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones_facturas + medico + "_"+next+".pdf";
|
|
fichero = null;
|
|
fichero = new File(resul);
|
|
}
|
|
while(!fichero.exists())
|
|
{
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones + medico + "_"+next+".pdf";
|
|
fichero = new File(resul);
|
|
while(fichero.exists())
|
|
{
|
|
next = rnd.nextInt(100);
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones + medico + "_"+next+".pdf";
|
|
fichero = null;
|
|
fichero = new File(resul);
|
|
}
|
|
}
|
|
}
|
|
else //estamos buscando el último fichero creado para el médico en cuestión.
|
|
{
|
|
//file.lastModified() milliseconds
|
|
/*File f = new File(ParametrosConfiguracion.ruta_pdf);
|
|
final String nombre_fichero = "Fact_" +medico + "_";*/
|
|
File f = new File(ParametrosConfiguracion.ruta_pdf_peticiones_facturas);
|
|
final String nombre_fichero = medico + "_";
|
|
FilenameFilter filtro = new FilenameFilter() {
|
|
public boolean accept(File dir, String name) {
|
|
return name.startsWith(nombre_fichero) && name.endsWith("pdf");
|
|
}
|
|
};
|
|
File[] matchingFiles = f.listFiles(filtro);
|
|
|
|
long time = 0;
|
|
|
|
for(int j=0;j<matchingFiles.length;j++)
|
|
{
|
|
//time = matchingFiles[j].lastModified();
|
|
if(matchingFiles[j].lastModified() > time)
|
|
{
|
|
/*resul = ParametrosConfiguracion.ruta_pdf+matchingFiles[j].getName();*/
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones_facturas+matchingFiles[j].getName();
|
|
time = matchingFiles[j].lastModified();
|
|
}
|
|
}
|
|
|
|
if (resul.compareTo("")==0){
|
|
File f2 = new File(ParametrosConfiguracion.ruta_pdf_peticiones);
|
|
final String nombre_fichero2 = medico + "_";
|
|
FilenameFilter filtro2 = new FilenameFilter() {
|
|
public boolean accept(File dir, String name) {
|
|
return name.startsWith(nombre_fichero2) && name.endsWith("pdf");
|
|
}
|
|
};
|
|
File[] matchingFiles2 = f2.listFiles(filtro2);
|
|
|
|
long time2 = 0;
|
|
|
|
for(int j=0;j<matchingFiles2.length;j++)
|
|
{
|
|
//time = matchingFiles[j].lastModified();
|
|
if(matchingFiles2[j].lastModified() > time2)
|
|
{
|
|
/*resul = ParametrosConfiguracion.ruta_pdf+matchingFiles[j].getName();*/
|
|
resul = ParametrosConfiguracion.ruta_pdf_peticiones+matchingFiles2[j].getName();
|
|
time2 = matchingFiles2[j].lastModified();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
return resul;
|
|
}
|
|
|
|
public static Vector ordenarVectorTTActmed(Vector vectorTTActmed){
|
|
int actoMenor = 0;
|
|
int acto1 = 0;
|
|
int acto2 = 0;
|
|
//boolean borrado = false;
|
|
//Quitar duplicados
|
|
for(int i=0;i<vectorTTActmed.size();i++){
|
|
acto1=((Ttactmed)vectorTTActmed.elementAt(i)).getActo();
|
|
|
|
for(int j=0;j<vectorTTActmed.size();j++){
|
|
acto2=((Ttactmed)vectorTTActmed.elementAt(j)).getActo();
|
|
|
|
if (i!=j){
|
|
|
|
if(acto1==acto2)
|
|
vectorTTActmed.remove(j);
|
|
}
|
|
}
|
|
}
|
|
//ordenar vector
|
|
for(int i=0;i<vectorTTActmed.size();i++){
|
|
actoMenor = ((Ttactmed)vectorTTActmed.elementAt(i)).getActo();
|
|
|
|
for(int j=i+1;j<vectorTTActmed.size()-1;j++){
|
|
|
|
if(((Ttactmed)vectorTTActmed.elementAt(i)).getActo()>((Ttactmed)vectorTTActmed.elementAt(j)).getActo()){
|
|
|
|
if (actoMenor>((Ttactmed)vectorTTActmed.elementAt(j)).getActo()){
|
|
Object variableauxiliar=vectorTTActmed.elementAt(i);
|
|
vectorTTActmed.set(i,vectorTTActmed.elementAt(j));
|
|
vectorTTActmed.set(j,variableauxiliar);
|
|
actoMenor = ((Ttactmed)vectorTTActmed.elementAt(i)).getActo();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
return vectorTTActmed;
|
|
}
|
|
|
|
|
|
public static Vector ObtenerPaginacionDeUnVector(Vector vSeleccion, int pagina)
|
|
{
|
|
int elementosPaginacion=1;
|
|
int intNumPagina=0;
|
|
int intFilasPorPagina = 10;
|
|
int intNumRegistrosTotales = vSeleccion.size();
|
|
int intNumPaginasTotales = intNumRegistrosTotales / intFilasPorPagina;
|
|
Vector vResultado = new Vector();
|
|
vResultado.add(intNumPaginasTotales);
|
|
|
|
if (intNumRegistrosTotales % intFilasPorPagina != 0)
|
|
intNumPaginasTotales++;
|
|
|
|
//objPaginacion.inicializarPaginacion(rs);
|
|
if (intNumRegistrosTotales!=0)
|
|
{
|
|
int posicion=0;
|
|
//objPaginacion.realizarPaginacion(rs, pagina);
|
|
if (pagina!=0 && intNumRegistrosTotales!=0)
|
|
{
|
|
posicion = ((pagina - 1) * intFilasPorPagina);
|
|
if (posicion == 0){
|
|
//vSeleccion(0);
|
|
}
|
|
else{
|
|
//vSeleccion(posicion);
|
|
}
|
|
|
|
intNumPagina = pagina;
|
|
}
|
|
else
|
|
intNumPagina = 0;
|
|
|
|
|
|
vResultado.add(intNumPagina);
|
|
int i=0;
|
|
while((i<=vSeleccion.size()) && (elementosPaginacion <= intFilasPorPagina))
|
|
{
|
|
if (pagina!=0){
|
|
//Se quiere realizar la paginacion
|
|
elementosPaginacion++;
|
|
}
|
|
i+=1;
|
|
}
|
|
}
|
|
|
|
LogTarisan.logger.log(NivelLog.DEBUG, "Seleccionados " + vSeleccion.size() + " registros de la tabla ttactmed");
|
|
|
|
return vResultado;
|
|
}
|
|
|
|
/* Busca todos los ficheros, que haya en el directorio especificado, cuyo nombre contengan el parámetro de búsqueda que introduzcamos */
|
|
public static String[] buscar_ficheros2(String filtro, String directorio)
|
|
{
|
|
final String filtroBusqueda = filtro;
|
|
|
|
//String resultado="";
|
|
File dir = new File(directorio);
|
|
FilenameFilter filter = new FilenameFilter() {
|
|
public boolean accept(File dir, String name) {
|
|
return name.startsWith(filtroBusqueda);
|
|
}
|
|
};
|
|
String[] children = dir.list(filter);
|
|
/*if (children == null) {
|
|
resultado = "No hay archivos";
|
|
}
|
|
else {
|
|
for (int f=0; f < children.length ; f++) {
|
|
String filename = children[f];
|
|
resultado = "Archivos encontrados";
|
|
}
|
|
} */
|
|
return children;
|
|
}
|
|
|
|
/* Busca todos los ficheros, que haya en el directorio especificado de manera recursiva */
|
|
public static Vector<String> buscar_ficheros_recursivo(File directorio) {
|
|
|
|
Vector<String> resultado = new Vector();
|
|
|
|
File listFile[] = directorio.listFiles();
|
|
if (listFile != null) {
|
|
for (int i = 0; i < listFile.length; i++) {
|
|
if (listFile[i].isDirectory()) {
|
|
buscar_ficheros_recursivo(listFile[i]);
|
|
} else {
|
|
resultado.add(listFile[i].getPath());
|
|
}
|
|
}
|
|
}
|
|
|
|
return resultado;
|
|
}
|
|
|
|
|
|
/* Busca todos los ficheros, que haya en el directorio especificado de manera recursiva */
|
|
public static Vector<String> buscar_ficheros_recursivo_rx(File directorio) {
|
|
|
|
Vector<String> resultado = new Vector();
|
|
|
|
File carpetas[] = directorio.listFiles();
|
|
if (carpetas != null) {
|
|
for (int i = 0; i < carpetas.length; i++) {
|
|
if (carpetas[i].isDirectory()) {
|
|
File archivos[] = carpetas[i].listFiles();
|
|
if (archivos != null) {
|
|
for (int x = 0; x < archivos.length; x++) {
|
|
if (archivos[x].isFile()) {
|
|
resultado.add(archivos[x].getPath());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return resultado;
|
|
}
|
|
|
|
/* Busca todos los informes, que haya en el directorio especificado que coincida con el episodio que corresponda */
|
|
public static Vector<String> buscar_informes_rx(File directorio, String filtro) {
|
|
|
|
Vector<String> resultado = new Vector();
|
|
|
|
File carpetas[] = directorio.listFiles();
|
|
if (carpetas != null) {
|
|
for (int i = 0; i < carpetas.length; i++) {
|
|
if (carpetas[i].isDirectory()) {
|
|
|
|
if (carpetas[i].getPath().indexOf(filtro)!=-1){
|
|
|
|
File archivos[] = carpetas[i].listFiles();
|
|
if (archivos != null) {
|
|
for (int x = 0; x < archivos.length; x++) {
|
|
if (archivos[x].isFile()) {
|
|
resultado.add(archivos[x].getPath());
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
return resultado;
|
|
}
|
|
|
|
/* Busca todos los ficheros, que haya en el directorio especificado, cuyo nombre contengan el parámetro de búsqueda que introduzcamos */
|
|
public static Vector<String> buscar_ficheros(String filtro, String directorio)
|
|
{
|
|
File dir = new File(directorio);
|
|
|
|
Vector<String> resultado = new Vector();
|
|
|
|
File archivos[] = dir.listFiles();
|
|
for (int i = 0; i < archivos.length; i++) {
|
|
if (archivos[i].isFile()) {
|
|
if (archivos[i].getPath().indexOf(filtro)!=-1){
|
|
|
|
String nombreFichero = archivos[i].getPath().substring(directorio.length());
|
|
String[] partes = nombreFichero.split("\\.");
|
|
nombreFichero = partes[0];
|
|
|
|
resultado.add(nombreFichero);
|
|
LogTarisan.logger.log(NivelLog.DEBUG, nombreFichero);
|
|
}
|
|
}
|
|
}
|
|
return resultado;
|
|
}
|
|
|
|
public static String[] buscar_ficheros3(String filtro, String directorio)
|
|
{
|
|
final String filtroBusqueda = filtro;
|
|
Vector<String> resultado = new Vector<String>();
|
|
|
|
File dir = new File(directorio);
|
|
FilenameFilter filter = new FilenameFilter() {
|
|
public boolean accept(File dir, String name) {
|
|
if (name.contains(filtroBusqueda)) {
|
|
resultado.addElement(name);
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
|
|
}
|
|
};
|
|
String[] children = dir.list(filter);
|
|
return children;
|
|
}
|
|
|
|
/* Devuelve un array con los ficheros y carpetas que contiene un directorio*/
|
|
public static Vector<String> buscar_ficheros_directorio(String directorio)
|
|
{
|
|
File dir = new File(directorio);
|
|
|
|
Vector<String> resultado = new Vector<String>();
|
|
|
|
File archivos[] = dir.listFiles();
|
|
for (int i = 0; i < archivos.length; i++) {
|
|
if (archivos[i].isFile()) {
|
|
|
|
String nombreFichero = archivos[i].getPath().substring(directorio.length());
|
|
String[] partes = nombreFichero.split("\\.");
|
|
nombreFichero = partes[0];
|
|
|
|
resultado.add(nombreFichero);
|
|
LogTarisan.logger.log(NivelLog.DEBUG, nombreFichero);
|
|
}
|
|
}
|
|
return resultado;
|
|
}
|
|
|
|
public static Vector<String> buscar_ficheros_array(String filtro, Vector<String> archivos)
|
|
{
|
|
Vector<String> resultado = new Vector<String>();
|
|
|
|
for (int i = 0; i < archivos.size(); i++) {
|
|
if (archivos.elementAt(i).indexOf(filtro)!=-1){
|
|
|
|
String nombreFichero = archivos.elementAt(i);
|
|
|
|
resultado.add(nombreFichero);
|
|
LogTarisan.logger.log(NivelLog.DEBUG, nombreFichero);
|
|
}
|
|
}
|
|
return resultado;
|
|
}
|
|
|
|
/* Busca si un string está en otro string separado por comas y devuelve un boolean */
|
|
public static boolean buscar_en_properties(String vString, String vContenedor){
|
|
boolean resultado = false;
|
|
|
|
String[] vArray = vContenedor.split(",");
|
|
|
|
for (int i = 0; i < vArray.length; i++) {
|
|
if (vArray[i].compareTo(vString)==0){
|
|
resultado = true;
|
|
}
|
|
}
|
|
|
|
return resultado;
|
|
}
|
|
|
|
/**
|
|
* Valida si es correcta la dirección de correo electrónica dada.
|
|
*@param email
|
|
*@return true si es correcta o false si no lo es.
|
|
*/
|
|
public static boolean validarEmail(String email) {
|
|
boolean valido = false;
|
|
Pattern patronEmail = Pattern.compile("^[A-Za-z0-9._%-]+@[A-Za-z0-9.-]+\\.[a-zA-Z]{2,4}$");
|
|
Matcher mEmail = patronEmail.matcher(email.toLowerCase());
|
|
|
|
if (mEmail.matches()){
|
|
valido = true;
|
|
}
|
|
return valido;
|
|
}
|
|
|
|
}
|
|
|