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.

El protocolo de validación lo encontré en Código Internacional de Cuenta Bancaria (IBAN) 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)

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.
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)

[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.

1. 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.
2. Se convierte la cadena a mayúsculas y se desprecia todo lo que no sean letras o dígitos.
3. 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.
4. 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.
5. 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): A = 10, B = 11, etc.
6. Calculamos los dígitos de control de acuerdo con el módulo 97.
7. 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.

Código Delphi [-]
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:

Código Delphi [-]
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]

Empezado por 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.

La web de donde tome el cuaderno de carga ha desaparecido. Podéis encontrar la normativa, por ejemplo, en http://empresas.bankia.es/Ficheros/C...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í.

[pacopenin]

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

Código Delphi [-]
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]

Empezado por 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í.

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]

Empezado por 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.

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.