Contenido

1      Cloud Integration

2      Integration Flow

3      Script Collection

4      Consuming a Script Collection

1         Cloud Integration

SAP Cloud Integration favorece la integración de procesos comerciales que comprende diferentes empresas, organizaciones o departamentos dentro de una organización.

SAP Cloud Integration le facilita al usuario la conexión de aplicación locales y en la nube con otras aplicaciones existentes locales y en la nube de SAP, ya que este tipo de servicio procesa los mensajes en escenarios en tiempo real que abarcan diferentes empresas, organizaciones o departamentos dentro de una organización.

2         Integration Flow

Un flujo de integración es la base de cualquier proyecto de integración de datos ya que contiene funciones de automatización integradas que hacen que este proceso sea tan fácil que los usuarios comerciales no técnicos puedan crear flujos con el soporte de TI mínimo o nulo.

3         Script Collection

Los Script Collection son un artefacto reutilizable que se puede desarrollar e implementar de forma independiente, también podemos hacer referencia a ellos desde múltiples flujos de integración.

A veces, cuando necesitamos capacidades más allá de las funciones nativas de SAP Cloud Integration, podemos usar sus propios scripts personalizados en sus artefactos de integración. Por ejemplo, podemos usar secuencias de comandos para transformaciones complejas, manejar excepciones, leer o modificar encabezados en adaptadores.

Sabemos que SAP Cloud Integration admite diferentes lenguajes de secuencias de comandos como Groovy y JavaScript.

Script Collection es un artefacto en sí mismo que es un paquete de Scripts. Podemos crear una colección de scripts dentro de un paquete de integración para luego poder crear scripts en él con el propósito de reutilizar estos scripts en cualquier artefacto de integración dentro de este paquete.

Debemos tener en cuenta que los recursos admitidos son scripts de Groovy, JavaScript y archivos Jar.

4         Consuming a Script Collection

El consumo de una colección de scripts en un flujo de integración es un proceso de dos pasos. En el primer paso, creamos una referencia a la colección de scripts en su flujo de integración y el segundo paso asignamos un recurso de secuencia de comandos de la colección de secuencias de comandos a la que se hace referencia al paso de flujo de secuencia de comandos del flujo de integración.

Requisitos

Hay que tener en cuenta que para poder realizar este ejercicio se debe contar con una cuenta en SAP BTP Cockpit y con la suscripción de Integration Suite, tener creado un paquete de integración, un flujo de integración y una colección de Script en la plataforma de Cloud Integration.

Primero se debe acceder a un navegador e ingresar la siguiente URL dando clic aquí para ingresar a nuestra cuenta de SAP BTP Cockpit.

Para crear las credenciales de usuario, ingresamos a nuestra cuenta de BTP, luego a nuestra subcuenta y posteriormente a nuestra suscripción de Integration Suite.

Luego de ingresar a nuestro portal de Integration Suite, vamos al menú de principal y luego damos en Design – Integrations.

Luego debemos ingresar al apartado de “Design” en el menú izquierdo para poder seleccionar un paquete de integración.

Si deseas saber cómo crear un paquete de integración te invitamos a leer el siguiente artículo dando clic aquí.

Vamos a la pestaña de “Artifacts” debemos tener el script collection creado, si deseas saber cómo se crea puedes visitar el siguiente artículo dando clic aquí.

y luego en el botón de edición, se nos habilitarán unas opciones y damos en añadir, se nos desplegará una lista de artefactos que podemos agregar, seleccionamos Script Collection.

Luego de ingresar a nuestro Script Collections seleccionamos el recurso que tenemos en la colección y lo implementamos ya que este será el Script que usaremos.

Vamos a analizar un poco el script que tenemos en nuestra colección.

Lo primero que encontramos en el script es que en la primera línea nos importa las librerías de SAP y debe incluirse de manera obligatoria.

import com.sap.gateway.ip.core.customdev.util.Message;

    import java.util.HashMap;

También podemos importar más librerías ya sea de SAP o de Java. Además, se importan ocho librerías de forma automática

java.io.*,

java.lang.*,

java.math.BigDecimal,

java.math.BigInteger,

java.net.*,

java.util.*,

groovy.lang.* y groovy.util.*.

Después definimos la función processData, en el que le indicamos que nos va a devolver un objeto de la clase Message, y que va a aceptar un objeto de la clase Message.

def Message processData(Message message)

Esta es la función que se ejecuta por defecto, sin tener que indicarlo de forma explícita y Message hará referencia al mensaje que viene desde nuestro flujo de integración, el cuál podremos tanto leer como modificar.

Después hemos dividido la función en cuatro partes:

Body

El cuerpo del mensaje, lo obtenemos del cuerpo de la entrada, y lo añadimos a la salida agregando la palabra Body antes.

Utilizamos el método message.getBody(String) para obtener el cuerpo del mensaje. A continuación, hacemos uso de setBody para modificar el atributo que contiene el cuerpo del mensaje.

De esta forma, cuando el mensaje salga hacia el siguiente paso en el flujo de integración, llegará con la modificación. En este caso, solo le añadimos la palabra Body con el símbolo igual.

        def body = message.getBody(String);

        message.setBody(“Body = ” + body);

        println “Body: ” +body

Header

La cabecera del mensaje, primero obtenemos las cabeceras completas, después obtenemos el header1 y el header2 en dos variables y por último las añadimos al mensaje de salida, y para ver que se está modificando vamos a colocar el valor del header2 en el header1 y viceversa.

En ese caso estamos usando el método getHeaders(), que nos devuelve un objeto

        def map = message.getHeaders();

        def header1 = map.get(“header1”);

        def header2 = map.get(“header2”);

        message.setHeader(“header1”, header2);

        message.setHeader(“header2”, header1);

        println “headers: ” +header1 +” ” +header2;

Properties

Las propiedades del mensaje, hacemos lo mismo que con las cabeceras, intercambiando los valores.

        map = message.getProperties();

        property1 = map.get(“property1”);

        property2 = map.get(“property2”);

        message.setProperty(“property1”, property2);

        message.setProperty(“property2”, property1);

        println “properties: ” +property1 +” ” + property2;

Por último, tenemos el Log, también se obtiene del mensaje anterior, aunque en ese caso no tenemos log para añadir en la plataforma, por lo que vendrá vacío, pero sí vamos a usarlo, ya que es algo especialmente útil para los flujos de integración. Y en este caso tenemos los métodos setStringProperty, que nos deja añadir una propiedad o atributo al mensaje de logs, así como addAttachmentAsString, que nos permite añadir un adjunto con un texto.

      def messageLog = messageLogFactory.getMessageLog(message);

      if(messageLog != null)

        {

          messageLog.setStringProperty(“log1″,”Log Text”);

          messageLog.setStringProperty(“property1”, property1)

          messageLog.setStringProperty(“header1”, header1)

          messageLog.addAttachmentAsString(“log1”,body,”text

/plain”);

        }

      println “Log ok”;

Ya que hemos analizado nuestro script, vamos a realizar un ejemplo donde usaremos los elementos básicos de entrada y salida.

Para ello vamos a crear un flujo de integración, editamos nuestro paquete de integración, damos en “Add” y luego “Integration Flow”, aquí podemos crearlo desde cero o carga uno del ordenador. Para este caso damos en crear, asignamos el nombre Integration Flow_Groovy y luego damos al botón OK.

Entramos a nuestro flujo y agregamos, un evento de inicio, dos modificadores de contenido y un elemento de Groovy Script.

El evento Start Timer lo vamos a configurar para que inicie el procesamiento una vez implementemos el flujo.

Vamos al Content Modifer 1, seleccionamos y en sus propiedades vamos a la pestaña de Message Header agregamos dos header o cabeceras que tendrán los nombres “header 1” y “header 2”, con sus respectivos valores “First header” y “Second header” respectivamente, ambas cabeceras serán de tipo constante.

Luego vamos a la pestaña Exchange Property y agregamos dos propiedades repitiendo los pasos anteriores.

En resumen, estas serán los atributos que enviará nuestro Content Modifier 1, con sus respectivos valores.

header 1: First header

header 2: Second header

property 1: First property

property 2: Second property

Damos clic fuera de nuestro Integration Process para habilitar las propiedades del mismo. Vamos a la pestaña de Resources para añadir un nuestro recurso, luego a References y por último damos Add References para agregar nuestro Script Collection.

Se abre una ventana de referencias donde vamos a seleccionar el paquete de la referencia que es donde tenemos nuestro Script Collections, seleccionamos el artefacto que contiene nuestro Script y damos OK.

Seleccionamos nuestro elemento de transformación llamado Groovy Script para indicarle el Script que vamos a usar en nuestro procesamiento. Para ello vamos a la pestaña de procesamiento y luego al botón Select para buscar nuestro Script.

Tenemos una opción de Script Function, en caso de que tengamos funciones dentro nuestro script aquí indicaríamos la función que queremos se ejecute en el procesamiento.

En la ventana que se abre vamos a la pestaña de Referenced Resources para que nos muestro nuestros recursos de referencia, lo seleccionamos, nos indicará los scripts que están en dicho recurso, para este caso solo tenemos uno, pero podemos tener los que deseemos. Luego damos en el botón OK, con esto quedara agregado a nuestro proceso de integración.

En nuestro Content Modifier 2, vamos a indicar los parámetros que queremos obtener de nuestro procesamiento del mensaje y como queremos visualizarlos. Para ello vamos a la pestaña de Message Body para indicar el cuerpo de nuestro mensaje.

Aquí vamos a recuperar los valores que tienen nuestras cabeceras y propiedades luego de ser procesadas por nuestro script.

Para usar las expresiones debemos respetar la estructura iniciando con el signo peso $  e indicando la variable entre llaves { }, dentro vamos a indicar el atributo header o property, seguido del nombre que indicamos en el Content Modifier 1.

De esta manera ${header.header1} , lo que no sea expresión es el texto que va salir tal cual lo escribamos en el cuerpo, solo cambiaran los valores de las expresiones.

Guardamos nuestro flujo y lo implementamos.

Nota: Antes de implementar nuestro flujo de integración debemos verificar que nuestro Script Collections este implementado, si no, debemos hacerlo. Vamos al paquete de integración buscamos el artefacto y damos Deploy.

Implementado nuestro flujo de integración vamos al monitor y evidenciamos que ambos artefactos están inicializados (Script Collections e Integration Flow_Groovy). Vamos a nuestro flujo y en el Log de Configuración vamos a Log Level para seleccionar Trace ya que por defecto está en Info, este cambio nos va permitir ver durante una hora el paso a paso de nuestro procesamiento del mensaje.

Una vez seleccionado el Log Level Trace, regresamos a nuestro flujo de integración e implementamos nuevamente para que tome esta configuración del Log. Regresamos al monitor, seleccionamos el flujo y vamos al Monitor Message Processing.

En nuestro procesamiento de mensajes encontramos los procesos, uno con el Log Info y el otro con el Log Trace, seleccionamos el ultimo y vamos a Log Level para abrir el Trace.

Aquí vamos a visualizar todo el procesamiento del mensaje paso a paso. Vamos al evento de finalización de nuestro flujo de integración, luego al Message Content y damos en la pestaña de Payload para ver el contenido del mensaje de salida de nuestro flujo.

Aquí podemos con éxito que los vamos de nuestras cabeceras y propiedades han cambiado. Recordemos que el propósito de nuestro Script era cambiar los valores de los atributos creados asignando el valor del header1 al header2 y viceversa, de igual manera con las propiedades.

En este artículo aprenderemos a consumir un artefact Script Collection mediante un flujo de integración. Dirigido a todas las personas que quieran aprender más sobre las herramientas SAP Cloud Integration y como se integran las diferentes herramientas de SAP. Podrás encontrar más datos como estos en los cursos y blogs desarrollados por Logali Group.