Entrada y salida personalizadas para Asignadores de datos de OmniStudio en OmniStudio

De forma predeterminada, los Asignadores de datos gestionan datos JSON y XML. Para gestionar otros formatos de datos, puede configurar un Asignador de datos para utilizar una entrada o salida personalizada que implemente como una clase personalizada. Por ejemplo, puede definir una Transformación de asignador de datos que acepta datos con formato CSV y los genera como JSON.

Las opciones son las siguientes:

• Carga del asignador de datos: Entrada personalizada (la salida es siempre un objeto de Salesforce)

• Transformación de asignador de datos: Entrada y salida personalizadas

• Extracto del asignador de datos: Entrada y salida personalizadas

Para configurar un Asignador de datos para utilizar una entrada o salida personalizada, establezca su tipo como Personalizado. A continuación especifique la clase que contiene los métodos serializar y deserializar que realizan la operación. La siguiente tabla muestra propiedades para una transformación de Asignador de datos configurada con una entrada y salida personalizadas.

Propiedad	Valor
Nombre de interfaz de asignador de datos	Transformación de serialización personalizada
Tipo de interfaz	Transformación
Tipo de entrada	Personalizar
Clase de entrada personalizada	CSVProcessor
Tipo de salida	Personalizar
Clase de salida personalizada	CSVProcessor

Para facilitar la asignación, puede pegar entrada de muestra en los paneles Entrada prevista y Salida prevista.

Para crear la lógica necesaria para personalizar la entrada y la salida, debe definir una clase personalizada que implemente Llamar. Para el resultado personalizado, implemente el método serializar. Para la entrada personalizada, implemente el método deserializar. No puede cambiar el nombre de los parámetros de entrada y salida.

El siguiente ejemplo muestra la estructura básica de una clase de serialización y deserialización de clientes.

global with sharing class PreprocessorClassExample implements Callable {
   public Object call(String action, Map<String, Object> args) {

        Map<String, Object> input = (Map<String, Object>)args.get('input');
        Map<String, Object> output = (Map<String, Object>)args.get('output');
        Map<String, Object> options = (Map<String, Object>)args.get('options');

        return invokeMethod(action, input, output, options);
    }
    private Object invokeMethod(String methodName, Map<String,Object> input, Map<String,Object> output, Map<String,Object> options) {
        if (methodName == 'serialize') {
            return serialize(input, output);
        }
        else if (methodName == 'deserialize') {
            return deserialize(input, output);
        }
        return false;
    }
    /*
        Serializes Apex objects into JSON content. Return String json
    */
    global Boolean serialize(Map<String, Object> input, Map<String, Object> output) {
        String jsonString = '';            
        // code
        output.put('output', jsonString); // JSON String
        return true;
    }
    /*
        Deserializes the specified JSON string into collections of primitive data types. Return Object ((Map<String, Object>))
    */
    global Boolean deserialize(Map<String, Object> input, Map<String, Object> output) {
        Map<String, Object> returnMap = new Map<String, Object>();
        // code
        output.put('output', returnMap); // ---> collections of primitive data types Map<String, Object>, List<Map<String, Object>>()
        return true;
    }
}

El siguiente ejemplo serializa y deserializa datos CSV.

global with sharing class CSVProcessor implements Callable {
    public Object call(String action, Map<String, Object> args) {

        Map<String, Object> input = (Map<String, Object>)args.get('input');
        Map<String, Object> output = (Map<String, Object>)args.get('output');
        Map<String, Object> options = (Map<String, Object>)args.get('options');

        return invokeMethod(action, input, output, options);
   }
   private Object invokeMethod(String methodName, Map<String,Object> input, Map<String,Object> output, Map<String,Object> options)
   {
   System.debug('METHOD NAME >>> ' + methodName);
       if (methodName == 'deserialize')
       {
           return deserialize(input, output);
       }
       return false;
   }
   /*
   Example Output: 'Column2,Column1\nvalue0,value1.0\nvalue0.1,value1.1';
   */
   /*
   Deserializes the specified JSON string into collections of primitive data types. Return Object ((Map<String, Object>))
   Input: 'Column2,Column1\nvalue0,value1.0\nvalue0.1,value1.1';
   Output:
   [
       {
           "Column1Test": "value1.0",
           "Column2Test": "value0"
       },
       {
           "Column1Test": "value1.1sl",
           "Column2Test": "value0.1"
       }
   ]
   */
        public class csvInput {
            @AuraEnabled
            public string VersionData;
        }
        global Boolean deserialize(Map<String, Object> input, Map<String, Object> output)
   {
       System.debug(input);
       System.debug(input.get('input'));
       System.debug(input.toString());
       //csvInput s = (csvInput)JSON.deserialize((string)input.get('input'), csvInput.class);
       Object data = input.get('input');
       csvInput s;
       if(data instanceof String) {
           s = (csvInput)JSON.deserialize(String.valueOf(data), csvInput.class);
       } else { // try to preserve the source formatting
           s = (csvInput)JSON.deserialize(JSON.serialize(data), csvInput.class);
       }
       Blob decodedInputBlob = System.EncodingUtil.base64Decode(s.VersionData);
       String decodedCsvString = decodedInputBlob.toString();
       Object inputValue = decodedCsvString;
       System.debug(inputValue);
       if (inputValue != null && inputValue InstanceOf String)
       {
           List<String> valueSet = ((String)inputValue).split('\n');
           List<Map<String, String>> csvList = new List<Map<String, String>>();
           List<String> columns = new List<String>();
           for (Integer i = 0; i < valueSet.size(); i++)
           {
               String value = valueSet[i];
               if (String.isBlank(value))
               {
                   continue;
               }
               if (i == 0)
               {
                   List<String> valSet = value.split(',');
                   for (Integer y = 0; y < valSet.size(); y++)
                   {
                       columns.add(valSet[y]);
                   }
               }
               else
               {
                   List<String> valSet = value.split(',');
                   if (columns.size() >= valSet.size())
                   {
                       Map<String, String> rows = new Map<String, String>();
                       for (Integer z = 0; z < valSet.size(); z++)
                       {
                           rows.put(columns[z], valSet[z]);
                       }
                       csvList.add(rows);
                   }
               }
           }
           output.put('output', csvList);
           //Map<String, Object> returnMap = new Map<String, Object>();
           //output.put('output', returnMap);
           System.debug(output);
           return True;
       }
       return False;
   }
}

Por ejemplo, supongamos que su archivo CSV tiene este contenido:

Nombre	Correo electrónico	Teléfono
Mary Baker	mbaker@example.com	415-555-3331
Joe Baker	jbaker@example.com	415-555-3332
Russell Baker	rbaker@example.com	415-555-3333

La clase CSVProcessor de ejemplo la convierte en esta entrada JSON:

[
  {
    "Name": "Mary Baker",
    "Email": "mbaker@example.com",
    "Phone": "415-555-3331"
  },
  {
    "Name": "Joe Baker",
    "Email": "jbaker@example.com",
    "Phone": "415-555-3332"
  },
  {
    "Name": "Russell Baker",
    "Email": "rbaker@example.com",
    "Phone": "415-555-3333"
  }
]