Validación del módulo 11 (RUT y Patente en Chile)

Hace bastante tiempo que no escribo una entrada en el blog, llegó la hora de revivirlo 🙂

El módulo 11 es un código de control usado para la validación de un dato al añadir un dígito verificador, en chile es usado para validar el RUN (Rol Único Nacional), RUT (Rol Único  Tributario) y la Patente de los vehículos (no sé si se utilizará para otras cosas).

Esta entrada está enfocada en la validación del módulo 11 y la aplicación en C# para validar un RUN/RUT y una Patente chilena.

El módulo 11: El método denominado módulo 11 detecta errores en un solo dígito e intercambios simples o dobles. Se basa en aplicar un factor de chequeo ponderado a cada dígito del número original.

El Registro Civil (chile) ofrece manuales para validar correctamente el RUT/RUN y la patente.

Para validar el módulo 11 tenemos el siguiente código (gentileza de Germán Aroca):

public class Mod11Validator
{
    public int Numero { get; set; }
    public string DigitoVerificador { get; set; }

    public Mod11Validator(int numero, string digitoVerificador)
    {
        this.Numero = numero;
        this.DigitoVerificador = digitoVerificador.ToUpper();
    }

    public bool ObtenerValidezMod11()
    {
        return this.DigitoVerificador == CalcularDigitoVerificador(this.Numero);
    }

    private string CalcularDigitoVerificador(int numero)
    {
        string cadenaNumero = numero.ToString();
        int calculador = 0;

        int[] factores = {3, 2, 7, 6, 5, 4, 3, 2};
        int indiceFactor = factores.Length - 1;

        for (int i = cadenaNumero.Length - 1; i >= 0; i--)
        {
            calculador = calculador + (factores[indiceFactor]*int.Parse(cadenaNumero.Substring(i, 1)));
            indiceFactor--;
        }

        string digitoVerificador;
        int resultado = 11 - (calculador%11);

        if (resultado == 11)
        {
            digitoVerificador = "0";
        }
        else if (resultado == 10)
        {
            digitoVerificador = "K";
        }
        else
        {
            digitoVerificador = resultado.ToString();
        }

        return digitoVerificador;
    }
}

Para validar el RUT/RUN por lo tanto solo debemos llamar a este método de la siguiente forma

Mod11Validator mod11 = new Mod11Validator(numero, dv);
bool esValido = mod11.ObtenerValidezMod11();

Para la validación de patente es un tema distinto, dado que la validación de la patente lleva letras, estas deben ser convertidas en dígitos de acuerdo al manual del registro civil. Entiendo que traspasar todas estas letras a dígitos es realmente aburrido y tedioso, les dejo adjunto 2 archivos CSV con las conversiones de patentes nuevas y antiguas Cortesía de Carlos Muñoz.

• Patentes Antiguas: Descargar CSV
• Patentes Nuevas: Descargar CSV

Para utilizar estos archivos correctamente con la clase que embedo a continuación, solo deben añadir los archivos a un archivo de recursos y luego mapearlos (ver líneas destacadas en el código). Por cierto, para leer los archivos utilizo el siguiente código:  Leer CSV (archivo separado por coma)

public class PatenteValidator
{
    public class PatenteAntigua
    {
        public static Dictionary<string, string> ValorLetras
        {
            get
            {
                DataTable dt =
                    Utils.Common.Files.FileTools.ByteBufferToTable(ValidatorResources.Resources.DiccionarioPatentesAntiguas, true);
                Dictionary<string, string> d = new Dictionary<string, string>();
                foreach (DataRow dr in dt.Rows)
                    d[dr[0].ToString()] = dr[1].ToString();

                return d;
            }
        }
    }

    public class PatenteNueva
    {
        public static Dictionary<string, string> ValorLetras
        {
            get
            {
                DataTable dt =
                    Utils.Common.Files.FileTools.ByteBufferToTable(ValidatorResources.Resources.DiccionarioPatentesNuevas, true);
                Dictionary<string, string> d = new Dictionary<string, string>();
                foreach (DataRow dr in dt.Rows)
                    d[dr[0].ToString()] = dr[1].ToString();

                return d;
            }
        }
    }

    public static bool ValidarPatente(string patente)
    {
        if (patente.Trim().Length != 8)
            return false;
        if (!patente.Trim().Contains("-"))
            return false;

        int aux;
        bool esPatenteAntigua = int.TryParse(patente.Substring(2,2), out aux);
        int numero;
        string dv;
        if(esPatenteAntigua)
        {
            Dictionary<string, string> valorLetras = PatenteAntigua.ValorLetras;
            string letras = patente.Substring(0, 2);
            if (!valorLetras.ContainsKey(letras.ToUpper()))
                return false;
            string valor = valorLetras[letras.ToUpper()];
            valor += patente.Substring(2, 4);
            dv = patente.Substring(7, 1);
            numero = int.Parse(valor);
        }
        else
        {
            Dictionary<string, string> valorLetras = PatenteNueva.ValorLetras;
            char[] letras = patente.Substring(0, 4).ToCharArray();
            string valor = string.Empty;

            foreach (char c in letras)
            {
                if (!valorLetras.ContainsKey(c.ToString().ToUpper()))
                    return false;
                valor += valorLetras[c.ToString().ToUpper()];
            }

            valor += patente.Substring(4, 2);
            dv = patente.Substring(7, 1);
            numero = int.Parse(valor);
        }

        Mod11Validator mod11Validator = new Mod11Validator(numero, dv);
        return mod11Validator.ObtenerValidezMod11();
    }
}