Como Gerar Scripts Groovy de Transformação com o R2-CX

Geração de Scripts Groovy com IA para Desenvolvedores de Integração

Escrever scripts Groovy de transformação é uma das tarefas mais demoradas em projetos de SAP CPI e integração empresarial. Mapeamento de campos, conversão de tipos de dados, tratamento de erros, verificações de nulos, transformações de moeda — cada script exige atenção cuidadosa aos detalhes e conhecimento profundo dos schemas de origem e destino.

O R2-CX elimina esse gargalo. Ao descrever a transformação que você precisa em linguagem natural, o R2-CX gera scripts Groovy completos e prontos para produção com tratamento adequado de erros, logging e documentação. Este guia percorre dois cenários reais: mapeamento de dados de Conta SAP C4C para formato canônico, e transformação de dados de Oportunidade com conversão de moeda para um dashboard de BI.

Pré-requisitos

Antes de começar, confirme que você tem:

Uma conta JedIN (tier Starter ou superior) com acesso ao R2-CX habilitado
Familiaridade com Groovy básico — entender closures, maps e manipulação de strings ajuda na revisão do código gerado
Um schema do sistema de destino — saiba quais campos são necessários na saída (formato canônico, schema do dashboard de BI, etc.)
Acesso ao JedIN Flow Designer ou SAP CPI — onde você fará deploy dos scripts gerados
Workspace do R2-CX aberto — com um sistema alvo selecionado (SAP CPI ou JedIN recomendado)

Passo 1: Abrir o Workspace do R2-CX

Faça login no JedIN e navegue pela barra lateral.
Clique em R2-CX para abrir o hub do R2-CX.
Selecione seu sistema alvo — para geração de scripts Groovy, escolha SAP CPI ou JedIN como alvo.
Clique em Workspace para entrar na interface de chat com IA.

Resultado Esperado: O workspace do R2-CX abre com o painel de chat à direita e o contexto do sistema carregado. O assistente de IA está pronto para receber comandos.

Passo 2: Gerar um Script de Transformação de Dados de Conta

Digite o seguinte prompt no chat do R2-CX:

Gere um script Groovy para transformar dados de Account do SAP C4C para formato canônico: mapear AccountName para company_name, AccountID para external_id, City para city, CountryCode para country_iso, adicionar source_system e timestamp

O R2-CX analisa a solicitação e gera um script Groovy completo. Aqui está o tipo de saída que você pode esperar:

import com.sap.gateway.ip.core.customdev.util.Message
import groovy.json.JsonSlurper
import groovy.json.JsonOutput
import java.time.Instant

/**
 * Transforma dados de Account do SAP C4C para formato canônico.
 *
 * Campos de origem (SAP C4C):
 *   - AccountName  -> company_name
 *   - AccountID    -> external_id
 *   - City         -> city
 *   - CountryCode  -> country_iso
 *
 * Campos adicionados:
 *   - source_system  = "SAP_C4C"
 *   - timestamp      = ISO-8601 UTC
 */
def Message processData(Message message) {
    def body = message.getBody(String)
    def jsonSlurper = new JsonSlurper()

    try {
        def input = jsonSlurper.parseText(body)
        def accounts = input instanceof List ? input : [input]

        def canonicalRecords = accounts.collect { account ->
            [
                company_name  : account.AccountName ?: "UNKNOWN",
                external_id   : account.AccountID ?: "",
                city          : account.City ?: "",
                country_iso   : account.CountryCode ?: "",
                source_system : "SAP_C4C",
                timestamp     : Instant.now().toString()
            ]
        }

        message.setBody(JsonOutput.prettyPrint(
            JsonOutput.toJson(canonicalRecords)
        ))
        message.setHeader("X-RecordCount", canonicalRecords.size().toString())
        message.setHeader("X-SourceSystem", "SAP_C4C")

    } catch (Exception e) {
        def errorPayload = [
            error      : true,
            message    : "Falha na transformação de Account: ${e.message}",
            timestamp  : Instant.now().toString(),
            original   : body?.take(500)
        ]
        message.setBody(JsonOutput.toJson(errorPayload))
        message.setHeader("X-TransformError", "true")
    }

    return message
}

Características principais do script gerado:

Mapeamento null-safe — cada campo usa o operador Elvis (?:) com um valor padrão adequado
Suporte a lotes — trata tanto objetos únicos quanto arrays
Tratamento de erros — o bloco catch preserva o payload original (truncado) para depuração
Headers de metadados — X-RecordCount e X-SourceSystem para roteamento downstream
Timestamps — formato ISO-8601 UTC usando java.time.Instant

Passo 3: Gerar uma Transformação de Oportunidade com Conversão de Moeda

Agora digite um prompt mais complexo:

Gere um script Groovy para mapear dados de Opportunity para dashboard de BI: receita em BRL para USD (dividir por 5.2), adicionar mapeamento de estágio do pipeline

O R2-CX gera uma transformação que inclui lógica de negócio:

import com.sap.gateway.ip.core.customdev.util.Message
import groovy.json.JsonSlurper
import groovy.json.JsonOutput
import java.time.Instant

/**
 * Transforma dados de Opportunity do SAP C4C para consumo em dashboard de BI.
 *
 * Conversões:
 *   - ExpectedRevenueAmount (BRL) -> revenue_usd (dividido pela taxa de câmbio)
 *   - SalesPhaseCode -> pipeline_stage (mapeamento legível)
 *
 * A taxa de câmbio é parametrizada via propriedade de mensagem.
 */
def Message processData(Message message) {
    def body = message.getBody(String)
    def jsonSlurper = new JsonSlurper()

    // Taxa de câmbio: usar propriedade se definida, padrão 5.2
    def exchangeRate = new BigDecimal(
        message.getProperty("BRL_USD_RATE") ?: "5.2"
    )

    // SAP C4C Sales Phase Code -> estágio legível
    def stageMapping = [
        "1" : "prospecção",
        "2" : "qualificação",
        "3" : "proposta",
        "4" : "negociação",
        "5" : "fechado_ganho",
        "6" : "fechado_perdido"
    ]

    try {
        def input = jsonSlurper.parseText(body)
        def opportunities = input instanceof List ? input : [input]

        def dashboardRecords = opportunities.collect { opp ->
            def revenueBrl = opp.ExpectedRevenueAmount != null
                ? new BigDecimal(opp.ExpectedRevenueAmount.toString())
                : BigDecimal.ZERO

            def revenueUsd = revenueBrl.divide(exchangeRate, 2,
                BigDecimal.ROUND_HALF_UP)

            def phaseCode = opp.SalesPhaseCode?.toString() ?: "0"
            def stageName = stageMapping[phaseCode] ?: "desconhecido"

            [
                opportunity_id   : opp.OpportunityID ?: "",
                opportunity_name : opp.Name ?: "",
                account_id       : opp.AccountID ?: "",
                revenue_brl      : revenueBrl.doubleValue(),
                revenue_usd      : revenueUsd.doubleValue(),
                exchange_rate    : exchangeRate.doubleValue(),
                pipeline_stage   : stageName,
                close_date       : opp.ExpectedCloseDate ?: "",
                owner            : opp.OwnerName ?: "",
                source_system    : "SAP_C4C",
                transformed_at   : Instant.now().toString()
            ]
        }

        message.setBody(JsonOutput.prettyPrint(
            JsonOutput.toJson(dashboardRecords)
        ))
        message.setHeader("X-RecordCount",
            dashboardRecords.size().toString())
        message.setHeader("X-ExchangeRate", exchangeRate.toString())

    } catch (Exception e) {
        def errorPayload = [
            error     : true,
            message   : "Falha na transformação de Opportunity: ${e.message}",
            timestamp : Instant.now().toString()
        ]
        message.setBody(JsonOutput.toJson(errorPayload))
        message.setHeader("X-TransformError", "true")
    }

    return message
}

Características principais deste script:

Taxa de câmbio parametrizada — lê BRL_USD_RATE das propriedades da mensagem, padrão 5.2
Precisão BigDecimal — evita erros de ponto flutuante na conversão de moeda
Mapeamento de estágios — traduz o SalesPhaseCode numérico do SAP C4C para estágios legíveis do pipeline
Saída pronta para BI — estrutura JSON plana com valores em BRL e USD mais a taxa aplicada

Passo 4: Refinar o Script Gerado

O R2-CX suporta refinamento iterativo. Você pode fazer perguntas de acompanhamento:

"Adicionar logging para cada registro processado" — o R2-CX adiciona def log = messageLogFactory.getMessageLog(message) com logging por registro
"Adicionar validação para rejeitar registros onde AccountName está vazio" — o R2-CX adiciona uma etapa de filtro antes do mapeamento
"Tornar o mapeamento de estágios configurável via propriedade externa" — o R2-CX lê uma propriedade JSON em vez de um mapa hardcoded
"Adicionar scaffolding de testes unitários" — o R2-CX gera uma classe de teste Spock ou JUnit com dados de entrada de exemplo

Cada refinamento preserva a estrutura existente e adiciona a funcionalidade solicitada de forma incremental.

Passo 5: Usar o Script no JedIN Flow Designer

Quando o script estiver pronto:

Abra o JedIN Flow Designer na barra lateral.
Crie ou abra um fluxo de integração.
Adicione um nó Script (Groovy) ao canvas do fluxo.
Cole o código Groovy gerado no editor de script.
Configure a conexão de entrada — tipicamente um receptor HTTP ou fonte OData.
Configure a conexão de saída — seu sistema de destino (banco de dados, API REST, armazenamento de arquivos).
Salve e faça deploy do fluxo.

Resultado Esperado: O fluxo executa com a transformação Groovy aplicada. Verifique o dashboard de monitoramento para confirmar contagens de registros e resultados da transformação.

Passo 6: Usar o Script no SAP CPI

Se você estiver fazendo deploy no SAP Cloud Platform Integration:

Abra seu tenant SAP CPI e navegue até o fluxo de integração.
Adicione uma etapa Groovy Script no pipeline de processamento de mensagens.
Cole o código gerado no editor de script.
Certifique-se de que o import Message corresponde à versão do runtime CPI.
Faça deploy e teste com um payload de exemplo.

Resultado Esperado: O script transforma mensagens no seu pipeline CPI de forma idêntica ao fluxo JedIN, pois o R2-CX gera assinaturas Message compatíveis com CPI por padrão.

Dicas para Prompts Melhores

A qualidade do script gerado depende da clareza do seu prompt. Aqui estão padrões que produzem os melhores resultados:

Padrão de Prompt	Exemplo
Especificar mapeamentos de campo explicitamente	"mapear AccountName para company_name, AccountID para external_id"
Indicar tipos de dados quando ambíguos	"receita como BigDecimal, não double"
Mencionar requisitos de tratamento de erros	"adicionar try/catch com payload original na resposta de erro"
Especificar comportamento de lote	"tratar tanto objeto único quanto entrada de array"
Incluir regras de negócio	"converter BRL para USD à taxa 5.2, arredondar para 2 decimais"
Solicitar headers ou propriedades	"definir header X-RecordCount com o número de registros processados"

Resultados Esperados

Após completar este guia, você terá:

Dois scripts Groovy de transformação prontos para produção gerados inteiramente por IA
Compreensão de como iterar e refinar scripts através de acompanhamentos em linguagem natural
Um fluxo de trabalho para mover scripts gerados pelo R2-CX para o JedIN Flow Designer ou SAP CPI
Confiança de que os scripts gerados incluem tratamento de erros, segurança contra nulos e headers de metadados

O R2-CX reduz o tempo de desenvolvimento de scripts Groovy de horas para minutos. Em vez de escrever código de mapeamento boilerplate manualmente, descreva a transformação que você precisa e deixe a IA cuidar dos detalhes de implementação. Concentre sua expertise em revisar a lógica e definir as regras de negócio — o R2-CX cuida do resto.