//package com.ejie.m62fb.util;
//
//import java.text.NumberFormat;
//import java.util.ArrayList;
//
//import com.ejie.m62fb.model.tipos.TipoClave;
//
//public class UtilidadesTexto {
//	public static final String SEQUENCE_NAME = "";
//	
//	public static String getTipoNIF(String nif){
//		/**
//		 * Para saber qué tipo de documento es el que se ha introducido, para poder
//		 * validar su formato se sigue en siguiente criterio:
//			- Si al valor introducido le quitamos el último carácter, y es un valor numérico, 
//			el tipo de documento es un DNI.
//			-Si no, si comienza por X. U o Z es una tarjeta de residencia, y si no es un CIF
//		 */
//		String nifAux = left(nif,nif.length()-1);
//		if (isNumeric(nifAux)){
//			return TipoClave.DNI;
//		}else if(left(nifAux,1).equalsIgnoreCase("x") 
//					|| left(nifAux,1).equalsIgnoreCase("u")
//					|| left(nifAux,1).equalsIgnoreCase("z")){
//			return TipoClave.NIE;	
//		}else{
//			return TipoClave.CIF;
//		}
//	}
//	/**
//	 * Returns the string s left aligned, len characters length and padded with
//	 * <code>pad</code>.
//	 * <p>
//	 * Here are some examples:
//	 * <p>
//	 * <code>
//	 * left("1234", 2)       - "12"
//	 * left("1234", 6)       - "1234  "
//	 * left("1234", 6, '+')  - "1234++"
//	 * </code> Creation date: (18/8/99 10:19:58)
//	 * 
//	 * @return java.lang.String
//	 * @param s
//	 *            java.lang.String
//	 * @param len
//	 *            int
//	 * @param pad
//	 *            char
//	 */
//	public static String left(String s, int len, char pad) {
//		if (len == 0) {
//			return s;
//		}
//		if (s == null) {
//			return s;
//		}
//		if (s.length() == 0) {
//			return s;
//		}
//		int sLen = s.length();
//		if (len < sLen) {
//			return s.substring(0, len);
//		} else {
//			StringBuffer sb = new StringBuffer(s);
//			for (int i = 0; i < len - sLen; i++) {
//				sb.append(pad);
//			} // for i
//			return sb.toString();
//		}
//	}
//
//	public static String left(String s, int len) {
//		if (len == 0) {
//			return s;
//		}
//		if (s == null) {
//			return s;
//		}
//		if (s.length() == 0) {
//			return s;
//		}
//		int sLen = s.length();
//		if (len < sLen) {
//			return s.substring(0, len);
//		}
//		return s;
//	}
//
//	/**
//	 * Returns a string of length len containing the rightmost len characters of
//	 * string. The string returned is padded with pad characters (or truncated)
//	 * on the left as needed. The default pad character is a blank. The len must
//	 * be a positive whole number or zero.
//	 * <p>
//	 * Here are some examples:
//	 * <p>
//	 * <code>
//	 * right("abc  d",8)     // '  abc  d'
//	 * right("abc def",5)    // 'c def'
//	 * right("12",5,'0')     // '00012'
//	 * </code>
//	 * <p>
//	 * Creation date: (18/8/99 10:26:21)
//	 * <p>
//	 * Modified: (11/6/99 08:56:43): Added
//	 * <code>if (len = s.length()) return s</code>.
//	 * 
//	 * @return java.lang.String
//	 * @param s
//	 *            java.lang.String
//	 * @param len
//	 *            int
//	 * @param pad
//	 *            char
//	 */
//	public static String right(String s, int len, char pad) {
//		if (len < 0)
//			throw new IllegalArgumentException(
//					"len must be a positive whole number");
//		if (len == 0)
//			return s;
//		if (s == null)
//			return s;
//		if (s.length() == 0)
//			return s;
//		int sLen = s.length();
//		if (len == s.length())
//			return s;
//		if (len < sLen)
//			return s.substring(sLen - len);
//		else {
//			String sl = copies(pad, len - sLen);
//			return sl + s;
//		}
//	}
//
//	public static String right(String s, int len) {
//		if (len < 0)
//			throw new IllegalArgumentException(
//					"len must be a positive whole number");
//		if (len == 0)
//			return s;
//		if (s == null)
//			return s;
//		if (s.length() == 0)
//			return s;
//		int sLen = s.length();
//		if (len == s.length())
//			return s;
//		if (len < sLen) {
//			return s.substring(sLen - len);
//		}
//		return s;
//	}
//
//	/**
//	 * Returns <code>times</code> concatenated copies of <code>c</code>.<br>
//	 * The n must be a positive whole number or zero.
//	 * <p>
//	 * Here are some examples:
//	 * <p>
//	 * <code>
//	 * copies('a',3)    -   "aaa"
//	 * copies('a',0)    -   ""
//	 * </code> Creation date: (18/8/99 10:28:56)
//	 * <p>
//	 * Modified: (11/6/99 09:01:23): <code>if (times == 0) return null</code>
//	 * becomes <code>[...] return ""</code> like in Rexx.
//	 * 
//	 * @return java.lang.String
//	 * @param c
//	 *            char
//	 * @param times
//	 *            int
//	 */
//	public static String copies(char c, int times) {
//		if (times == 0)
//			return "";
//		StringBuffer sb = new StringBuffer();
//		for (int i = 1; i <= times; i++)
//			sb.append(c);
//		return sb.toString();
//	}
//
//	/**
//	 * Returns <code>times</code> concatenated copies of <code>c</code>.<br>
//	 * The n must be a positive whole number or zero.
//	 * <p>
//	 * Here are some examples:
//	 * <p>
//	 * <code>
//	 * copies("123",3)    -   "123123123"
//	 * copies("123",0)    -   ""
//	 * </code> Creation date: (18/8/99 10:30:40)
//	 * <p>
//	 * Modified: (11/6/99 09:02:15): Added
//	 * <code>if (times == 0) return ""</code> to do the same as in
//	 * <code>copies(char, int)</code>.
//	 * 
//	 * @return java.lang.String
//	 * @param s
//	 *            java.lang.String
//	 * @param times
//	 *            int
//	 */
//	public static String copies(String s, int times) {
//		if (times == 0)
//			return "";
//		StringBuffer sb = new StringBuffer();
//		for (int i = 1; i <= times; i++)
//			sb.append(s);
//		return sb.toString();
//	}
//
//	public static final String NIF_STRING_ASOCIATION = "TRWAGMYFPDXBNJZSQVHLCKE";
//
//	/**
//	 * Devuelve un NIF sin el caracter '-'
//	 */
//	public static String quitarCaracterEnTxt(String texto, char caracterEliminar) {
//
//		StringBuffer r = new StringBuffer(texto.length());
//		// calcular el tamaño final del texto
//		int index;
//		int fromIndex = 0;
//		int count = 0;
//		while ((index = texto.indexOf(caracterEliminar, fromIndex)) > -1) {
//			count++;
//			fromIndex = index + 1;
//		}
//		r.setLength(texto.length() - count);
//		int current = 0;
//		for (int i = 0; i < texto.length(); i++) {
//			char cur = texto.charAt(i);
//			if (cur != caracterEliminar)
//				r.setCharAt(current++, cur);
//		}
//		return r.toString();
//	}
//
//	public static String formatIdentificador(String identif) {
//		String charAux = identif.substring(0, 1);
//		String identifAux = "";
//		if (("X").equals(charAux) || ("Y").equals(charAux)
//				|| ("Z").equals(charAux)) {
//			identifAux = charAux
//					+ formatNIE(identif.substring(1, identif.length()));
//
//		} else {
//			identifAux = formatDni(identif);
//		}
//
//		return identifAux;
//	}
//
//	/**
//	 * Devuelve un dni y formateado con sus nueve posiciones númericas 111-L -->
//	 * 00000111L
//	 */
//	public static String formatDni(String dni) {
//		// dni = quitarCaracterEnTxt(dni, '-');
//		dni = right(dni, 9, '0');
//		return dni;
//	}
//
//	/**
//	 * Devuelve un nie formateado con sus nueve posiciones númericas X10X -->
//	 * X0000010X
//	 */
//	public static String formatNIE(String nie) {
//
//		return right(nie, 8, '0');
//
//	}
//
//	/**
//	 * Devuelve un NIF completo a partir de un DNI. Es decir, añade la letra del
//	 * NIF
//	 * 
//	 * @param dni
//	 *            dni al que se quiere añadir la letra del NIF
//	 * @return NIF completo.
//	 */
//	public static String nifFromDni(String dni) {
//		dni = right(dni, 8, '0');
//		return String.valueOf(dni)
//				+ NIF_STRING_ASOCIATION
//						.charAt(new Integer(dni).intValue() % 23);
//	}
//
//	/**
//	 * Devuelve un NIF completo a partir de un NIE. Es decir, añade la letra del
//	 * NIF
//	 * 
//	 * @param nie
//	 *            nie al que se quiere añadir la letra del NIF
//	 * @return NIF completo.
//	 */
//	public static String nifFromNie(String nie) {
//		switch (nie.toUpperCase().charAt(0)) {
//		case 'X':
//			nie = nie.replace('X', '0');
//			break;
//		case 'Y':
//			nie = nie.replace('Y', '1');
//			break;
//		case 'Z':
//			nie = nie.replace('Z', '2');
//			break;
//		}
//		if (nie.length() == 8) {
//			nie = nifFromDni(nie);
//		}
//		return nie;
//	}
//
//	/**
//	 * Valida si el NIF O NIE es correcto
//	 */
//	/*
//	 * public static boolean validarIdentif(String identif) {
//	 * 
//	 * String identificador = identif;
//	 * 
//	 * String numeroIdentif = null;
//	 * 
//	 * // Validamos si es una tardjeta de residente o un DNI. switch
//	 * (identificador.toUpperCase().charAt(0)) { case 'X': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '0' +
//	 * identificador; break; } case 'Y': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '1' +
//	 * identificador; break; } case 'Z': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '2' +
//	 * identificador; break; } }
//	 * 
//	 * int longitud = identificador.length();
//	 * 
//	 * // Se valida que el formato del identificador sea de 9 posiciones if
//	 * (longitud < 9) { identificador = right(identificador, 9, '0'); }
//	 * 
//	 * // Cogemos las 8 posiciones de la izquierda. numeroIdentif =
//	 * identificador.substring(0, identificador.length() - 1); int contador = 0;
//	 * 
//	 * while (contador < numeroIdentif.length()) {
//	 * 
//	 * String caracter = numeroIdentif.substring(contador, contador + 1);
//	 * 
//	 * if (!isNumeric(caracter)) { return false; }
//	 * 
//	 * contador = contador + 1; }
//	 * 
//	 * // Obtenemos la letra del DNI String ultimoCaracter =
//	 * identificador.substring( identificador.length() - 1,
//	 * identificador.length()) .toUpperCase();
//	 * 
//	 * // Se valida que la letra introducida no sea un número. if
//	 * (isNumeric(ultimoCaracter)) { return false; }
//	 * 
//	 * // Calculamos la ultima letra del DNI String letraDni =
//	 * calcularLetraDni(numeroIdentif);
//	 * 
//	 * // Si la letra calculada no coincide con la que hemos introducido //
//	 * devolvemos false. if (!letraDni.equals(ultimoCaracter)) { return false; }
//	 * 
//	 * return true; }
//	 */
//
//	public static boolean isNumeric(String cadena) {
//		try {
//			Integer.parseInt(cadena);
//			return true;
//		} catch (NumberFormatException nfe) {
//			return false;
//		}
//	}
//
//	public static String calcularLetraDni(String identificador) {
//
//		int numero = 0;
//		numero = (Integer.parseInt(identificador) % 23);
//
//		String cadena = "TRWAGMYFPDXBNJZSQVHLCKE";
//		String letraCalculada = cadena.substring(numero, numero + 1);
//
//		return letraCalculada;
//	}
//
//	public static boolean validarCuentaBancaria(String cuenta) {
//		String banco = cuenta.substring(0, 4);
//		String sucursal = cuenta.substring(4, 8);
//		String dC = cuenta.substring(8, 10);
//		String CCC = cuenta.substring(10, 20);
//		if (!(obtenerDigito("00" + banco + sucursal) == Integer.parseInt(String
//				.valueOf(dC.charAt(0))))
//				|| !(obtenerDigito(CCC) == Integer.parseInt(String.valueOf(dC
//						.charAt(1))))) {
//			return false;
//		} else {
//			return true;
//		}
//	}
//
//	public static int obtenerDigito(String valor) {
//		int valores[] = { 1, 2, 4, 8, 5, 10, 9, 7, 3, 6 };
//
//		int control = 0;
//		for (int i = 0; i <= 9; i++) {
//			control += Integer.parseInt(String.valueOf(valor.charAt(i)))
//					* valores[i];
//		}
//		control = 11 - (control % 11);
//		if (control == 11) {
//			control = 0;
//		} else {
//			if (control == 10) {
//				control = 1;
//			}
//		}
//
//		return control;
//	}
//
//	/*
//	 * public static boolean validarTarjeta(String identif) {
//	 * 
//	 * String identificador = identif;
//	 * 
//	 * String numeroIdentif = null;
//	 * 
//	 * // Validamos si es una tarjeta de residente o un DNI. switch
//	 * (identificador.toUpperCase().charAt(0)) { case 'X': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '0' +
//	 * identificador; break; } case 'Y': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '1' +
//	 * identificador; break; } case 'Z': { identificador =
//	 * identificador.substring(1, identificador.length()); identificador = '2' +
//	 * identificador; break; } default: return false; }
//	 * 
//	 * int longitud = identificador.length();
//	 * 
//	 * // Se valida que el formato del identificador sea de 9 posiciones if
//	 * (longitud != 9) { return false; }
//	 * 
//	 * // Cogemos las 8 posiciones de la izquierda. numeroIdentif =
//	 * identificador.substring(0, identificador.length() - 1); int contador = 0;
//	 * 
//	 * while (contador < numeroIdentif.length()) {
//	 * 
//	 * String caracter = numeroIdentif.substring(contador, contador + 1);
//	 * 
//	 * if (!isNumeric(caracter)) { return false; }
//	 * 
//	 * contador = contador + 1; }
//	 * 
//	 * // Obtenemos la letra del DNI String ultimoCaracter =
//	 * identificador.substring( identificador.length() - 1,
//	 * identificador.length()) .toUpperCase();
//	 * 
//	 * // Se valida que la letra introducida no sea un número. if
//	 * (isNumeric(ultimoCaracter)) { return false; }
//	 * 
//	 * // Calculamos la ultima letra del DNI String letraDni =
//	 * calcularLetraDni(numeroIdentif);
//	 * 
//	 * // Si la letra calculada no coincide con la que hemos introducido //
//	 * devolvemos false. if (!letraDni.equals(ultimoCaracter)) { return false; }
//	 * 
//	 * return true; }
//	 */
//
//	public static String formatearNumero(Float valor, int minDec, int maxDec) {
//		String numeroFormateado = null;
//		NumberFormat nf = NumberFormat.getInstance();
//		nf.setMaximumFractionDigits(minDec);
//		nf.setMinimumFractionDigits(maxDec);
//		try {
//			numeroFormateado = nf.format(valor);
//		} catch (NumberFormatException nfe) {
//			numeroFormateado = "";
//		}
//
//		return numeroFormateado;
//	}
//
//	public static String formatearNumero(Double valor, int minDec, int maxDec) {
//		String numeroFormateado = null;
//		NumberFormat nf = NumberFormat.getInstance();
//		nf.setMaximumFractionDigits(minDec);
//		nf.setMinimumFractionDigits(maxDec);
//		try {
//			numeroFormateado = nf.format(valor);
//		} catch (NumberFormatException nfe) {
//			numeroFormateado = "";
//		}
//
//		return numeroFormateado;
//	}
//
//	public static boolean isNullOrBlank(String s) {
//		return (s == null || s.trim().equals(""));
//	}
//
//	public static String replaceTxt(final String aTexto,
//			final String aTextoViejo, final String aTextoNuevo) {
//		if (aTextoViejo.equals("")) {
//			throw new IllegalArgumentException(
//					"El texto a reemplazar no puede estar vacio.");
//		}
//
//		final StringBuffer result = new StringBuffer();
//		// startIdx and idxOld delimit various chunks of aInput; these
//		// chunks always end where aOldPattern begins
//		int startIdx = 0;
//		int idxOld = 0;
//		while ((idxOld = aTexto.indexOf(aTextoViejo, startIdx)) >= 0) {
//			// grab a part of aInput which does not include aOldPattern
//			result.append(aTexto.substring(startIdx, idxOld));
//			// add aNewPattern to take place of aOldPattern
//			result.append(aTextoNuevo);
//
//			// reset the startIdx to just after the current match, to see
//			// if there are any further matches
//			startIdx = idxOld + aTextoViejo.length();
//		}
//		// the final chunk will go to the end of aInput
//		result.append(aTexto.substring(startIdx));
//		return result.toString();
//	}
//
//	/**
//	 * getStrTokenizer
//	 * 
//	 * @param separador
//	 * @param listaValores
//	 * @return la lista de valores @@1@@2@@3@@.....
//	 */
//	public static String getStrTokenizer(String separador,
//			ArrayList listaValores) {
//
//		StringBuffer strDevuelto = new StringBuffer();
//
//		strDevuelto.append(separador);
//		for (int i = 0; i < listaValores.size(); i++) {
//			strDevuelto.append(listaValores.get(i).toString());
//			strDevuelto.append(separador);
//		}
//		if (!strDevuelto.toString().endsWith(separador)) {
//			strDevuelto.append(separador);
//		}
//		return strDevuelto.toString();
//	}
//}
