[JAVA] Sanitizador de palabras y verificador de RUT (Chile)

[carlitos.dll]

Código (java) [Seleccionar] Expandir



/*-
* Copyright (c) 2008 Carlos
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of copyright holders nor the names of its
*    contributors may be used to endorse or promote products derived
*    from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL COPYRIGHT HOLDERS OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

import java.util.*;

/**
* ReglasDeNegocio.java
*
* Esta clase implementa una serie de métodos estáticos,
* para implementar reglas de negocio
* tales como sanitizar palabras, validar rut.
*
* @author Carlos
* @version 14-9-2008
*/
final class ReglasDeNegocio
{
  /**
   * Método sanitizador de Strings.
   * @param Recibe:
   * Un String con el String a sanitizar
   * Un int con el tipo de sanitización
   * Un String con el nombreDelAtributo que llama al método, en caso de que se lanzen excepciones
   * 1 corresponde a limpieza para Strings de nombres.
   * 2 corresponde a limpieza para Strings de direcciones.
   * Ejemplo: si tengo una variable String nombre:
   * Ejemplo: nombre = ReglasDeNegocio.filtro("Juan123456 Pérez###", 1, "nombre"),
   * nombre tendrá el contenido: "Juan Pérez",
   * si nombre es nulo se lanza una excepción diciendo: "nombre no puede ser nulo", nombre es el identificador de la variable.
   * Ejemplo: filtro("Santa Rosa%%%%%////123", 2, "direccion") devuelve "Santa Rosa 123"
   * autor: Carlos
   */
  public static String filtro(
                               String argumento,
                               int opcion,
                               String nombreVariable) throws Exception
  {
      try
      {
          nombreVariable = nombreVariable.trim();
          if (nombreVariable.length() < 1)
          {
              throw new Exception(
              "el nombreVariable debe contener el nombre de la variable.");
          }
      }
      catch (NullPointerException npe)
      {
          throw new Exception("Error en los parámetros.");
      }

      String patron;
      switch (opcion)
      {
          case 1 : {
                       patron = new String("[^A-Za-záéíóúñÁÉÍÓÚÑüÜ -]");
                       break;
                   }
          case 2 : {
                       patron = new String("[^0-9A-Za-záéíóúñÁÉÍÓÚÑüÜ#° -]");
                       break;
                   }
          default: {
                       throw new Exception(String.valueOf(opcion));
                   }
      }
      try
      {
          argumento = argumento.trim();
          if (argumento.length() < 1)
          {
              throw new Exception(nombreVariable + " está vacío.");
          }
      }
      catch (NullPointerException npe)
      {
          throw new Exception(nombreVariable + " no puede ser nulo");
      }

      Scanner palabra = new Scanner(argumento).useDelimiter(patron);
      String reconstruccion = new String();
      while(palabra.hasNext())
      {
          reconstruccion = reconstruccion + palabra.next();
      }
      palabra.close();

      argumento = new String();
      StringTokenizer tokens = new StringTokenizer(reconstruccion);
      while(tokens.hasMoreTokens())
      {
          argumento = argumento + " " + tokens.nextToken();
      }
      argumento = argumento.trim();
      return argumento;
  }

  /**
   * Método sanitizador y validador de rut.
   * @param Recibe una cadena correspondiente al rut.
   * @return Devuelve un rut sanitizado,
   * en caso de que el digito verificador sea correcto, sino lanza una excepción.
   * Ejemplo "123456789-2" lo devuelve correcto.
   * "123456789-26999" lo devuelve como "123456789-2".
   * "123456789-3" lanza excepción pues el digito verificador es 2.
   * "00000123456789-2" lo devuelve como "123456789-2".
   * autor: Carlos
   * version: 1.1
   */
   public static String validadorRut(String rut) throws Exception
   {
      if (rut == null)
      {
          throw new Exception("rut no puede ser nulo");
      }
     
      rut = rut.replace('—','-').replace('–','-');

      String datosRut = new String();
      Scanner token = new Scanner(rut).useDelimiter("[[\\D]&&[^Kk-]]");
      while (token.hasNext())
      {
          datosRut = datosRut + token.next();
      }
      StringTokenizer tokens = new StringTokenizer(datosRut, "-");
      if (tokens.countTokens() != 2)
      {
          throw new Exception("error de formato en el rut");
      }
     
      String datos = tokens.nextToken();
     
      boolean comienzaConCero = datos.startsWith("0");
      if (comienzaConCero)
      {
          int indice;  
          for (indice = 0; indice < datos.length() && comienzaConCero; indice++)
          {
              comienzaConCero = datos.substring(indice, indice + 1).equals("0");
          }
          datos = datos.substring(indice - 1);
      }
     
      String digitoVerificador = new String();
      try
      {
          int formato = Integer.parseInt(datos);
          int contador = 2;
          int calculo = 0;
          for (int i = datos.length() - 1; i >= 0; i--)
          {
              contador = contador > 7 ? 2 : contador;
              calculo += Integer.parseInt(datos.substring(i, i + 1)) * contador++;
          }
          calculo = 11 - (calculo % 11);
          String digito = new String(calculo == 10 ? "K" : calculo == 11 ? "0" : String.valueOf(calculo));
          String digitoRecibido = tokens.nextToken().substring(0, 1);
          if (digito.equalsIgnoreCase(digitoRecibido))
          {
              return rut = datos + "-" + digito;
          }
          else
          {
              throw new Exception("El digito verificador del rut no es correcto.");
          }
      }
      catch (NumberFormatException nfe)
      {
          throw new Exception("Error de formato en el rut.");
      }
   }

}



[juancho77]

Y que se supone que hace? 

[Pablo Videla]

Gracias! yo tenia esa duda , el programa calcula el digito verificador del rut chileno , yo soy chileno xD

[Pablo Videla]

 

Código (java) [Seleccionar] Expandir

public static void main(String args[])throws Exception
{
ReglasDeNegocio persona;

persona = new ReglasDeNegocio();
persona.validadorRut("mirut");
}

[/code=java]
al agregar mi verdadero rut me lanza la excepcion
--------------------Configuration: <Default>--------------------
Exception in thread "main" java.lang.Exception: error de formato en el rut
    at ReglasDeNegocio.validadorRut(ReglasDeNegocio.java:163)
    at ReglasDeNegocio.main(ReglasDeNegocio.java:212)

Process completed.

y coloco mi rut real, claro que sin el digito verificador ni los puntos , por que se supone que me debe calcular el digito verificador , cual es el problema ..?

(no coloco nica me verdarero rut aca)

pense que calculaba el digito verificador , pero solo comprueba si es el verdadero o no xD