Este blog cubre un script maravilloso para convertir elementos JSON anidados profundos de cadenas a tipos de datos dobles o booleanos.

En algunos casos, pueden surgir algunos requisitos en los que el sistema de destino no acepta algunos campos específicos de un JSON en formato de cadena y solo se aceptan valores dobles o numéricos. El siguiente maravilloso cubre dichos requisitos.

Al convertir XML al formato JSON, todos los caracteres se convierten al tipo de cadena predeterminado (aunque la definición XSD puede decir que es de tipo de datos int/booleano). Para convertir cadenas a tipos de datos numéricos o booleanos, se puede utilizar un script maravilloso para lograr lo mismo.

Guión maravilloso:

//Groovy : Convert deep nested specified JSON elements to double or Boolean data types
import groovy.json.JsonSlurper
import groovy.json.JsonOutput
import groovy.json.JsonBuilder
import com.sap.gateway.ip.core.customdev.util.Message
def Message processData(Message message) 
{
    def body = message.getBody(java.lang.String)
    def jsonSlurper = new JsonSlurper()
    def json = new JsonSlurper().parseText(body)
    //Get Message Properties
    def NumericFieldsToConvert=message.getProperty("Numericfields").split(",")
    def BooleanFieldsToConvert=message.getProperty("Booleanfields").split(",")
    // Call the conversion function with the root of the JSON
    convertGPaths(json,NumericFieldsToConvert,BooleanFieldsToConvert)
    // Convert the modified JSON back to a string
    def modifiedJsonStr = new JsonBuilder(json).toPrettyString()    
    message.setBody(modifiedJsonStr)
    return message
}

def convertGPaths(node,NumericFieldsToConvert,BooleanFieldsToConvert)
{
if (node instanceof Map) 
{
    println("Node:"+node)
    node.each { key, value ->

        println("Key : "+key)
        println("Value :"+value)
        //Double fields
        if (key in NumericFieldsToConvert)
        {
            try 
            {
            node[key] = value.toDouble()
            }//try
            catch (Exception e)
            {
            node[key] = value
            }//catch
        } //if

        //boolean fields
        else if (key in BooleanFieldsToConvert)
        {
            try 
            {
            node[key] = value.toBoolean()
            }//try
            catch (Exception e)
            {
            node[key] = value
            }//catch
        } //if 

        else if (value instanceof Map || value instanceof List) 
        {
            node[key]=convertGPaths(value,NumericFieldsToConvert,BooleanFieldsToConvert)
        }//else if
        else
        {
            node[key] = value
        }
    }//node.each
}//if
else if (node instanceof List) 
{
        node.each { item ->
            if (item instanceof Map || item instanceof List) 
            {
                convertGPaths(item,NumericFieldsToConvert,BooleanFieldsToConvert)
            }//if
        }//node.each
}//else if
}//convertGPaths

Resultados de la simulación en Groovy IDE en línea:

Resultados de simulación para conversión de cadena a booleana, tipo doble

NOTA: Pase valores separados por comas de campos booleanos y numéricos que se convertirán mediante un modificador de contenido. En caso de adiciones adicionales a campos, esto se puede configurar directamente, haciéndolo así más dinámico.

Resumen

Arriba se ilustró un script maravilloso para convertir elementos específicos de JSON de cadena predeterminada a datos booleanos/numéricos.

Los comentarios o opiniones/sugerencias, pros y contras con respecto a lo anterior son bienvenidos por parte de compañeros de Integración.

Referencias