Norma 19 34 Crear xml formato Sepa
 

Hola buenas tardes. Antes de nada agradecer anticipadamente aquellos que tomen interés en este problema.
Tengo una aplicación que me genera los archivos para enviar a la entidad bancaria en formato Sepa TxT. A partir del próximo mes de Febrero este tipo de archivos ya no estará admitido por las entidades bancarias, quedando obsoleto. Me dispongo por lo tanto a pasar de formato sepa txt a formato sepa xml iso 20022 y la verdad sinceramente no se ni por donde empezar este asunto. Mi pregunta es si existe algún componente para generar este tipo de ficheros sepa (como antiguamente los había para la antigua norma 19) o algún tipo de herramienta o documentación que me ayude en esta tarea de crear el fichero con el formato indicado. He realizado pruebas con el componente XMLDocument (Delphi 7), pero no se si será la opción más adecuada con respecto al componente empleado.
Agradecería infinitamente la ayuda así como cualquier sugerencia.
Gracias.
Un saludo,
Ramiro

ramherfer,

¡Bienvenido al Club Delphi! :D

Te sugiero revisar la Guía de estilo de los foros, recomendada a todos los nuevos ingresos al Club Delphi.

¡Gracias por tu cooperación! :) ^\||/

Saludos,

Nelson.

Hola, ¿tienes la documentación para la creación de los ficheros?

Si, tengo la estructura del fichero XML, si te refieres a esto, pero no se como proceder con el componente XMLDocument.

¿A qué te refieres con que "no sabes proceder"?

No se como utilizar el componente, como validar el fichero xml...

Como ya te han aconsejado antes, deberías leer nuestra guía de estilo :)

No sabes cómo utilizar el componente: lo pinchas con el ratón y lo arrastras a un formulario.
No sabes cómo validar el fichero xml: tendrás que seguir las instrucciones que vienen en el librito de creación de la norma.

Muchas gracias por tu ayuda Casimiro Notevi, no sabes cuan agradecido te estoy, intentaré ver si soy capaz de arrastrar el componente al formulario y de leer el librito de creación de la norma, así como la ayuda de Delphi del componente.

Pregunta cuando tengas alguna duda.

No te preocupes ha sido toda una lección.

Me alegro ^\||/

No creo que tengas que pasarte a XML necesariamente .... lo único es que los ficheros de texto tiene que cumplir la norma 34-14 (ultima) usando IBAN / BIC / SWIFT ademas de algunos cambios en los registros.

¿Febrero? ¿de qué año? porque el cambio a la nueva normativa SEPA fue en Febrero de este año y ya estamos a Marzo. :confused:

Si te refieres a Febrero de este año, como bien dice nuestro colega avmm2004, no ha sido necesario usar XML, solo cambiar el diseño de los ficheros de texto para adaptarse a la nueva normativa. Bastantes de los que andamos por aquí ya hemos pasado por eso sin grandes problemas.

Saludos

Ya me extrañaba, porque no había oido nada sobre XML obligatorio.

uis....espera.... me estoy confundiendo yo también, fue en Febrero pero del año pasado. :rolleyes:

No te ralles con XMLDocument
 

Yo en mi programa lo implementé también con XMLDocument en Delphi7, no es muy complicado, aunque evidentemente hay que mirar cosas del componente.
Pero luego resulta que al depender de componentes de Windows explotaba en sistemas con Windows 64 bits. Aunque mantengo el código, deseché su uso completamente. Las dependencias con otros programas/componentes siempre son problemáticas.

Mi consejo es que directamente escribas el archivo como si de un archivo de texto normal se tratase. Igual que has montado la 34.14 y 19.14/15/44 en formato de texto básico.
De hecho, y dadas las limitaciones impuestas a los caracteres válidos, a pesar de tratarse de un archivo unicode no tendrás problemas en montarlo todo con Delphi7.

El código, aunque sale algo más largo, es mas sencillo de entender y mantener.

Aqui http://www.sepaesp.es/f/websepa/secc.../BOEnichos.pdf
dice esto:

Yo entiendo que por mucho que nos hayamos adaptado a la norma SEPA si estamos enviando los ficheros de texto tenemos hasta febrero del 2016 para pasar a enviar los xml.

Creo que ahí no hablan de las normas 19 y 34

Los documentos oficiales simpre me resultan enfarragosos asi que igual me columpio entonces, yo entendía que la norma 34 era para transferencias y la 19 para adeudos, por eso al leer:
"transferencias o adeudos domiciliados individuales agrupados" entendi que se referian a los cuadernos 34 y 19.

Comunicado de una de las entidades bancarias (Banco Sabadell), para los que estaban tranquilos de que habian ya pasado por este mal trago:

SEPA - FORMATO XML ISO20022
A partir del 1 de Febrero de 2016 el formato SEPA XML será el único válido para el envío de ficheros de Adeudos Domiciliados y Transferencias. En consecuencia, los Recibos físicos y los ficheros de Normas 32, 58, 19.14, 19.15, 19.44 y 34.14 se deberán adaptar a los nuevos estándares obligatorios de Adeudos Directos y Transferencias SEPA XML.

Es decir que de aquí a más o menos un año, no aceptarán el formato SEPA en fichero txt deberá ser formato XML ISO 20022.

Gracias.

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.