> For the complete documentation index, see [llms.txt](https://docs.editran.onesait.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.editran.onesait.com/documentacion-editran/editran-sepa-v3/modo-de-uso.md).

# Modo de uso

En este apartado se van a describir las dos maneras en las que el usuario puede utilizar la facilidad Editran/SEPA: como proceso independiente que convierte los ficheros meramente de uno al otro formato e integrado con Editran. Además, también se abordarán los posibles tratamientos a efectuar con los ficheros cuya conversión finalice con Warnings.

## 4.1 Transformación con Warnings

Dada la asimetría entre las normas de los formatos XML y plano en cuanto a obligatoriedad y contenido de los campos en una y otra, en ocasiones el conversor genera ficheros que no cumplen estrictamente la norma del formato final (campos obligatorios que quedan vacíos, valores diferentes a los que indica la norma, etc.) aún cumpliéndola en el formato inicial. Este resultado será más habitual en las transformaciones de XML a plano pues, dada la transitoriedad de este último, se ha dado prioridad al cumplimiento de los requisitos del formato XML.

Así es que en dicha situación, siempre que el fichero inicial sea correcto, Editran/SEPA generará el correspondiente fichero convertido pero terminará con un resultado especial de Warning (véase el apartado [10.1 Recepción de los ficheros](#101-recepción-de-los-ficheros)) para poder diferenciarlo de un fichero que sí sigue rigurosamente la norma. Por defecto, los scripts están definidos para asumir dicho resultado como correcto, pero bastaría con modificarlos para definir otro tipo de comportamientos ante esa situación (mover esos ficheros a otra carpeta, eliminarlos como se hace con los que tienen errores, etc.).

## 4.2 Proceso cliente

Como aplicación JAVA, podemos diseñar nuestra propia llamada a Java, en la que debemos ejecutar:

**En Windows:**

```
java -cp "lib/*;lib/Win/*" com.indra.mmdd.editran.main.EDItranSepaXmlMain [Parametros]
```

**En UNIX:**

```
java -cp "lib/*:lib/DirSO/*" com.indra.mmdd.editran.main.EDItranSepaXmlMain [Parametros]
```

En `lib/DirSO/*`, sustituir `DirSO` por el nombre de la subcarpeta de lib correspondiente al sistema operativo donde se va a ejecutar:

* AIX: `lib/AIX/*`
* HP: `lib/HP/*`
* Linux: `lib/Linux/*`
* Sun: `lib/Sun/*`

Donde `[Parametros]` puede ser, según el número de argumentos especificados:

**1 argumento:**

* `-h` para una consulta general del modo de uso,
* `-v` para mostrar en el log la versión del Conversor que se está utilizando,

o bien

* `<fichero de entrada>` — siendo `<fichero de entrada>` el path y nombre del fichero que contiene los datos de origen.

En este modo de uso, Editran/SEPA decide la transformación a realizar según la extensión del fichero de origen.

* Asumirá que si el nombre de dicho fichero termina con la extensión `.xml` la transformación a realizar es en el sentido:

  **XML (ISO 20022) → Plano (versiones 14 y 44)**

  El fichero generado por Editran/SEPA tendrá en ese caso formato plano y su nombre será el mismo que el del fichero origen pero sin la extensión `.xml`.
* De la misma manera, si el fichero de origen no tiene extensión `.xml`, Editran/SEPA asume que la transformación que debe hacer es en el sentido:

  **Plano (versiones 14 y 44) → XML (ISO 20022)**

  El fichero generado por Editran/SEPA tendrá en ese caso formato XML y su nombre será el mismo que el del fichero origen pero añadiéndole la extensión `.xml`.

El fichero XML es el de entrada en el caso de una transformación XML → Plano o bien el que resulta de la ejecución en el caso de una transformación Plano → XML.

**3 argumentos:** `<fichero de entrada> <fichero de salida> <P|X>`

Siendo:

* `<fichero de entrada>`: path y nombre del fichero que contiene los datos de origen.
* `<fichero de salida>`: path y nombre del fichero final ya transformado.
* `<P|X>`: es el formato que tendrá el fichero obtenido con la transformación.
  * Cuando se indique `P` Editran/SEPA realizará una transformación en el sentido: **XML (ISO 20022) → Plano (versiones 14 y 44)**
  * Por el contrario, cuando se indique `X` Editran/SEPA generará un fichero XML: **Plano (versiones 14 y 44) → XML (ISO 20022)**

El fichero XML es el de entrada en el caso de una transformación XML → Plano o bien el que resulta de la ejecución en el caso de una transformación Plano → XML.

En el ANEXO se detallan los posibles códigos de error devueltos por el proceso.

Además el usuario podrá consultar en el fichero `out.log` información más detallada y explícita de cada tarea, y su resultado, realizada durante el proceso de conversión. Dicho fichero se genera automáticamente en la carpeta `logs` de la instalación de SEPA.

## 4.3 Uso de Onesait Ecosystems · Editran/SEPA de forma autónoma

Editran/SEPA se puede ejecutar de forma autónoma de la forma que hemos aplicado en el punto [4.2 Proceso cliente](#42-proceso-cliente). En la carpeta de scripts se incluye, dentro de cada Sistema Operativo, un script de ejemplo para poder llamar a SEPA de forma autónoma llamado `SEPA.bat` o `SEPA.sh`. Estos scripts se pueden ejecutar de 3 formas:

* Sin argumentos: El script te pide fichero de entrada y (opcionalmente) fichero de salida y sentido.
* 1 argumento: El argumento es el nombre del fichero de entrada.
* 3 argumentos: Los argumentos son el fichero de entrada, fichero de salida y sentido.

Los argumentos se introducen a Editran/SEPA de la misma forma que se realiza en el punto 4.2.

## 4.4 Integración con Onesait Ecosystems · Editran

Para incorporar el uso de Editran/SEPA al de editran se utilizarán los procesos de usuario previo a emisión y posterior a emisión o posterior a recepción de Editran/G. En concreto el administrador de los perfiles deberá indicar en dichos parámetros de Editran/G unos scripts que realicen esa llamada. En la subcarpeta scripts bajo SEPA, y dentro de cada sistema operativo, se pueden consultar los diversos ejemplos que se adjuntan con la instalación y que recogen tanto la llamada al propio conversor como las principales tareas a realizar antes y después de la misma.

Los scripts `startSeparador`, `stopSeparador` sólo deben ser usados si se requiere la funcionalidad de Separador XML (véase apartado [9 SEPARADOR ficheros planos y XML](#9-separador-ficheros-planos-y-xml)). Los scripts de su Sistema Operativo deben ser copiados a la carpeta raíz SEPA.

En concreto dichos scripts harán una llamada Java, como las que se han visto en el apartado [4.2 Proceso cliente](#42-proceso-cliente), por cada fichero que se encuentre o bien en el directorio de emisión (en el caso del previo a emisión) o bien en el de recepción (si se utiliza en el proceso posterior a recepción).

Si la transformación de uno de los ficheros finalizara con error, el batch a utilizar eliminaría los ficheros convertidos (respetando los originales) y quedaría interrumpido para toda la presentación.

### 4.4.1 Windows

El script Previo a emisión que hace que se ejecute Editran/SEPA en una presentación de emisión se llama `PRVEMISEPA.bat`.

Para poder utilizar dicho batch hay que definir `.\SEPA\PRVEMISEPA.bat` en el apartado "Previo a emisión" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

> **IMPORTANTE:** Es necesario definir en el directorio de emisión con el metacaracter `*` al final de la ruta, y además no se pueden utilizar rutas relativas (`..\`, `.\`, etc.)

Por ejemplo, si los ficheros están en el directorio `c:\Ficheros\SEPA\`, en el apartado Ficheros de Editran/G habrá que definir: `c:\Ficheros\SEPA\*`

También se puede definir un nombre común para los ficheros a emitir y al final definir el asterisco (`c:\Ficheros\SEPA\file*`)

El script tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```bat
echo ################################################################################
echo SCRIPT DE USUARIO PREVIO A EMISION: %0.
timestamp

if not exist "%FENTORNO%" (
    echo Error, no existe el path %FENTORNO%
    exit -1
)
call %FENTORNO% getParametros "PRV" %*

echo PRESENTACION : %SENTIDO%-%SESION% (%LOCAL%-%REMOTO%-%APLICACION%)
echo RESULTADO    : %RESULTADO%
echo ################################################################################
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RESULTADO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

* Se definen las variables necesarias, se comprueba que el directorio de emisión definido en Editran/G tiene el metacarácter `*` obligatorio y se ejecuta Editran/SEPA por cada fichero que encuentra en el directorio de emisión definido en el apartado Ficheros de Editran/G.

Si el fichero original tiene la extensión `.xml` Editran/SEPA lo convertirá a un fichero plano; si no tiene extensión `.xml` lo convertirá a un fichero con formato XML, ya que por defecto utiliza el modo de uso del comando con un solo parámetro, como se explica en [4.2 Proceso cliente](#42-proceso-cliente).

```bat
if not exist "%DIR_SEPA%" (
    echo Error, no existe el path %DIR_SEPA%
    exit -1
)
set CLASSPATH=
set DIR_ORIG=orig
set ARCHIVOS_ORIG=%LOCAL%-%REMOTO%-%APLICACION%-%SENTIDO%.orig
set FLISTA=%LOCAL%-%REMOTO%-%APLICACION%-%SENTIDO%.list

goto Inicio

:Inicio
IF NOT "%RESULTADO%"=="0000" goto Fin

FOR %%f in ("%DIR_SEPA:"=%\lib\*.jar") do CALL :Entorno "%%f"
FOR %%f in ("%DIR_SEPA:"=%\lib\Win\*.jar") do CALL :Entorno "%%f"
GOTO Start

:Entorno
set CLASSPATH=%~1;%CLASSPATH%
GOTO:EOF
:Start
rem Se extrae el path de los ficheros a emitir, previamente definido con la máscara * en la
rem presentación de EDItran/G
cfgupt -r -i%SESION% | find "NOMBRE FICHERO" > %FLISTA%

FOR /F "tokens=2 delims='='" %%p IN (%FLISTA%) DO call :Check "%%p"
goto Correcto

:Check
set DIR_FILES=%~1
IF "%DIR_FILES:~-1%" == " " (
 set DIR_FILES="%DIR_FILES:~0,-1%"
)
set DIR_FILES=%DIR_FILES:"=%
IF "%DIR_FILES:~0, 1%" == " " (
 set DIR_FILES="%DIR_FILES:~1%"
)
set DIR_FILES=%DIR_FILES:"=%
set AST=%DIR_FILES:~-1%

IF %AST% == * (
 GOTO Pathctl
) ELSE (
 echo La ruta de los ficheros de emision de Editran/G debe finalizar con la mascara *.
 GOTO badpath
)

:Pathctl
FOR %%f IN ("%DIR_FILES%") DO call :Sepa "%%f"
goto:EOF

:Sepa
rem Se guarda el nombre de los ficheros a convertir en un fichero auxiliar llamado orig.
echo %~1>>"%ARCHIVOS_ORIG%"
set DIRAUX= %cd%
cd %DIR_SEPA%

rem Descomentar las lineas inferiores si los ficheros de entrada de formato plano no son de
rem longitud fija
rem set FILE=%~1
rem IF NOT %FILE:~-4% == .xml IF NOT %FILE:~-4% == .XML (
rem call "%DIR_SEPA%/scripts/Win/utils/RellenaLineas.bat" %1 600
rem IF EXIST "%FILE%.old" (
rem   del "%FILE%.old"
rem )
rem )
rem set FILE=

rem Se ejecuta EDITRAN/SEPA por cada fichero a convertir y enviar.
%JAVASEPA% -cp "%CLASSPATH%" %EDITRAN_XMLMAIN% "%~1" > NUL
IF NOT %ERRORLEVEL% == 0 (
 IF NOT %ERRORLEVEL% == 36 (
  echo Fallo al convertir el fichero %1
  echo Error=%ERRORLEVEL%
  goto Error
 ) ELSE (
  echo Conversion SEPA del fichero %~1 finalizada con warnings.
 )
)
cd %DIRAUX%
goto:EOF
```

* Si ninguna de las conversiones realizadas sobre los ficheros a emitir termina con resultado de error, se mueven los ficheros originales a un subdirectorio histórico llamado `orig`.

```bat
:Correcto
IF NOT EXIST %ARCHIVOS_ORIG% (
 echo No hay ficheros a convertir
 GOTO Fin
)

findstr /I /M ".xml" "%ARCHIVOS_ORIG%" > NUL

IF %errorlevel%==0 (
echo Conversion SEPA XML a plano correcta.
) ELSE (
echo Conversion SEPA plano a XML correcta.
)
for /F "delims=';'" %%p IN ("%ARCHIVOS_ORIG%") do call :Move "%%p"
goto Fin
```

* Si por el contrario, alguna/s de las conversiones realizadas a partir de los ficheros a emitir finaliza con error, se eliminan los ficheros convertidos correctamente (si los hubiera) y se detiene el envío de la presentación, dejando los ficheros originales de envío como estaban para su posterior revisión.

```bat
:Error
rem Si ha habido error se notifica en el editrang.out, se borran todos los ficheros
rem convertidos y se detiene el batch.
cd %DIRAUX%
echo Conversion SEPA incorrecta.
for /F "delims=';'" %%p IN (%ARCHIVOS_ORIG%) do call :Delete "%%p"
IF EXIST %ARCHIVOS_ORIG% del %ARCHIVOS_ORIG%
IF EXIST %SESION%.emision del %SESION%.emision
exit -1
```

El script Posterior a Emisión que hace que se muevan los ficheros convertidos y enviados correctamente se llama `PSTEMISEPA.bat`.

Para poder utilizar dicho batch hay que definir `.\SEPA\PSTEMISEPA.bat` en el apartado "Posterior a emisión" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

El script tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```bat
echo ################################################################################
echo SCRIPT DE USUARIO POSTERIOR A EMISION: %0.
timestamp

if not exist "%FENTORNO%" (
echo Error, no existe el path %FENTORNO%
exit -1
)
call %FENTORNO% getParametros "PST" %*

echo PRESENTACION : %SENTIDO%-%SESION% (%LOCAL%-%REMOTO%-%APLICACION%)
echo FICHEROS     : %LFICHEROS%
echo RESULTADO    : %RESULTADO%
echo ################################################################################
goto Inicio
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RESULTADO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

* Se obtiene la lista de ficheros emitidos correctamente del fichero `.ficheros` del directorio de los tampones de Editran y se mueven a un directorio llamado "conv".

```bat
:Inicio
IF NOT "%RESULTADO%"=="0000" goto Fin

set ARCHIVOS_CONV=conv
set LFICHEROS=%LFICHEROS:/=\%
set LFICHEROS=%LFICHEROS:\\=\%
set FICH_TRATANDO=""
set FICH_ANTERIOR=""

setlocal enabledelayedexpansion
for /F "tokens=1 usebackq delims=," %%p in (%LFICHEROS%) do (
if "%%p" NEQ !FICH_ANTERIOR! (
set FICH_ANTERIOR="%%p"
call :Move "%%p"
)
)
endlocal

goto Fin

:Move
for %%i in (%1) do set DIRECTORY=%%~dpi
set DIRECTORY=%DIRECTORY%%ARCHIVOS_CONV%
IF NOT EXIST "%DIRECTORY%" mkdir "%DIRECTORY%"
MOVE /Y "%~1" "%DIRECTORY%" > NUL
goto:EOF

:Fin
set ARCHIVOS_CONV=
set DIRECTORY=
set DIR_SEPA=
set VARIOS_LOGICOS=
set CONLOG4J=
set EDITRAN_XMLMAIN=
set SESION=
set SENTIDO=
set LOCAL=
set REMOTO=
set APLICACION=
set RESULTADO=
set LFICHEROS=
exit 0
```

El script Posterior a Recepción que hace que se ejecute Editran/SEPA en una presentación de recepción se llama `PSTRECSEPA.bat`.

Para poder utilizar dicho batch hay que definir `.\SEPA\PSTRECSEPA.bat` en el apartado "Posterior a recepción" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

> **IMPORTANTE:** Es recomendable definir el directorio de recepción con la opción `%o` para recibir los ficheros con el nombre con el que los envía el remoto.
>
> Si al recibir ficheros la conversión deseada es de XML a Plano, es necesario definir en el directorio de recepción que el fichero a descargar contenga extensión `.xml`, ya que el batch PSTRECSEPA por defecto utiliza el modo de uso del comando con un solo parámetro, como se explica en [4.2 Proceso cliente](#42-proceso-cliente). Con la opción `%o` se reciben los ficheros con el nombre con el que los envía el remoto, si éste los envía con la extensión `.xml` no habrá que realizar ninguna configuración; al contrario, si el remoto no incluye la extensión, habría que definir el parámetro `%o` con la extensión `.xml` al final.

También se puede hacer uso de otras variables, consulte el manual de Editran/G.

Por ejemplo, para recibir los ficheros en el directorio `c:\Ficheros\recepcion\`, en el apartado Ficheros de Editran/G habrá que definir: `c:\Ficheros\recepcion\%o`. Si la conversión es de XML a Plano y el remoto no incluye la extensión al emitir, habría que definir la ruta `c:\Ficheros\recepcion\%o.xml`

El batch tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```bat
echo ################################################################################
echo SCRIPT DE USUARIO POSTERIOR A RECEPCION: %0.
timestamp

if not exist "%FENTORNO%" (
echo Error, no existe el path %FENTORNO%
exit -1
)

call %FENTORNO% getParametros "PST" %*

echo PRESENTACION : %SENTIDO%-%SESION% (%LOCAL%-%REMOTO%-%APLICACION%)
echo FICHEROS     : %LFICHEROS%
echo RESULTADO    : %RESULTADO%
echo ################################################################################
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RESULTADO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

Se definen las variables necesarias y se ejecuta Editran/SEPA por cada fichero que se recibe. Si el fichero original tiene la extensión `.xml` Editran/SEPA lo convertirá a un fichero plano; si no tiene extensión `.xml` lo convertirá a un fichero con formato XML.

```bat
if not exist "%DIR_SEPA%" (
echo Error, no existe el path %DIR_SEPA%
exit -1
)
set CLASSPATH=
set DIR_ORIG=orig
set ARCHIVOS_ORIG=%LOCAL%-%REMOTO%-%APLICACION%-%SENTIDO%.orig

goto Inicio

:Inicio
IF NOT "%RESULTADO%"=="0000" goto Fin

set LFICHEROS=%LFICHEROS:/=\%
set LFICHEROS=%LFICHEROS:\\=\%
set FICH_TRATANDO=""
set FICH_ANTERIOR=""
set INI_MSG=""

FOR %%f in ("%DIR_SEPA:"=%\lib\*.jar") do CALL :Entorno "%%f"
FOR %%f in ("%DIR_SEPA:"=%\lib\Win\*.jar") do CALL :Entorno "%%f"
GOTO Start

:Entorno
set CLASSPATH=%~1;%CLASSPATH%
GOTO:EOF

:Start
setlocal enabledelayedexpansion
for /F "tokens=1 usebackq delims=," %%p in (%LFICHEROS%) do (
if "%%p" NEQ !FICH_ANTERIOR! (
set FICH_TRATANDO="%%p"
rem Segun la extensión, el principio del mensaje de salida es uno u otro
findstr /I /M ".xml" !FICH_TRATANDO! > NUL
if !errorlevel!==0 (
set INI_MSG=Conversion SEPA XML a plano del fichero !FICH_TRATANDO!
) else (
set INI_MSG=Conversion SEPA plano a XML del fichero !FICH_TRATANDO!
)

call :Sepa !FICH_TRATANDO!
set FICH_ANTERIOR=!FICH_TRATANDO!
)
)
endlocal

goto Correcto

:Sepa
echo %~1>>%ARCHIVOS_ORIG%
set DIRAUX= "%cd%"
cd "%DIR_SEPA%"
%JAVASEPA% -cp "%CLASSPATH%" %EDITRAN_XMLMAIN% "%~1" > NUL
IF NOT %ERRORLEVEL% == 0 (
IF %ERRORLEVEL% == 36 (
echo %INI_MSG% finalizada con Warnings.
) ELSE (
echo %INI_MSG% finalizada con error.
echo Error=%ERRORLEVEL%
goto Error
)
) ELSE (
echo !INI_MSG! correcta.
)
cd %DIRAUX%

rem Descomentar las lineas inferiores si se quiere que, para ficheros de salida de formato plano,
rem se escriba un salto de linea al final de cada registro
rem set NL=%~1
rem IF %NL:~-4% == .xml nl -600 -in -od "%NL:.xml=%"
rem IF EXIST "%NL:.xml=%.old" del "%NL:.xml=%.old"
rem IF %NL:~-4% == .XML nl -600 -in -od "%NL:.XML=%"
rem IF EXIST "%NL:.XML=%.old" del "%NL:.XML=%.old"

goto:EOF
```

* Si ninguna de las conversiones realizadas sobre los ficheros a recibir termina con resultado de error, se moverán los ficheros originales a un subdirectorio histórico llamado `orig`.

```bat
:Correcto
findstr /I /M ".xml" %ARCHIVOS_ORIG% > NUL

IF %errorlevel%==0 (
echo Conversion SEPA XML a plano correcta.
) ELSE (
echo Conversion SEPA plano a XML correcta.
)
for /F "delims=';'" %%p IN (%ARCHIVOS_ORIG%) do call :Move "%%p"
goto Fin
```

* Si alguna de las conversiones realizadas a partir de los ficheros a recibir termina con error el script lo indicará en su resultado. En esta situación por defecto se eliminarán los ficheros convertidos correctamente, si los hubiera, dejando como estaban los ficheros originales de recepción para su posterior revisión.

```bat
:Error
echo Conversion SEPA incorrecta.
cd %DIRAUX%
for /F "delims=';'" %%p IN ('type "%ARCHIVOS_ORIG:"=%"') do call :Delete "%%p"
IF EXIST "%ARCHIVOS_ORIG:"=%" del "%ARCHIVOS_ORIG:"=%"
exit -1

:Delete
set BORRAR=%~1
IF %BORRAR:~-4% == .xml IF EXIST "%BORRAR:.xml=%" del "%BORRAR:.xml=%"
IF %BORRAR:~-4% == .XML IF EXIST "%BORRAR:.XML=%" del "%BORRAR:.XML=%"
IF NOT %BORRAR:~-4% == .xml IF NOT %BORRAR:~-4% == .XML IF EXIST "%BORRAR%.xml" del
"%BORRAR%.xml"
goto:EOF
```

### 4.4.2 UNIX

El script Previo a emisión que hace que se ejecute Editran/SEPA en una presentación de emisión se llama `PRVEMISEPA.sh`.

Para poder utilizar dicho script hay que definir `./SEPA/PRVEMISEPA.sh` en el apartado "Previo a emisión" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

> **IMPORTANTE:** Es necesario definir en el directorio de emisión con el metacaracter `*` al final de la ruta, y además no se pueden utilizar rutas relativas (`../`, `./`, etc.)

Por ejemplo, si los ficheros están en el directorio `/opt/ficheros/SEPA/`, en el apartado Ficheros de Editran/G habrá que definir: `/opt/ficheros/SEPA/*`.

También se puede definir un nombre común para los ficheros a emitir y al final definir el asterisco (`/opt/ficheros/SEPA/file*`)

El script tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```sh
# -----------------------------------------------------------
#                         Funciones
# -----------------------------------------------------------
function escribeCabecera()
{   echo "################################################################################"
    echo SCRIPT DE USUARIO PREVIO A EMISION: $0.
    echo "`date`"
}

function escribeParametros()
{   echo "PRESENTACION : $SENTIDO-$SESION ($LOCAL-$REMOTO-$APLICACION)"
    echo "RETORNO      : $RETORNO"
    echo "################################################################################"
}

function borrarFichTrabajo()
{
    [ -f "$ARCHIVOS_ORIG" ] && rm "$ARCHIVOS_ORIG"
    [ -f "$FLISTA" ] && rm "$FLISTA"
}

function borrarFichConvertidos()
{ [ ! -f "${ARCHIVOS_ORIG}" ] && return

    while read fichConv
    do
        #Borrar archivos convertidos
        case "${fichConv}" in
            *.xml|*.XML)
                fsinExtension=${fichConv%????}
                if [ -f "${fsinExtension}" ]; then
                     rm "${fsinExtension}"
                fi;;
            *)
                if [ -f "${fichConv}".xml ]; then
                     rm "${fichConv}".xml
                fi;;
        esac
    done < "${ARCHIVOS_ORIG}"
}

function moverFichOriginales()
{ [ ! -f "${ARCHIVOS_ORIG}" ] && return

    while read fichOrig
    do
        directory=`dirname "${fichOrig}"`/"${DIR_ORIG}"
        if [ ! -d "${directory}" ]; then
            mkdir -p "${directory}"
        fi
        if [ -f "${fichOrig}" ]; then
            mv "${fichOrig}" "${directory}"
        fi
    done < "${ARCHIVOS_ORIG}"
}

function mensajeResultado()
{
    if [ ! -f "${ARCHIVOS_ORIG}" ]; then
        echo "No hay archivos a convertir"
        exit 0
    fi

     case `head -1 "${ARCHIVOS_ORIG}"` in
         *.xml|*.XML)
             echo "Conversion SEPA XML a plano correcta."
             ;;
         *)
             echo "Conversion SEPA plano a XML correcta."
             ;;
     esac
}

# -----------------------------------------------------------
#                         MAIN
# -----------------------------------------------------------
SALIDA=0
CLASSPATH=
DIR_ORIG=orig

# Escribe la cabecera del script ############################
escribeCabecera

# Valida las variables de entorno
validaEntorno && echo "Error validaEntorno" && exit 1

# Transforma los parámetros de entrada en parámetros Editran
getParametrosEditran "PRV" "$@"
[ $? -ne 0 ] && echo "Error getParametrosEditran" "PRV" "$@" && exit 1

# Escribe los parámetros Editran ############################
escribeParametros
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RETORNO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

Se definen las variables necesarias, se comprueba que el directorio de emisión definido en Editran/G tiene el metacarácter `*` obligatorio y se ejecuta Editran/SEPA por cada fichero que encuentra en el directorio de emisión definido en el apartado Ficheros de Editran/G.

Si el fichero original tiene la extensión `.xml` Editran/SEPA lo convertirá a un fichero plano; si no tiene extensión `.xml` lo convertirá a un fichero con formato XML, ya que por defecto utiliza el modo de uso del comando con un solo parámetro, como se explica en 4.2 Proceso cliente.

Si ninguna de las conversiones realizadas sobre los ficheros a emitir termina con resultado de error se moverán los ficheros originales a un subdirectorio histórico llamado `orig`.

Si, por el contrario, alguna/s de esas conversiones finaliza con error, se eliminan los ficheros convertidos correctamente, si los hubiera, y se detiene el envío de la presentación, dejando los ficheros originales de envío como estaban para su posterior revisión.

Si el directorio de emisión definido en Editran/G no tiene el metacarácter `*` obligatorio el proceso se detiene. Si hubiera algún fichero convertido, se borraría:

```sh
# Si RETORNO no es 0 salir ##################################
if [ "${RETORNO}" != "0000" ]; then
  exit 0
fi

# Ficheros de trabajo #######################################
ARCHIVOS_ORIG=$LOCAL-$REMOTO-$APLICACION-$SENTIDO.orig
FLISTA=$LOCAL-$REMOTO-$APLICACION-$SENTIDO.list
borrarFichTrabajo

# Librerias SEPA ############################################
for f in ${DIR_LIB_SEPA}/*.jar; do
  CLASSPATH=${f}:${CLASSPATH}
done

for f in ${DIR_LIB_SEPA_SO}/*.jar; do
  CLASSPATH=${f}:${CLASSPATH}
done

# Obtenemos los ficheros a convertir ########################
# Se extrae el path de los ficheros a emitir, previamente definido en la presentacion de EDItran/G
cfgupt -r -i$SESION | grep "NOMBRE FICHERO" | cut -d"=" -f2 | sed 's/^ *//' > $FLISTA

while read fich
do
    case "${fich}" in
        */"*")
            fbuscar="${fich%??}"
            for fichconvert in "${fbuscar}"/*
            do
                if [ -f "${fichconvert}" ] ; then
                    echo "${fichconvert}" >> $ARCHIVOS_ORIG

                    diraux=${PWD}
                    cd "${DIR_SEPA}"
                    java -Dlog4j.configurationFile="conf/log4j2.properties" -cp ${CLASSPATH} \
$EDITRAN_XMLMAIN "${fichconvert}" 2>&1 > ${LOGOUT}
                    error=$?
                    cd "${diraux}"

                             if [ ${error} -ne 0 ]; then
                                 if [ ${error} -ne 36 ]; then
                                     echo "Fallo al convertir el fichero ${fichconvert}"
                                     echo "Error=${error}"
                                     echo "Conversion SEPA incorrecta"

                                      SALIDA=1
                                      break
                                  else
                                    echo "Conversion SEPA del fichero ${fichconvert} con warnings"
                                  fi
                             fi
                    fi
                done;;
           *)
                echo "Debe definir una máscara * en la ruta de los ficheros de emision de EDITRAN/G."

                SALIDA=1
                break
    esac
done < "$FLISTA"

# Conversion con errores ####################################
if [ $SALIDA -ne 0 ]; then
    echo "Salida con error"
    borrarFichConvertidos
    borrarFichTrabajo
    exit $SALIDA
fi

# Conversion correcta #######################################
mensajeResultado
moverFichOriginales
borrarFichTrabajo

# Terminar ##################################################
exit $SALIDA
```

El script Posterior a Emisión que hace que se muevan los ficheros convertidos y enviados correctamente se llama `PSTEMISEPA.sh`.

Para poder utilizar dicho script hay que definir `./SEPA/PSTEMISEPA.sh` en el apartado "Posterior a emisión" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

El script tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```sh
# -----------------------------------------------------------
#                         Funciones
# -----------------------------------------------------------
function escribeCabecera()
{   echo "################################################################################"
    echo SCRIPT DE USUARIO POSTERIOR A EMISION: $0.
    echo "`date`"
}

function escribeParametros()
{   echo "PRESENTACION : $SENTIDO-$SESION ($LOCAL-$REMOTO-$APLICACION)"
    echo "FICHEROS     : $FLIST"
    echo "RETORNO      : $RETORNO"
    echo "################################################################################"
}

# -----------------------------------------------------------
#                         MAIN
# -----------------------------------------------------------
# Escribe la cabecera del script ############################
escribeCabecera

# Valida las variables de entorno ###########################
validaEntorno && echo "Error validaEntorno" && exit 1

# Transforma los parámetros de entrada en parámetros Editran
getParametrosEditran "PST" "$@"
[ $? -ne 0 ] && echo "Error getParametrosEditran" "PST" "$@" && exit 1

# Escribe los parámetros Editran ############################
escribeParametros
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RETORNO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

* Se obtiene la lista de ficheros emitidos correctamente del fichero `.ficheros` del directorio de los tampones de Editran y se mueven a un directorio llamado "conv".

```sh
# Si RETORNO no es 0 salir ##################################
if [ "${RETORNO}" != "0000" ]; then
  exit 0
fi

# Variables de trabajo ######################################
DIR_CONV=conv
FICH_ANTERIOR=""

# Mueve los ficheros convertidos ############################
awk -F',' '{if ($1 != "") print $1}' "${FLIST}" | while read fileconv
do
    if [ -f "${fileconv}" ] && [ "${fileconv}" != "${FICH_ANTERIOR}" ]; then
        FICH_ANTERIOR="${fileconv}"

           directory=`dirname "${fileconv}"`/"${DIR_CONV}"

           if [ ! -d "${directory}" ]; then
               mkdir -p "${directory}"
           fi

           mv "${fileconv}" "${directory}"
    fi
done
```

El script Posterior a Recepción que hace que se ejecute Editran/SEPA en una presentación de recepción se llama `PSTRECSEPA.sh`.

Para poder utilizar dicho script hay que definir `./SEPA/PSTRECSEPA.sh` en el apartado "Posterior a recepción" de la opción "Aplicación" de la presentación de Editran/G que enviará ficheros SEPA.

> **IMPORTANTE:** Es recomendable definir el directorio de recepción con la opción `%o` para recibir los ficheros con el nombre con el que los envía el remoto.
>
> Si al recibir ficheros la conversión deseada es de XML a Plano, es necesario definir en el directorio de recepción que el fichero a descargar contenga extensión `.xml`, ya que el batch PSTRECSEPA por defecto utiliza el modo de uso del comando con un solo parámetro, como se explica en [4.2 Proceso cliente](#42-proceso-cliente). Con la opción `%o` se reciben los ficheros con el nombre con el que los envía el remoto, si éste los envía con la extensión `.xml` no habrá que realizar ninguna configuración; al contrario, si el remoto no incluye la extensión, habría que definir el parámetro `%o` con la extensión `.xml` al final.

También se puede hacer uso de otras variables, consulte el manual de Editran/G.

Por ejemplo, para recibir los ficheros en el directorio `/opt/ficheros/recepción/`, en el apartado Ficheros de Editran/G habrá que definir: `/opt/ficheros/recepción/%o`. Si la conversión es de XML a Plano y el remoto no incluye la extensión al emitir, habría que definir la ruta `/opt/ficheros/recepción/%o.xml`.

El script tiene los siguientes pasos:

* Registra en el fichero de salida de Editran/G (`editrang.out`) la información general del resultado de la transmisión:

```sh
# -----------------------------------------------------------
#                         Funciones
# -----------------------------------------------------------
function escribeCabecera()
{   echo "################################################################################"
    echo SCRIPT DE USUARIO POSTERIOR A RECEPCION: $0.
    echo "`date`"
}

function escribeParametros()
{   echo "PRESENTACION : $SENTIDO-$SESION ($LOCAL-$REMOTO-$APLICACION)"
    echo "FICHEROS     : $FLIST"
    echo "RETORNO      : $RETORNO"
    echo "################################################################################"
}

function borrarFichTrabajo()
{
    [ -f "$ARCHIVOS_ORIG" ] && rm "$ARCHIVOS_ORIG"
}

function borrarFichConvertidos()
{ [ ! -f "${ARCHIVOS_ORIG}" ] && return

    while read fichConv
    do
        #Borrar archivos convertidos
        case "${fichConv}" in
            *.xml|*.XML)
                fsinExtension=${fichConv%????}
                if [ -f "${fsinExtension}" ]; then
                     rm "${fsinExtension}"
                fi;;
                *)
                        if [ -f "${fichConv}".xml ]; then
                             rm "${fichConv}".xml
                        fi;;
        esac
    done < "${ARCHIVOS_ORIG}"
}

function moverFichOriginales()
{ [ ! -f "${ARCHIVOS_ORIG}" ] && return

    while read fichOrig
    do
        directory=`dirname "${fichOrig}"`/"${DIR_ORIG}"
        if [ ! -d "${directory}" ]; then
            mkdir -p "${directory}"
        fi
        if [ -f "${fichOrig}" ]; then
            mv "${fichOrig}" "${directory}"
        fi
    done < "${ARCHIVOS_ORIG}"
}

function mensajeResultado()
{
    if [ ! -f "${ARCHIVOS_ORIG}" ]; then
        echo "No hay archivos a convertir"
        exit 0
    fi

      case `head -1 "${ARCHIVOS_ORIG}"` in
          *.xml|*.XML)
              echo "Conversion SEPA XML a plano correcta."
              ;;
          *)
              echo "Conversion SEPA plano a XML correcta."
              ;;
      esac
}

# -----------------------------------------------------------
#                         MAIN
# -----------------------------------------------------------
SALIDA=0
CLASSPATH=
DIR_ORIG=orig

# Escribe la cabecera del script ############################
escribeCabecera

# Valida las variables de entorno ###########################
validaEntorno && echo "Error validaEntorno" && exit 1

# Transforma los parámetros de entrada en parámetros Editran
getParametrosEditran "PST" "$@"
[ $? -ne 0 ] && echo "Error getParametrosEditran" "PST" "$@" && exit 1

# Escribe los parámetros Editran ############################
escribeParametros
```

Donde SESION es el nombre de la presentación, SENTIDO es el sentido de la transmisión (E (Emisión) o R (Recepción)), RETORNO es el resultado de la transmisión, LOCAL es el código local, REMOTO el código remoto y APLICACIÓN la aplicación de la presentación.

Se definen las variables necesarias y se ejecuta Editran/SEPA por cada fichero que se recibe. Si el fichero original tiene la extensión `.xml` Editran/SEPA lo convertirá a un fichero plano; si no tiene extensión `.xml` lo convertirá a un fichero con formato XML.

Si ninguna de las conversiones realizadas sobre los ficheros a recibir termina con error se moverán los ficheros originales a un subdirectorio histórico llamado `orig`.

Si, por el contrario, alguna/de dichas conversiones termina con error, se eliminarán los ficheros convertidos correctamente, si los hubiera, y el script devolverá el correspondiente resultado, dejándose como estaban los ficheros originales de recepción para su posterior revisión.

```sh
# Si RETORNO no es 0 salir ##################################
if [ "${RETORNO}" != "0000" ]; then
  exit 0
fi

# Ficheros de trabajo #######################################
ARCHIVOS_ORIG=$LOCAL-$REMOTO-$APLICACION-$SENTIDO.orig
FICH_ANTERIOR=""
borrarFichTrabajo

# Librerias SEPA ############################################
for f in ${DIR_LIB_SEPA}/*.jar; do
    CLASSPATH=${f}:${CLASSPATH}
done

for f in ${DIR_LIB_SEPA_SO}/*.jar; do
    CLASSPATH=${f}:${CLASSPATH}
done

# Obtenemos los ficheros a convertir ########################
awk -F',' '{if ($1 != "") print $1}' "${FLIST}" | while read fich
do
    if [ -f "${fich}" ] && [ "${fich}" != "${FICH_ANTERIOR}" ]; then
        FICH_ANTERIOR="${fich}"
        echo "${fich}" >> $ARCHIVOS_ORIG

        diraux=${PWD}
        cd "${DIR_SEPA}"
        java -Dlog4j.configurationFile="conf/log4j2.properties" -cp ${CLASSPATH} $EDITRAN_XMLMAIN \
"${fich}" 2>&1 > ${LOGOUT}
        error=$?
        cd "${diraux}"

           if [ ${error} -ne 0 ]; then
               if [ ${error} -ne 36 ]; then
                   echo "Fallo al convertir el fichero ${fich}"
                   echo "Error=${error}"
                   echo "Conversion SEPA incorrecta"

                    # Sale del bucle read, no del script
                    exit 1
                else
                    echo "Conversion SEPA del fichero ${fich} con warnings"
                fi
        fi
    fi
done
SALIDA=$?

# Conversion con errores ####################################
if [ $SALIDA -ne 0 ]; then
    echo "Salida con error"
    borrarFichConvertidos
    borrarFichTrabajo
    exit $SALIDA
fi

# Conversion correcta #######################################
mensajeResultado
moverFichOriginales
borrarFichTrabajo

# Terminar ##################################################
exit $SALIDA
```

### 4.4.3 Tratamiento de ficheros con Warnings

Por defecto, así están programados los scripts que se adjuntan con la instalación, los ficheros planos obtenidos de una conversión que quedan incompletos (el resultado de la conversión será de Warning) serán considerados por Editran/SEPA como correctos y por tanto serán enviados. Esta situación ocurre cuando el fichero que se va a convertir es XML y no contiene datos opcionales según ese formato que sin embargo son obligatorios para la norma del formato plano a la que se convierte.

Para modificar dicho comportamiento y dar por inválidos dichos ficheros, se realizará el siguiente cambio en `PRVEMISEPA` y en `PSTRECSEPA`:

**Windows:**

Modificamos:

```bat
IF NOT %ERRORLEVEL% == 0 (
 IF NOT %ERRORLEVEL% == 36 (
  echo Fallo al convertir el fichero %1
  echo Error=%ERRORLEVEL%
  goto Error
 )
)
```

Por:

```bat
IF NOT %ERRORLEVEL% == 0 (
   echo Fallo al convertir el fichero %1
   echo Error=%ERRORLEVEL%
   goto Error
)
```

**UNIX:**

Modificamos:

```sh
if [ ${error} -ne 0 -ne 36 ]; then
 echo "Fallo al convertir el fichero ${fichconvert}"
```

Por:

```sh
if [ ${error} -ne 0 ]; then
 echo "Fallo al convertir el fichero ${fichconvert}"
```

### 4.4.4 Uso de Onesait Ecosystems · Editran/SEPA en transmisiones de emisión de Onesait Ecosystems · Editran

Cuando se utiliza el conversor SEPA junto con Editran, además de implementar los procesos previo a emisión y posterior a recepción como se ha descrito en los apartados anteriores, se debe también configurar de manera adecuada el perfil de Editran/G de los Ficheros de emisión. La configuración es diferente según sea el tipo de fichero obtenido con la conversión. A continuación se detalla la manera de proceder en uno y otro caso.

* **XML → plano**: si el archivo inicial es XML, al pasar por el conversor SEPA se obtiene un fichero de formato plano que es el que se enviará. Por tanto, se definirá "Fijo" en el campo "Formato de ficheros", 600 como longitud de registro y ningún delimitador. El alfabeto será ASCII. La traducción ASCII/EBCDIC será necesaria si el remoto desea recibir el fichero plano en formato EBCDIC.

![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-e37ea27385ff1e7b42434d9a921ab7b21ad3f96d%2Fimage.avif?alt=media)

Ejemplo de configuración en Unix:

![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-60e0fea8a04b8b2b3744071bac82aa2584965362%2Fimage.avif2.avif?alt=media)

* **Plano → XML**: si el fichero inicial es plano, al pasar por el conversor SEPA se obtiene un fichero XML que obligatoriamente debe estar codificado en UTF-8. Así que este tipo de ficheros se enviará con formato binario, con alfabeto y delimitador "NINGUNO".

Ejemplo de configuración en Windows:

![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-98b6b1ea003eb2bafaee1d70ec97252d00c237d6%2Fimage.avif3.avif?alt=media)

Ejemplo de configuración en Unix:

![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-f613f5bcf694f31155d22bbb83e7d6d007090186%2Fimage.avif4.avif?alt=media)

Es posible enviar ficheros de ambos tipos, plano y XML, por una misma presentación de Editran. Para ello bastará con definir, desde Ficheros del Menú/G, los dos tipos de ficheros de emisión de la forma que se ha descrito.

En el siguiente ejemplo de Editran Windows se utilizan carpetas distintas para alojar los dos tipos de ficheros que se van a convertir y posteriormente enviar. Todos los documentos que se encuentren en el directorio "plano" se transformarán a XML y se enviarán en binario. Por su parte, todos aquellos que estén en el directorio "XML" se transformarán a plano y seguidamente se enviarán en formato fijo de longitud 600, sin delimitador y en lenguaje ASCII.

Ejemplo de configuración en Windows:

![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-8b62b58d103595def3c2a57dc8a1fc93148d4917%2Fimage.avif5.avif?alt=media)

Ejemplo de configuración en Unix: ![Foto](https://605131618-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYRsCBWELAyzw5mj5JFUW%2Fuploads%2Fgit-blob-d6b28777175e9c03cdddee1b27f5454950763eec%2Fimage.avif6.avif?alt=media)

### 4.4.5 Uso de Onesait Ecosystems · Editran/SEPA en transmisiones de recepción de Onesait Ecosystems · Editran

Por defecto, el proceso posterior a recepción está configurado para recibir los ficheros planos en el lenguaje de la máquina (ASCII en Windows y Unix) y en UTF-8 los ficheros XML. Por lo tanto, si los ficheros planos no se fueran a recibir en ASCII, el usuario deberá modificar dicho proceso. Para ello habrá que indicar, en los argumentos correspondientes de la llamada JAVA a Editran/SEPA, el alfabeto con el que se reciben (véase apartado [5 Configuración de Onesait Ecosystems · Editran/SEPA](#5-configuración-de-onesait-ecosystems--editransepa)).

## 4.5 Librería de Java

Las librerías de la carpeta `SEPA/lib` se pueden incluir en un proyecto Java independiente y utilizar los métodos de conversión de ficheros que implementa. Para ello se adjunta el JavaDoc de las clases públicas a las que llamar. En él se explica la funcionalidad de la librería. Típicamente son sólo necesarias la clase `Parámetros` para definir cada valor de la conversión y la clase `SepaParser`, llamada para convertir un fichero.

***


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.editran.onesait.com/documentacion-editran/editran-sepa-v3/modo-de-uso.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.