validar | Cyberexplorador's Blog

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

febrero 20, 2011 a las 5:26 pm | Publicado en Java, Programacion | 2 comentarios
Etiquetas: java, ruc-ecuador, validar

En la primera parte les mostré cómo validar el RUC de una persona natural. Ahora les mostraré cómo validar el RUC de una persona jurídica o extranjera.

RUC de persona jurídica o extranjera

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

La validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 4, 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
Se suma ese resultado.
Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
Se resta el módulo (en este caso 11) de el residuo de la división anterior.
El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 10 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente: 4 3 2 7 6 5 4 3 2

RUC: 1 7 9 0 0 1 1 6 7 4 0 0 1

Producto: 4 21 18 0 0 5 4 18 14

Sumatoria: 84

Residuo: 84 dividido para 11 da como respuesta 7, y como residuo 7.

Resta: 11 – 7 = 4.

4 Es el dígito verificador.

El código es el siguiente:

public class ValidaRucSociedades {

/**
* @param args
*/
private static final int num_provincias = 24;
//public static String rucPrueba = “1790011674001″;
private static int[] coeficientes = {4,3,2,7,6,5,4,3,2};
private static int constante = 11;

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

if (!((prov > 0) && (prov <= num_provincias))) {
System.out.println(«Error: ruc ingresada mal»);
return false;
}

//verifica que el último dígito de la cédula sea válido
int[] d = new int[10];
int suma = 0;

//Asignamos el string a un array
for (int i = 0; i < d.length; i++) {
d[i] = Integer.parseInt(ruc.charAt(i) + «»);
}

for (int i=0; i< d.length – 1; i++) {
d[i] = d[i] * coeficientes[i];
suma += d[i];
//System.out.println(“Vector d en ” + i + ” es ” + d[i]);
}

System.out.println(«Suma es: » + suma);

int aux, resp;

aux = suma % constante;
resp = constante – aux;

resp = (resp == 10) ? 0 : resp;

System.out.println(«Aux: » + aux);
System.out.println(«Resp » + resp);
System.out.println(«d[9] » + d[9]);

if (resp == d[9]) {
return true;
}
else
return false;
}

public static void main(String[] args) {
String ruc_dato = «1790011674001»;
if (validacionRUC(ruc_dato))
System.out.println(«El RUC es correcto»);
else
System.out.println(«El RUC es incorrecto»);
}
}

En la tercera parte les enseñaré a validar el RUC para empresas públicas.

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

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

Autenticación de usuarios con PHP y MySQL sin programar nada – Manejo de sesiones

septiembre 2, 2009 a las 6:18 pm | Publicado en PHP, Programacion | 77 comentarios
Etiquetas: autenticacion, dreamweaver, manejo, mysql, php, sesiones, usuarios, validar

Pues es verdad, te voy a explicar cómo restringir el acceso a una página web mediante un usuario y contraseña o manejo de sesiones que estén en una base de datos de MySQL sin que programes una sola línea de código. Esto no significa que no necesites saber programación PHP, lo necesitas pero aquí te daré algunos pasos para que hagas todo más rápido y si conoces PHP pues lo mejores a tu gusto.

Las herramientas que vamos a utilizar son:

Wamp Server
Dreamweaver 8.0 o superior
Mozilla Firefox o Internet Explorer o cualquier otro navegador

Una vez que tengamos instalado nuestro servidor web, en este caso Wamp Server vamos a proceder a explicar este tutorial.

Primero crearemos una base de datos, en este caso se llama «manejo_usuarios» ésta contiene una tabla llamada «usuarios» con dos campos: «user» y «password». Podemos agregar dos registros para hacer la prueba. Puedes crear la base usando phpMyAdmin que trae el propio WAMP. Entonces tenemos algo así:

Clic en la imagen para ampliar

Una vez creada la base de datos vamos a crear las páginas web, vamos a necesitar para esta prueba 3 páginas PHP. Recuerda guardarlas en la ruta C:\wamp\www para poder visualizarlas. Bueno de hecho al abrir Dreamweaver (en este caso usaré la versión CS) antes de crear cualquier archivo debemos ir al menú «Sitio» -> «Nuevo sitio». Yo dentro de la ruta C:\wamp\www creé una carpeta llamada «UsuariosenPHP» y dentro una carpeta llamada «images». Respecto a esto último hay que destacar que todas las imágenes que insertes en el sitio desde cualquier ruta se copiará automáticamente a la carpeta «images». Entonces llenamos con los datos necesarios:

Nombre del sitio: Le puedes poner cualquier nombre
Carpeta raíz local: Aquí escogemos la carpeta donde está el sitio, en mi caso C:\wamp\www\UsuariosenPHP
Carpeta predeterminada de imágenes: La ruta de la carpeta que creamos antes C:\wamp\www\UsuariosenPHP\images

Entonces nos queda algo así:

Clic en la imagen para ampliar

Ahora dentro de la misma ventana nos vamos a «Servidor de pruebas», en Modelo de servidor seleccionamos «PHP MySQL» y en Acceso escogemos «Local/Red». En Carpeta de servidor escogemos la ruta del WAMP, en este caso C:\wamp y en prefijo del URL escogemos la ruta con la que cargaremos nuestro sitio web, para este caso sería: http://localhost/UsuariosenPHP/.

Nota: Si usas otro servidor web como XAMPP tienes que cambiar esas rutas.

Entonces nos queda algo así:

Clic en la imagen para ampliar

Damos clic en Aceptar. No olvides realizar este paso o tendrás problemas más adelante.

Ahora crearemos las páginas web. Como mencioné antes serán 3 páginas web sencillas las que necesitamos para esta prueba:

index.php –> Esta página será la principal, tendrá un título y un enlace a la página ingreso.php
ingreso.php –> Tendrá un formulario donde se ingresará el usuario y la contraseña para autenticarse.
entrar.php –> Es la página donde ingresaremos si la autenticación fue exitosa.

Ahora veamos qué tiene cada página:

index.php

Tendrá únicamente un título y un enlace a la página ingreso.php como se muestra en la siguiente figura:

Clic en la imagen para ampliar

ingreso.php

Esta página contendrá un formulario que pida el nombre de usuario y la contraseña. El campo de texto del usuario se llamará «usuario» (sin comillas) y el campo de texto del password se llamará «contrasena» (sin comillas). Entonces tenemos algo así:

Clic en la imagen para ampliar

entrar.php

Esta página tiene un título, tiene una tabla que dirá el nombre del usuario que accedió y tendrá un link que diga Desconectar que permitirá cerrar la sesión (ya explicaré cómo hacer eso):

Clic en la imagen para ampliar

Antes de validar los usuarios (que es lo que nos interesa) debemos hacer algo en esta página entrar.php. Debemos restringir el acceso a ella, pues la idea es que sea visible solo por quien inicia sesión. Bien para ello nos vamos al menú Insertar -> Objetos de aplicación -> Autenticación de usuarios -> Restringir acceso a página:

Clic en la imagen para ampliar

En el cuadro de opciones establecemos los siguientes parámetros:

Clic en la imagen para ampliar

Ahora cada vez que alguien quiera acceder a esa página sin haber iniciado sesión, será redireccionado automáticamente a la página ingreso.php.

Validar usuarios

Bien ahora si vamos a validar el ingreso de los usuarios. En mi base de datos tengo dos usuarios registrados que son:

Usuario #1: usuario = usuario1, contraseña = prueba1
Usuario #2: usuario = usuario2, contraseña = prueba2

La validación lo haremos en la página ingreso.php nos vamos al menú Ventana -> Bases de datos y se nos carga una ventana en el panel derecho, si seguiste los pasos anteriores al crear Nuevo sitio y al configurar el servidor de prueba, entonces no tendrás problemas en este paso.

En la ventana de Bases de datos damos clic en el símbolo + y luego en «Conexión MySQL». Se nos aparece una ventana y llenamos con los siguientes datos:

Nombre de conexión: cualquier nombre, en mi caso se llama conexion_usuarios.
Servidor MySQL: si la base de datos está en la misma máquina escribimos «localhost» (sin comillas).
Nombre de usuario: por lo general el nombre por defecto es «root» (sin comillas).
Contraseña: por lo general se deja el espacio en blanco.
Base de datos: damos clic en «Seleccionar» y escogemos la base de datos que creamos, en mi caso «manejo_usuarios».

Nos quedaría así:

Clic en la imagen para ampliar

Ahora en la ventana «Bases de datos» aparece la base seleccionada con el nombre que le pusimos. Ahora nos vamos al menú Ventana -> Vinculaciones. En la ventana que aparece en el menú lateral damos clic en el signo + y escogemos «Juego de registros (consulta)» y escribimos los siguientes datos:

Nombre: cualquier nombre que queramos darle a la consulta o recordset, en mi caso se llama «consulta_usuarios» (sin comillas).
Conexión: seleccionamos la conexión que creamos anteriormente.
Table: escogemos la tabla que contiene los datos, en mi caso «usuarios».
Columnas: escogemos la opción todo, ya que queremos los datos tanto del usuario como del password.

Nos queda algo así:

Clic en la imagen para ampliar

Si damos clic en Prueba podemos ver todos los registros que tiene esta consulta. Damos clic en aceptar. Automáticamente Dreamweaver crea el código PHP, sin que hayamos programado absolutamente nada. Yo uso la versión CS o versión 8, aquí el código PHP se crea en el mismo archivo, pero en versiones superiores como la CS4 crea el código en un archivo separado.

Bien, una vez hecha la conexión a la base de datos vamos a validar el usuario. Nos vamos al menú Insertar -> Objetos de aplicación -> Autenticación de usuarios -> Conectar usuario. Se nos aparece un cuadro y establecemos los siguientes parámetros:

Obtener entrada de formulario: aquí va el nombre del formulario, por defecto se llama form1, pero si le cambiaron de nombre va el nombre que le pusieron.
Campo nombre de usuario: se escoge el nombre del campo de texto que contiene al usuario, en mi caso se llama «usuario» (sin comillas).

Campo contraseña: se escoge el nombre del campo de texto que contiene la contraseña, en mi caso se llama «contrasena» (sin comillas).
Validar utilizando conexión: escogemos el nombre de la conexión a la base de datos que creamos antes, en mi caso «conexion_usuarios» (sin comillas).
Tabla: escogemos el nombre de la tabla que contiene los usuarios, en mi caso «usuarios» (sin comillas).
Columna nombre de usuario: escogemos la columna que contiene los usuarios, en mi caso «user» (sin comillas).
Columna contraseña: escogemos la columna que contiene las contraseñas, en mi caso «password» (sin comillas).
Si la conexión es correcta, ir a: aquí escogemos la página web a donde se redireccionará al usuario si los datos ingresados son correctos, en este caso entrar.php.
Si falla la conexión, ir a: aquí escogemos la página web a donde se redireccionará al usuario si los datos ingresados son erróneos, en mi caso ingreso.php.

Nos queda así:

Clic en la imagen para ampliar

Listo!!! Ahora para ingresar a la página entrar.php debemos validarnos en la página ingreso.php, no hemos escrito nada de código PHP, todo lo hizo Dreamweaver.

Ahora vamos a terminar el programa dándole los últimos toques a la página entrar.php.

Al crear la conexión a la base de datos se crea automáticamente en todas las páginas del sitio, pero las vinculaciones se deben crear una para cada página según se necesite. Entonces en la página entrar.php agregamos una nueva vinculación con el signo + y escogemos «Juego de registros (consulta)» y lo llenamos con los siguientes datos:

Clic en la imagen para ampliar

Ya sé lo que te estás preguntando ¿qué es eso de Filtro: user = Variable de sesión MM_Username? Bien ¿recuerdas que te dije que no necesitas programar nada, pero que si debes conocer algo de PHP? Bien, si te fijas en el código PHP que Dreamweaver creó en la página ingreso.php te fijarás que existe lo siguiente:

//declare two session variables and assign them
$_SESSION[‘MM_Username’] = $loginUsername;
$_SESSION[‘MM_UserGroup‘] = $loginStrGroup;

Pues ahí tienes la variable MM_Username, ésta variable contiene el nombre de sesión con el que navegarás por la página web, y el nombre de sesión es igual al usuario que tienes en la base de datos. Entonces en esta consulta lo que estamos haciendo es obtener el nombre de usuario donde user (la variable que tenemos en la base de datos) sea igual a la variable MM_Username de inicio de sesión. Pues queremos imprimir ese dato en una parte de la página web, toma en cuenta que por esa razón en Columnas escogí Seleccionado y escogí la columna user únicamente, pues no me interesa imprimir la columna password, sería una gran error.

Bien una vez hecha esta consulta, ponemos el cursor donde queremos imprimir el nombre del usuario y nos vamos al menú Insertar -> Objetos de aplicación -> Datos dinámicos -> Texto dinámico. Nos aparece un cuadro y escogemos la consulta que acabamos de hacer:

Clic en la imagen para ampliar

Te aparecerá un cuadro que contiene la consulta PHP.

Finalmente vamos a crear el enlace para cerrar sesión. Solo ponemos el cursor donde queremos que esté el enlace, y nos vamos al menú Insertar -> Objetos de aplicación -> Autenticación de usuarios -> Desconectar usuario. Nos aparece una ventana y llenamos con los siguientes parámetros:

Clic en la imagen para ampliar

Si en vez de la palabra Desconectar quieres, por ejemplo, las palabras Cerrar sesión, entonces la escribes, la seleccionas y sigues el procedimiento anterior.

Así se ve cuando ingresas al área restringida después de validarte, en este caso como usuario2:

Clic en la imagen para ampliar

Listo!!! Acabas de crear una página web que valida el ingreso de usuarios que están en una base de datos de MySQL sin programar nada.

Trata de probar los demás componentes que trae el menú Insertar -> Objetos de aplicación. Te ahorrarás mucho tiempo haciendo páginas web gracias a Dreamweaver.

Por cierto subí todos los códigos generados a esta página: http://mygnet.net/codigos/php/manejodebasedatos/validar_ingreso_de_usuarios_con_php_y_mysql.3046 ahí los pueden descargar.