Un enlace, por favor.

Ya veo:
http://aeb.respuestaprofesional.com/norma_sepa.html

Me parece absurdo el cambio, no sé qué mejora tiene.

Aunque creo que sigue refiriéndose a transferencias sepa, no a los recibos domiciliados, que siguen igual, en formato texto. No sé seguro.

Nasca, pues te agradecería muchísimo me echaras un cable, porque se que tengo tiempo, pero es un serio problema. LLevo días leyendo tratando de interpretar la normativa, viendo ficheros de ejemplo, pero no consigo con el xmldocument confeccionar un xml correcto (me asigna atributos en los nodos hijo), ya desde la aplicación del sepa estuve muy tranquilo con la conversión de la norma 19 CSB a Sepa en texto plano sabiendo que tenia tiempo hasta el 2016, pero en cuanto me doy cuenta eso está a la vuelta de la esquina.

Si me puedes orientar un poco, de verdad no sabes cuanto te lo agradecería. Tan solo con la secuencia de instrucciones empleada con el XMLDocument me salvas.
Un saludo,
Ramiro

ramherfer,

:rolleyes:

Revisa esta información:
Espero sea útil :)

Nelson.

Gracias Nelson, he estado mirando el componente y desgraciadamente es para a partir de Delphi 2009 con lo que no lo puedo instalar en mi Delphi 7, no obstante he visto la sencillez del código que propone como ejemplo y voy a ver si lo traslado al XMLDocument a ver si me arroja un poco de luz. Me preocupa el XMLDocument por lo que comenta Nasca en versiones Windows de 64Bits, aunque tengo aplicaciones rodando en windows 32/64 con componentes instalados y no me a dado problemas, pero con lo que Nasca comenta no tengo por mas que alzar las orejas. Una vez tenga algo en XML a modo de prueba, lo haré rodar bajo Windows 32 y Windows 64 en diferentes versiones y a ver que pasa.
Agradezco tu ayuda y comento como ha ido la prueba del código (que me parece bastantesencillo).
Gracias,
Ramiro

Algo de código
 

He revisado y solo mantuve el código de lectura del XMLDocument, que fue lo que inicialmente implementé y me dio errores.

Lo dicho, mucho mas seguro y sencillo evitar esa dependencia con código del tipo:

Código Delphi [-]
  Writeln(FN34,'<?xml version="1.0" encoding="UTF-8"?>');
  Writeln(FN34,'<Document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:iso:std:iso:20022:tech:xsd:pain.001.001.03">');
  Writeln(FN34,' <CstmrCdtTrfInitn>');
  Writeln(FN34,'  <GrpHdr>');
  //...
  Writeln(FN34,' <CstmrCdtTrfInitn>');
  Writeln(FN34,'  <GrpHdr>');
  //...
  Writeln(FN34,'    <PstlAdr>');
    SetCampo('     ','PstCd', Copy(LimpiarCarNormaSEPAXML(cdsEmisorCOD_POSTAL.Value),1,16), false);
    SetCampo('     ','TwnNm', Copy(LimpiarCarNormaSEPAXML(cdsEmisorCIUDAD.Value),1,35), false);
    SetCampo('     ','CtrySubDvsn', Copy(LimpiarCarNormaSEPAXML(cdsEmisorPROVINCIA.Value),1,35), false);
  if cdsEmisorID_PAIS.Value <> '' then
    SetCampo('     ','Ctry', cdsEmisorID_PAIS.Value, true)
    else
    SetCampo('     ','Ctry', 'ES', true);
    SetCampo('     ','AdrLine', Copy(LimpiarCarNormaSEPAXML(cdsEmisorDOMICILIO.Value),1,70), false);
  Writeln(FN34,'    </PstlAdr>');
 //...
cdsDatos.First;
while not cdsDatos.EOF do
 begin
  Writeln(FN34,'   <CdtTrfTxInf>');
  Writeln(FN34,'    <PmtId>');
 //...
  Writeln(FN34,'    <Amt>');
  Writeln(FN34,'     <InstdAmt Ccy="EUR">' + importe_t +'</InstdAmt>');
  Writeln(FN34,'    </Amt>');
//En esta norma no es opcional, pero dependerá de la implantación de cada banco
if (cdsDatosBIC.Value <> '') or (cdsDatosL_ENTIDAD_BIC.Value <> '') then
  begin
  Writeln(FN34,'    <CdtrAgt>');
  Writeln(FN34,'     <FinInstnId>');
  if (cdsDatosBIC.Value <> '') then
    SetCampo('      ','BIC', cdsDatosBIC.Value, false)
    else
    SetCampo('      ','BIC', cdsDatosL_ENTIDAD_BIC.Value, false);    
  Writeln(FN34,'     </FinInstnId>');
  Writeln(FN34,'    </CdtrAgt>');
  end;

Es optimizable con ayuda de algunas funciones, pero así queda mas legible.

El código está raro porque he tenido que pasarlo por un editor html para no perder las etiquetas xml.

Gracias Nasca, me imagino que construyendo el XML de esta forma los bancos lo admiten ¿no?.
Creo que voy a probar con esto, al fin de al cabo ya no se diferencia mucho de la forma de construirlo, de como ahora con sepa texto plano esta.
De verdad mil gracias por encender algo de luz sobre este problema.
Un saludo,

XMLDocument y similares son interfaces muy engorrosas (y ademas son dependencias a librerias del OS), y que son para hcer procesamiento muy complejos de XML... que son raros.

Una forma muy simple es usar plantillas asi:

y hacer el reemplazo del texto.

Me encontre ademas una implementacion de Mustache (mustache es un sitema de generacion de templates que hace facil hacer lo anterior, muy utilizado para hacer sitios web) para Delphi:

http://blog.synopse.info/post/2014/0...-Delphi-part-3

Otra es que estos componentes estan inspirados en el DOM (Document Object Model), que es todo un rollo... y que esconden una verdad simple:

XML es una forma mas "verbosed" de representar un arbol. Asi que tambien puedes simplemente hacer/usar una estructura de arbol y luego serializar a XML.

No hay problema
 

Sin problemas.

En la norma solo se permiten los caracteres ASCII, así que si montas una función de limpiado que convierta a unicode no hay ningún problema. El xml a utilizar no deja de ser un archivo de texto con extensión xml en codificación utf8.

Si ya utilizas alguna función para limpiar caracteres no soportados solo tienes que pasarla por un Utf8Encode.

Código Delphi [-]
LimpiarCarNormaSEPAXML(texto: String): String;
begin
  Result := Utf8Encode(LimpiarCarNormaSEPA(texto));
end;

100% válido y ninguna dependencia de instalaciones de librerías determinadas en el sistema. Por lo que funcionará sin problemas en sistemas Windows de 64 bits.

P.D. Tal y como explica el compañero, para replicar la estructura de árbol algo tan sencillo como escribir determinados espacios da un resultado muy bonito y legible por humanos en el resultado final, aunque es totalmente innecesario para la lectura informática.

Por cierto ve al esquema original y pasa de la documentación de la implementación española, que no tiene mucho sentido. Con el esquema y alguna consulta puntual, sobre todo para saber que esperan en cada caso, en el documento español tendrás suficiente.

Gracias Nasca, pues a codificar se ha dicho, creo que es lo más sencillo (conociendo la estructura Sepa) y lo más parecido a lo que tengo ahora, pero como bien dices con extensión XML.
Voy a seguir 100% tu recomendación.

mamcx, gracias por tu consejo, lo único es que creo que tras las reflexiones de nasca (sencilla a priori), creo que me estaría complicando la vida, para algo tan sencillo como enviar los puñeteros recibos al banco para cobrar. No obstante agradezco tu sugerencia y no la puedo menos preciar hasta tener el sistema montado y funcionando.

Saludos,

ramherfer,

:rolleyes:

Revisa esta información:
Espero sea útil :)

Nelson.

Confirmado.

A partir del día 1 de febrero de 2016 todos los archivos tienen que ir en formato XML.

Saludos y a currar. :D

Un avance espectacular, después de tantos años ya era hora de pasar del formato texto al formato... texto recargado :eek:
Podían haber cambiado, en todo caso, a un simple fichero .INI que sería más cómodo y claro para leerlo y escribirlo.

El caso es no parar de dar por el c... pero bueno, estas cosillas vienen bien, así se hace limpieza de programas en el mercado y algún bocado daremos. ;)

Está clara mi poca visión comercial :rolleyes:

Gracias Newtron por confirmar tan rotundamente, esa rareza mía que algunos tenían solucionado desde el 2014 :D y que parecía que estaba loco y que yo había llegado tarde (que trato recibido por algunos miembros de este foro -que desagradable-).
Por cierto ya lo tengo solucionado, de una forma muy, muy sencilla y bastante rápida siguiendo las "amables, sabias y rodadas instrucciones de Nasca", era tan solo lo que buscaba con mi pregunta, ahora como bien apuntas a recoger dividendos :D
El formato ha sido validado por varias entidades bancarias sin ningún problema, así que seguro que no haré tarde!!.

Buenas noches,

siento reabrir este hilo pero el tema es realmente interesante y necesario a medida que pasa el tiempo y se acerca la fecha...

Me he puesto manos a la obra basándome en vuestros comentarios, muy útiles por cierto, y pese a mis pobres conocimientos he conseguido crear un archivo .xml y empezar a meter lineas en él.

Me queda mucha tarea por delante pero hay algo que no quiero pasar por alto antes de que se enrede todo demasiado.

Veo que hay caracteres que no soporta la norma SEPA y habláis de una función para limpiarlos y codificar lo necesario.

¿Os importaría indicar el código de esa función o indicarme como tengo que hacerlo?

Según entiendo hay que cambiar las "ñ" por "n" y cosas de esas pero por ejemplo los acentos ¿Que se hace con ellos?

Muchas Gracias por vuestro aporte e interés

En la documentación de la norma lo explica. Deberías descargarla y leerla antes de hacer cualquier cosa.

Tampoco tiene mucho misterio. Los caracteres válidos son estos:

Se pueden sustituir caracteres acentuados para no hacer cagadas con algo como:

Código Delphi [-]
texto := StringReplace(texto,'Ö','O',[rfReplaceAll]);

Y esta función u otra similar te resuelve el resto:

Código Delphi [-]
      for i := 1 to Length(texto) do
          begin
            if not(Ord(texto[i]) in [65..90,97..122,48..57,47,45,63,58,40,41,46,44,39,43,32]) then
               texto[i] := '¤'
          end;

      texto := StringReplace(texto,'¤','',[rfReplaceAll, rfIgnoreCase]);

Suerte.

Hola Delphitest, yo básicamente he utilizado esta función y por el momento no me ha dado ningún problema:

Código Delphi [-]
 
  Function LimpiarCarNormaSEPAXML(texto: String; longitud: Integer): String;
  begin
    Result := Utf8Encode(Trim(Copy(texto, 1, longitud)));
  end;

El fichero resutlante ha sido testeado en entidades financieras, sin mayor problema. La función que indica nasca también es una opción, yo particularmente la voy a probar también.
Espero te sirva de ayuda.
Un saludo

Muchas gracias por el empujoncillo :)

En base a lo que comentais he hecho esta función:

Código Delphi [-]
Function TForm1.LimpiarCarNormaSEPAXML(texto: String; longitud: Integer): String;
var i : integer;
begin
// Quitar los acentos de las vocales y caracteres raros
texto := StringReplace(texto,'á','a',[rfReplaceAll]);
texto := StringReplace(texto,'Á','A',[rfReplaceAll]);
texto := StringReplace(texto,'é','e',[rfReplaceAll]);
texto := StringReplace(texto,'É','E',[rfReplaceAll]);
texto := StringReplace(texto,'í','i',[rfReplaceAll]);
texto := StringReplace(texto,'Í','I',[rfReplaceAll]);
texto := StringReplace(texto,'ó','o',[rfReplaceAll]);
texto := StringReplace(texto,'Ó','O',[rfReplaceAll]);
texto := StringReplace(texto,'ú','u',[rfReplaceAll]);
texto := StringReplace(texto,'Ú','U',[rfReplaceAll]);
texto := StringReplace(texto,'Ö','O',[rfReplaceAll]);
texto := StringReplace(texto,'ö','o',[rfReplaceAll]);
texto := StringReplace(texto,'Ñ','N',[rfReplaceAll]);
texto := StringReplace(texto,'ñ','n',[rfReplaceAll]);
texto := StringReplace(texto,'Ç','C',[rfReplaceAll]);
texto := StringReplace(texto,'ç','c',[rfReplaceAll]);

// Recorrer el texto para eliminar los caracteres no permitidos
for i := 1 to Length(texto) do
begin
  if not(Ord(texto[i]) in [65..90,97..122,48..57,47,45,63,58,40,41,46,44,39,43,32]) then
     texto[i] := '¤'
end;
texto := StringReplace(texto,'¤','',[rfReplaceAll, rfIgnoreCase]);

// Convertir a mayúsculas
texto := ansiuppercase(Texto);

// Codificar a Utf8
Result := Utf8Encode(Trim(Copy(texto, 1, longitud)));
end;

Lo de convertir a mayúsculas no se si es necesario o no pero por si acaso...

Y luego me queda la duda de las vocales acentuadas, tipo á é ... he revisado la documentación y no dice que sean caracteres válidos pero tampoco los incluye como ç y ñ para que no lo sean.

He abierto algunos de los ficheros de recibos que suelo enviar al banco y veo que hay muchos nombres que incluyen acentos y se han procesado correctamente.