Cálculo / Validación del IBAN

[Angel.Matilla]

Dado que a partir del 1 de febrero de 2014 se cambia el formato para efectuar pagos por vía telemática y hay que aplicar la normativa SEPA; la AEB ha publicado la nueva normativa para dichos soportes informáticos y se puede consultar el formato de los nuevos CSB19 (CSB 19.14) en Adeudos Directos SEPA en fichero electrónico – Esquema Básico (http://www.aeb60.com/Cuadernos/Cuaderno%2019.14%20Adeudos%20Directos%20SEPA%20en%20fichero%20electr%C3%B3nico%20%E2%80%93%20Esquema %20B%C3%A1sico.pdf).

El protocolo de validación lo encontré en Código Internacional de Cuenta Bancaria (IBAN) (http://www.finanzasybanca.com/iberfinanzas/index.php/C/Codigo-Internacional-de-Cuenta-Bancaria-IBAN.html) y me he hecho la rutina. Este es el código:
AnsiString CalIban(AnsiString Cuenta)
{
AnsiString cAux;

Cuenta = Cuenta + "142800";
cAux = FormatFloat("0", StrToInt(Cuenta.SubString(1, 9)) % 97);
Cuenta = Cuenta.SubString(10, Cuenta.Length());
while (!Cuenta.IsEmpty())
{
if (StrToInt(cAux) < 10)
{
cAux = cAux + Cuenta.SubString(1, 8);
Cuenta = Cuenta.SubString(9, Cuenta.Length());
}
else
{
cAux = cAux + Cuenta.SubString(1, 7);
Cuenta = Cuenta.SubString(8, Cuenta.Length());
}
cAux = FormatFloat("0", StrToInt(cAux) % 97);
}
return "ES" + FormatFloat("00", 98 - StrToInt(cAux));
}
//---------------------------------------------------------------------------El 142800 que aparece en las primeras líneas es el resultado de aplicar la tabla de conversión a las letras ES y añadir un 00 necesario para que tenga la longitud adecuada, de acuerdo con la norma.

Devuelve las cuatro primeras posiciones del IBAN, que en el caso de España son ESxx siendo xx un número entre 1 y 98. El IBAN completo en el caso de España tiene 24 posiciones: las calculadas con esta rutina (ESxx) más las 20 del CCC, que mantiene su fórmula de cálculo (Letra DNI,Nº AÑOS, DIGITO CONTROL CUENTA , D.CONTROL EAN 13 (http://foros.ryanstudios.com/viewtopic.php?t=6886))

Si hubiera que calcular el IBAN para otros paises hay que tener en cuenta:
1. El código nacional según la norma ISO 3166-1 que podemos encontrar en ISO 3166-1 decoding table (http://www.iso.org/iso/home/standards/country_codes/iso-3166-1_decoding_table.htm).
2. Dado que hay paises que en las cuentas bancarias admiten letras (caso de Francia) hay que usar la tabla de conversión que aparece en Código Internacional de Cuenta Bancaria (IBAN) (http://www.finanzasybanca.com/iberfinanzas/index.php/C/Codigo-Internacional-de-Cuenta-Bancaria-IBAN.html)

[ecfisa]

Hola Angel.

Gracias por el aporte ^\||/.

Saludos :)

[pacopenin]

Gracias por el aporte y la documentación.

[Angel.Matilla]

Ampliando el código anterior que puse, para validar cualquier IBAN que se introduzca o calcular el correspondiente a un número de cuenta. Este es el código:
AnsiString CalIban(AnsiString Cuenta, AnsiString Pais)
{
AnsiString cAux;

if (Cuenta.Trim().IsEmpty() || Cuenta.Length() > 34)
return "";

Cuenta = UpperCase(Cuenta);
cAux = "";
for (int nPos = 0; nPos < Cuenta.Length(); nPos ++)
if (isalpha(Cuenta.c_str()[nPos]) || isdigit(Cuenta.c_str()[nPos]))
cAux = cAux + AnsiString(Cuenta.c_str()[nPos]);

Cuenta = cAux;
if (isalpha(Cuenta.c_str()[0]) && isalpha(Cuenta.c_str()[1])) // Es IBAN
{
if (isalpha(Cuenta.c_str()[2]) || isalpha(Cuenta.c_str()[3]))
return "";

Cuenta = Cuenta.SubString(5, Cuenta.Length()) + Cuenta.SubString(1, 2) + "00";
Pais = Cuenta.SubString(1, 2);
}
else
{
if (Pais.IsEmpty())
Pais = "ES";

Cuenta = Cuenta + Pais + "00";
}

cAux = "";
for (int nPos = 1; nPos <= Cuenta.Length(); nPos ++)
{
if (isalpha(Cuenta.c_str()[nPos - 1]))
cAux = cAux + FormatFloat("00", Cuenta.c_str()[nPos - 1] - 55);
else
cAux = cAux + Cuenta.SubString(nPos, 1);
}
Cuenta = cAux;

cAux = FormatFloat("0", StrToInt(Cuenta.SubString(1, 9)) % 97);
Cuenta = Cuenta.SubString(10, Cuenta.Length());
while (!Cuenta.IsEmpty())
{
if (StrToInt(cAux) < 10)
{
cAux = cAux + Cuenta.SubString(1, 8);
Cuenta = Cuenta.SubString(9, Cuenta.Length());
}
else
{
cAux = cAux + Cuenta.SubString(1, 7);
Cuenta = Cuenta.SubString(8, Cuenta.Length());
}
cAux = FormatFloat("0", StrToInt(cAux) % 97);
}
return Pais + FormatFloat("00", 98 - StrToInt(cAux));
}
Explico lo que hago.

A la función se le pasan dos parámetros: el número de cuenta y el país; este último puede estar vacío, en cuyo caso se toma por defecto España (ES), o contener el código internacional de país según la norma ISO 3166-1.
Se convierte la cadena a mayúsculas y se desprecia todo lo que no sean letras o dígitos.
Si la información que viene es ya un IBAN (para España sería ESXXEEEEOOOODDNNNNNNNNNN) se extrae el código de país y se monta la cadena para calcular los dígitos de control.
Si no es un IBAN (las 20 posiciones de un CCC español o, por ejemplo, las 21 de Francia) se prepara la cadena con el código de país.
Se convierten todas las letras a su equivalente numérico, según la tabla que podemos ver en Código Internacional de Cuenta Bancaria (IBAN) (http://www.finanzasybanca.com/iberfinanzas/index.php/C/Codigo-Internacional-de-Cuenta-Bancaria-IBAN.html): A = 10, B = 11, etc.
Calculamos los dígitos de control de acuerdo con el módulo 97.
Devolvemos la secuencia País + Dígitos.Todo esto no impide que en el caso de cuentas españolas haya que validar los dígitos de control de los CCC. Espero que sea de utilidad.

[defcon1_es]

Muchas gracias por el aporte.

Para los que usamos Delphi en vez de C++ Builder, les dejo la "traducción" de la función a Pascal.

function TForm1.Generar_IBAN(Pais, Cuenta: string): string;

function EsAlfanumerico(Caracter: Char): boolean;
begin
Result := (AnsiChar(Caracter) in ['A'..'Z', 'a'..'z']);
end;

function EsNumerico(Caracter: Char): boolean;
begin
Result := (AnsiChar(Caracter) in ['0'..'9']);
end;

var cAux, AuxCuenta:string;
i:Integer;
auxTemp: Extended;
begin
if (Trim(Cuenta) = '') or (Length(Cuenta) > 34)
then Result := ''
else begin
// Fase 1: Nos aseguramos que solo contiene Letras y Numeros
Cuenta := UpperCase(Cuenta);
AuxCuenta := Cuenta;
cAux := '';
for i := 1 to Length(Cuenta) do
if (EsAlfanumerico(Cuenta[i]) or EsNumerico(Cuenta[i]))
then cAux := cAux + AnsiString(Cuenta[i]);

Cuenta := cAux;
// Fase 2: Se comprueba si ya es un codigo IBAN, y si no lo es, se añade el PAIS
if (EsAlfanumerico(Cuenta[1]) and EsAlfanumerico(Cuenta[2])) // Es IBAN
then begin
if (EsAlfanumerico(Cuenta[3]) or EsAlfanumerico(Cuenta[4]))
then Result := '';
Cuenta := Copy(Cuenta, 5, Length(Cuenta));//Cuenta.SubString(5, Length(Cuenta)) + Cuenta.SubString(1, 2) + '00';
Pais := Copy(Cuenta, 1, 2);//Cuenta.SubString(1, 2);
end
else begin
//y si no lo es, se añade el PAIS
if (Trim(Pais) = '') then Pais := 'ES';
Cuenta := Cuenta + Pais + '00';
end;

// Fase 3: Se convierten las letras del pais en sus numeros equivalentes:
//A=10, B=11, C=12 ... Z=35
cAux := '';
for i := 1 to Length(Cuenta) do
begin
if (EsAlfanumerico(Cuenta[i]))
then cAux := cAux + FormatFloat('00', Ord(Cuenta[i])-55)//Cuenta[i - 1] - 55)
else cAux := cAux + Copy(Cuenta, i, 1);
end;
Cuenta := cAux;
// Fase 4: Dividimos por 97
auxTemp := StrToInt(Copy(Cuenta, 1, 9)) mod 97;
cAux := FormatFloat('0', auxTemp);//FormatFloat("0", StrToInt(Cuenta.SubString(1, 9)) % 97);
Cuenta := Copy(Cuenta, 10, Length(Cuenta));//Cuenta.SubString(10, Cuenta.Length());
while (Trim(Cuenta) <> '') do
begin
if (StrToInt(cAux) < 10)
then begin
cAux := cAux + Copy(Cuenta, 1, 8);//Cuenta.SubString(1, 8);
Cuenta := Copy(Cuenta, 9, Length(Cuenta));//Cuenta.SubString(9, Cuenta.Length());
end
else begin
cAux := cAux + Copy(Cuenta, 1, 7);//Cuenta.SubString(1, 7);
Cuenta := Copy(Cuenta, 8, Length(Cuenta));//Cuenta.SubString(8, Cuenta.Length());
end;
auxTemp := StrToInt(cAux) mod 97;
cAux := FormatFloat('0', auxTemp);
end;
// Fase 5: Devolvemos el IBAN completo con sus digitos de control.
// Se puede cambiar para devolver solo el digito de control, o lo que se quiera.
Result := Pais + FormatFloat('00', 98 - StrToInt(cAux)) + AuxCuenta;
end;
end;
end;

[Garada]

Gracias por los aportes.

Si se le pasa un IBAN para comprobar sus dígitos de control la función fallaría (incluso la de C++), hay que revisar el paso 2 cuando ya es un IBAN.
Aquí les propongo mis modificaciones:

function GenerarIBAN(Pais, Cuenta: string): string;

function EsAlfanumerico(Caracter: Char): boolean;
begin
Result := CharInSet(Caracter, ['A'..'Z', 'a'..'z']);
end;

function EsNumerico(Caracter: Char): boolean;
begin
Result := CharInSet(Caracter, ['0'..'9']);
end;

var
cAux,
AuxCuenta: string;
i: Integer;
auxTemp: Extended;
begin
Result := '';
Cuenta := Trim(Cuenta);
if (Cuenta = '') or (Length(Cuenta) > 34) then
Exit
else
begin
// Fase 1: Nos aseguramos que solo contiene Letras y Numeros
Cuenta := UpperCase(Cuenta);
cAux := '';
for i := 1 to Length(Cuenta) do
if (EsAlfanumerico(Cuenta[i]) or EsNumerico(Cuenta[i])) then
cAux := cAux + AnsiString(Cuenta[i]);
Cuenta := cAux;
AuxCuenta := Cuenta;

// Fase 2: Se comprueba si ya es un codigo IBAN, y si no lo es, se añade el PAIS
if (EsAlfanumerico(Cuenta[1]) and EsAlfanumerico(Cuenta[2])) then // Es IBAN
begin
if (EsAlfanumerico(Cuenta[3]) or EsAlfanumerico(Cuenta[4])) then
Exit;

Pais := Copy(Cuenta, 1, 2);//Cuenta.SubString(1, 2);
Cuenta := Copy(Cuenta, 5, Length(Cuenta));//Cuenta.SubString(5, Length(Cuenta)) + Cuenta.SubString(1, 2) + '00';
AuxCuenta := Cuenta;
end
else
begin
//y si no lo es, se añade el PAIS
if (Trim(Pais) = '') then
Pais := 'ES';
end;
Cuenta := Cuenta + Pais + '00';

// Fase 3: Se convierten las letras del pais en sus numeros equivalentes:
//A=10, B=11, C=12 ... Z=35
cAux := '';
for i := 1 to Length(Cuenta) do
begin
if (EsAlfanumerico(Cuenta[i])) then
cAux := cAux + FormatFloat('00', Ord(Cuenta[i]) - 55)//Cuenta[i - 1] - 55)
else
cAux := cAux + Copy(Cuenta, i, 1);
end;
Cuenta := cAux;

// Fase 4: Dividimos por 97
auxTemp := StrToInt(Copy(Cuenta, 1, 9)) mod 97;
cAux := FormatFloat('0', auxTemp);//FormatFloat("0", StrToInt(Cuenta.SubString(1, 9)) % 97);
Cuenta := Copy(Cuenta, 10, Length(Cuenta));//Cuenta.SubString(10, Cuenta.Length());
while (Trim(Cuenta) <> '') do
begin
if (StrToInt(cAux) < 10) then
begin
cAux := cAux + Copy(Cuenta, 1, 8);//Cuenta.SubString(1, 8);
Cuenta := Copy(Cuenta, 9, Length(Cuenta));//Cuenta.SubString(9, Cuenta.Length());
end
else
begin
cAux := cAux + Copy(Cuenta, 1, 7);//Cuenta.SubString(1, 7);
Cuenta := Copy(Cuenta, 8, Length(Cuenta));//Cuenta.SubString(8, Cuenta.Length());
end;
auxTemp := StrToInt(cAux) mod 97;
cAux := FormatFloat('0', auxTemp);
end;
// Fase 5: Devolvemos el IBAN completo con sus digitos de control.
// Se puede cambiar para devolver solo el digito de control, o lo que se quiera.

Result := Pais + FormatFloat('00', 98 - StrToInt(cAux)) + AuxCuenta;
end;
end;

[jorgecurro]

Muchas gracias por el aporte, me viene de perlas.

Saludos

[ramato79]

Gracias por la aportación.
Solo una cosilla, el codigo del pais en el caso de ser una cuenta IBAN debe tomarse antes de la modificacion de la cuenta :)

[quote=Angel.Matilla;469275]Ampliando el código anterior que puse, para validar cualquier IBAN que se introduzca o calcular el correspondiente a un número de cuenta. Este es el código:

Cuenta = cAux;
if (isalpha(Cuenta.c_str()[0]) && isalpha(Cuenta.c_str()[1])) // Es IBAN
{
if (isalpha(Cuenta.c_str()[2]) || isalpha(Cuenta.c_str()[3]))
return "";

Pais = Cuenta.SubString(1, 2);
Cuenta = Cuenta.SubString(5, Cuenta.Length()) + Cuenta.SubString(1, 2) + "00";
}
else
{
if (Pais.IsEmpty())
Pais = "ES";

Cuenta = Cuenta + Pais + "00";
}

[Angel.Matilla]

Tienes razón en tu puntualización. No osbtante, y es culpa mía, el código de país es uno de los parámetros que se pasan a la función.

[Angel.Matilla]

Dado que a partir del 1 de febrero de 2014 se cambia el formato para efectuar pagos por vía telemática y hay que aplicar la normativa SEPA; la AEB ha publicado la nueva normativa para dichos soportes informáticos y se puede consultar el formato de los nuevos CSB19 (CSB 19.14) en Adeudos Directos SEPA en fichero electrónico – Esquema Básico (http://www.aeb60.com/Cuadernos/Cuaderno%2019.14%20Adeudos%20Directos%20SEPA%20en%20fichero%20electr%C3%B3nico%20%E2%80%93%20Esquema %20B%C3%A1sico.pdf).
La web de donde tome el cuaderno de carga ha desaparecido. Podéis encontrar la normativa, por ejemplo, en http://empresas.bankia.es/Ficheros/CMA/ficheros/N1914_Esq_Basico.PDF

[pacopenin]

¿Alguien tiene hecho el cálculo de la Identificación de Acreedor para las domiciliaciones en formato SEPA?.

Uno de los pasos es tomar el resto de la división de un numero de p.e. 1185626240142800 entre 97. Dicho número sale de formar un string según varias formulas. Pues el caso es que no se como hacer esa división, ya que no se puede a entero para realizar un mod y obtener el resto. Ando espeso espeso. Se agradecen sugerencias. La explicación completa y más clara que la mía aquí (http://inza.wordpress.com/2013/10/25/como-preparar-los-mandatos-sepa-identificador-del-acreedor/).

[pacopenin]

Bueno, dejé de obsesionarme con hacerlo de una forma más directa y estoy haciendolo así


var
cfinal : String;
cc, n, resto : integer;
nn, cociente : Double;
begin

......

nn:=StrToFloat(cFinal);
cociente := nn / 97;
cc := Trunc(cociente);
resto := trunc(nn - (cc * 97));
n := 98 - resto;

[Angel.Matilla]

¿Alguien tiene hecho el cálculo de la Identificación de Acreedor para las domiciliaciones en formato SEPA?.

Uno de los pasos es tomar el resto de la división de un numero de p.e. 1185626240142800 entre 97. Dicho número sale de formar un string según varias formulas. Pues el caso es que no se como hacer esa división, ya que no se puede a entero para realizar un mod y obtener el resto. Ando espeso espeso. Se agradecen sugerencias. La explicación completa y más clara que la mía aquí (http://inza.wordpress.com/2013/10/25/como-preparar-los-mandatos-sepa-identificador-del-acreedor/).
El bucle para ir formando esas cadenas lo tienes en mi primer mensaje:
AnsiString cAux; Cuenta = Cuenta + "142800";
cAux = FormatFloat("0", StrToInt(Cuenta.SubString(1, 9)) % 97);
Cuenta = Cuenta.SubString(10, Cuenta.Length());
while (!Cuenta.IsEmpty())
{
if (StrToInt(cAux) < 10)
{
cAux = cAux + Cuenta.SubString(1, 8);
Cuenta = Cuenta.SubString(9, Cuenta.Length());
}
else
{
cAux = cAux + Cuenta.SubString(1, 7);
Cuenta = Cuenta.SubString(8, Cuenta.Length());
}
cAux = FormatFloat("0", StrToInt(cAux) % 97);
}
return "ES" + FormatFloat("00", 98 - StrToInt(cAux));En este caso se supone que la cuenta siempre es de España (de ahí la cadena 1428 del principio del código); de otra forma bastaría con pasar el parámetro del país.

[pacopenin]

Gracias Angel.Matilla, pero mi problema no es con el IBAN ya que las formulas que habeis puesto funcionan bien.

El error ha sido mío por no abrir otro hilo, pero como en el fondo si guarda relación por eso lo he comentado aquí.
El problema es que al hacer las domiciliaciones bancarias hay que calcular la Identificación de Acreedor de acuerdo a la fórmula que comenté antes partiendo del Pais, un sufijo (000) y el CIF. Esto nos da en un determinado momento un número entero de 16 dígitos del que hay que sacar el resto de la división entre 97 y ese cálculo excedía el rango numérico de los enteros que conocía (nunca usé ningún entero mayor que longInt). Acabo de ver que hay un Int64 y un StrToInt64 que no sabía que existían. Con eso supongo que me arreglaré. Cuando lo tenga funcionando publicaré el código en un nuevo hilo.

^\||/

[Angel.Matilla]

Vale. También tengo el código para hacer el cálculo a partir del CIF. Es este, en Builder:
Para el primer registro obligatorio del Cuaderno 19-14

String Registro;
Regsitro = "0119143001" + AjustaCadena("ES" + Modulo9710(cIdPre + "ES00") + cSufPre + cIdPre, ' ', 35, 'D') +
AjustaCadena(cTitPre, ' ', 70, 'D') + Date().FormatString("yyyymmdd") +
AjustaCadena("PRE" + Now().FormatString("yyyymmddhhnnss00000") + cRefInt +
Now().FormatString("yymm"), ' ', 35, 'D') +
cCtaPre.SubString(5, 8) + AnsiString::StringOfChar(' ', 434));Siempre suponiendo que el país es España; las variables son:

cIdPre es el CIF/NIF pedido (en este caso es el presentador).
cSufPre es el sufijo asigando apra ese CIF.
cTitPre es el nombre del titular de ese CIF.
cCtaPre es su cuenta bancaria en formato IBAN; en este caso, al ser la cabecera del presentador, se toman el código de entidad y oficina.
Las funciones que se llaman dentro de esa composición son estas:
AnsiString AjustaCadena(AnsiString cCadena, char cRelleno, int nLong, char cJust)
{
cCadena = Trim(cCadena.SubString(1, nLong));
switch (cJust)
{
case 'I':
cCadena = AnsiString::StringOfChar(cRelleno, nLong - cCadena.Length()) + cCadena;
break;
case 'C':
cCadena = AnsiString::StringOfChar(cRelleno, (nLong - cCadena.Length())/2) + cCadena + AnsiString::StringOfChar(cRelleno, (nLong - cCadena.Length())/2);
if (cCadena.Length() < nLong)
cCadena += AnsiString(cRelleno);
break;
case 'D':
cCadena = cCadena + AnsiString::StringOfChar(cRelleno, nLong - cCadena.Length());
break;
}
return (cCadena);
}Esta primera función rellena a la longitud especificada (nLong) con el carácter indicado (cRelleno) justificando como indica cJust: Si cJust vale D añade caracteres al final; si es I los añade al principio y si es C centra la cadena. La otra función es esta:
AnsiString Modulo9710(AnsiString Cadena)
{
AnsiString cValor;

cValor = "";
for (int nPos = 1; nPos <= Cadena.Length(); nPos ++)
{
if (isalpha(Cadena.c_str()[nPos - 1]))
cValor = cValor + FormatFloat("00", Cadena.c_str()[nPos - 1] - 55);
else
cValor = cValor + Cadena.SubString(nPos, 1);
}
Cadena = cValor;

cValor = FormatFloat("0", StrToInt(Cadena.SubString(1, 9)) % 97);
Cadena = Cadena.SubString(10, Cadena.Length());
while (!Cadena.IsEmpty())
{
if (StrToInt(cValor) < 10)
{
cValor = cValor + Cadena.SubString(1, 8);
Cadena = Cadena.SubString(9, Cadena.Length());
}
else
{
cValor = cValor + Cadena.SubString(1, 7);
Cadena = Cadena.SubString(8, Cadena.Length());
}
cValor = FormatFloat("0", StrToInt(cValor) % 97);
}
return cValor;
}Que calcula los dígitos de control en base al módulo 97-10. Espero que sea esto lo que buscabas.

[Angel.Matilla]

Gracias Angel.Matilla, pero mi problema no es con el IBAN ya que las formulas que habeis puesto funcionan bien.

El error ha sido mío por no abrir otro hilo, pero como en el fondo si guarda relación por eso lo he comentado aquí.
El problema es que al hacer las domiciliaciones bancarias hay que calcular la Identificación de Acreedor de acuerdo a la fórmula que comenté antes partiendo del Pais, un sufijo (000) y el CIF. Esto nos da en un determinado momento un número entero de 16 dígitos del que hay que sacar el resto de la división entre 97 y ese cálculo excedía el rango numérico de los enteros que conocía (nunca usé ningún entero mayor que longInt). Acabo de ver que hay un Int64 y un StrToInt64 que no sabía que existían. Con eso supongo que me arreglaré. Cuando lo tenga funcionando publicaré el código en un nuevo hilo.

^\||/
Otra cosa: Ten en cuenta que el sufijo no siempre es 000; este dato te lo tiene que facilitar la entidad bancaria a través de la que se lleva a cabo el cobro de los recibos.

[pacopenin]

Voy a probar, aunque veo que la forma de calcularlo es distinta a la que yo había encontrado y no se dan números enteros tan largos. Y lo del sufijo ya lo tengo en cuenta, ^\||/

[Angel.Matilla]

Para hacer el cálculo seguí las sugerencias que encontré en una web; no recuerdo si es la del enlace que puse más arriba. Si se puede trabajar con la cadena completa se hace de una vez.