Validar el ingreso del RUC de Ecuador en Java – Primera parte

febrero 20, 2011 a las 4:58 pm | Publicado en Java, Programacion | 1 comentario
Etiquetas: cedula, java, ruc-ecuador, validar

En este nuevo tutorial les voy a enseñar a validar el RUC ecuatoriano. La validación de la cédula del Ecuador lo pueden encontrar en el siguiente enlace: http://www.coplec.org/?q=2008/07/01/validador-de-c%C3%A9dula-ecuatoriana

Les puse ese enlace porque usaremos ese código para validar uno de los tres tipos de RUC que existen en el Ecuador.

Los tres tipos de RUC son:

RUC de persona jurídica o extranjera.- Es del tipo 1790011674001
RUC de persona pública (entidades estatales).- Es del tipo 1760001550001
RUC de persona natura.- Es del tipo 1701300103001

Se mostrará la validación por partes según cada tipo de RUC.

RUC de personas naturales

La estructura de este tipo de RUC se muestra en la siguiente figura:

Su validación se explica a continuación:

El RUC de una persona natural será 13 dígitos, sin letras, sin caracteres especiales , únicamente números, de los cuales los 10 primeros será la cédula de identidad.
Las 2 primeras posiciones corresponden a la provincia donde fue expedida, por lo cual los dos primeros números no será mayor a 24 ni menor a 1.
El tercer dígito es menor a 6 ( 0,1,2,3,4,5 ).
Del cuarto al noveno dígito es un número consecutivo de 6 dígitos.
El décimo dígito es el dígito verificador.
Del décimo primer dígito al décimo tercer dígito, identifican en forma consecutiva el número de establecimientos. Empieza siempre con el 0001.

El número de RUC es: 1710034065001 independientemente del número de establecimientos que tenga el contribuyente, no existe un número de RUC tal como 1710034065002.

La validación de la cédula de Identidad pasa un algoritmo «Módulo 10». Al número se lo divide en 13 partes, las 9 primeras son el número mismo, la 10 es el dígito autoverificador, y las 3 restantes indican si es principal o establecimiento adicional. Los coeficientes usados para verificar el décimo dígito de la cédula, mediante el algoritmo «Módulo 10» son: 2.1.2.1.2.1.2.1.2

Como se ve en la imagen se usan los 9 primeros dígitos del RUC. Los números de las posiciones impares e multiplican por 2, y los números de las posiciones pares se multiplican por 1. Si el resultado de multiplicar por 2 es mayor a 9, se resta 9. Como en la figura, 12 – 9 = 3.

Luego se suman todos los valores del producto. En este caso la respuesta es 25.

Luego se resta este número de su decena superior. La decena superior a 25 es 30. Por lo tanto queda: 30 – 25 = 5.

Y 5 es el dígito verificador, si este número coincide con el décimo dígito del RUC la cédula es correcta.

Excepción: Si el resultado de la resta es 10, el dígito verificador será 0.

Usando el código de la página que les puse arriba y haciéndole una pequeña modificación, el resultado queda:

public class ValidaCedula {
private static final int num_provincias = 24;

public static Boolean validacionCedula(String cedula){
//verifica que los dos primeros dígitos correspondan a un valor entre 1 y NUMERO_DE_PROVINCIAS
int prov = Integer.parseInt(cedula.substring(0, 2));

if (!((prov > 0) && (prov <= num_provincias))) {
//addError(«La cédula ingresada no es válida»);
System.out.println(«Error: cedula ingresada mal»);
return false;
}

//verifica que el último dígito de la cédula sea válido
int[] d = new int[10];
//Asignamos el string a un array
for (int i = 0; i < d.length; i++) {
d[i] = Integer.parseInt(cedula.charAt(i) + «»);
}

int imp = 0;
int par = 0;

//sumamos los duplos de posición impar
for (int i = 0; i < d.length; i += 2) {
d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);
imp += d[i];
}

//sumamos los digitos de posición par
for (int i = 1; i < (d.length – 1); i += 2) {
par += d[i];
}

//Sumamos los dos resultados
int suma = imp + par;

//Restamos de la decena superior
int d10 = Integer.parseInt(String.valueOf(suma + 10).substring(0, 1) +
«0») – suma;

//Si es diez el décimo dígito es cero
d10 = (d10 == 10) ? 0 : d10;

//si el décimo dígito calculado es igual al digitado la cédula es correcta
if (d10 == d[9]) {
return true;
}else {
//addError(«La cédula ingresada no es válida»);
return false;
}
}

public static void main(String[] args) {
String ruc_dato = «1710034065001»;
if (validacionCedula(ruc_dato.substring(0, 10)))
System.out.println(«El RUC es correcto»);
else
System.out.println(«El RUC es incorrecto»);
}
}

Una explicación del código. Hay una parte donde dice:

d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);

El uso del símbolo de pregunta ? es un equivalente al uso del if. Todo lo que está entre el ? y los dos puntos será lo que suceda en caso de ser verdadero, y lo que está después de los dos puntos sucederá en caso de ser falso.

Validar el ingreso del RUC de Ecuador en Java – Segunda parte

Validar el ingreso del RUC de Ecuador en Java – Tercera parte

Para conocer un poco más sobre la estructura del RUC pueden visitar el siguiente sitio: http://www.campvs.org/legislacion/index.php?option=com_content&task=view&id=18&Itemid=69

Pueden descargarse el código fuente de esta explicación en el siguiente enlace: http://mygnet.net/codigos/java/varios/validar_la_cedula_y_el_ruc_de_ecuador_en_java.3335