XML Data Processing with eZintegrations

XML Data Processing is essential in the world of data connections,
XML is still a common format for older systems, APIs, and business tools like SOAP services or old databases.
While JSON is now the favorite for new apps because it’s light and easy to use, not every system uses it.
That’s why handling XML responses is important: it keeps data moving smoothly between different systems and avoids delays in your automation tasks.
With eZintegrations, our AI-powered platform, you can easily turn messy XML into useful information without any trouble.

Core XML Data Processing Operations

At its heart, eZintegrations provides simple operations to manage XML data.
These operations work together in a flow to clean, pull out, and change the data, making it ready for things like reports, storage, or more connections.
Here’s a quick look at the main operations:

• XML to JSON: This is your first step to update things. It takes XML text and turns it into a neat JSON object, grabbing values from specific keys. It’s great for sorting out complex XML layouts into something easier to work with.
• Data Extractor: After turning it into JSON, this tool helps you pick out the exact pieces you need. It goes through the object to get keys and their values, removing extra stuff so you focus on what matters.
• Substitute: Think of this as a smart swap tool. It lets you replace unwanted letters, words, or patterns in your data—useful for fixing odd bits like extra codes or strange formatting that XML sometimes has.
• Base64 Decoding: Many XML files hide data like reports or files in base64 format. This tool changes it back to its original form, like text, pictures, or documents, so you can use it.
• Delimiter to JSON: If your cleaned-up data comes as separated text (like CSV inside XML), this turns it into JSON lists or objects, adding structure so it’s easy to search.

AI Transformations

Alternatively, you can simplify this further using AI operations.
With just a short plain-English instruction, eZintegrations’ AI can automatically handle complex XML transformations in a single smart step.

For example, to process a typical XML response, you can use the following simple English prompt:

<script>
// Step 1: Wrap everything in a function so it runs safely
(function() {
try {
// Step 2: Get the incoming dataset
var datasetResponse = {%bizdata_dataset_response%}; // Bizdata dataset

// Step 3: Extract the base64 string from 'ReportBytes'
var base64String = datasetResponse?.ReportBytes;
if (!base64String) {
console.error("No ReportBytes found in dataset");
return;
}

// Step 4: Decode the base64 content
var decodedData = atob(base64String);

// Step 5: Remove '77u/' padding if present
decodedData = decodedData.replace(/77u\//g, "");

// Step 6: Convert comma-delimited text to JSON array
var lines = decodedData.split("\n").filter(line => line.trim() !== "");
var headers = lines[0].split(",");
var salesData = lines.slice.map(function(line) {
var values = line.split(",");
var record = {};
headers.forEach(function(header, idx) {
record[header.trim()] = values[idx]?.trim() || null;
});
return record;
});

// Step 7: Wrap in an object under the key 'salesData'
var result = { salesData: salesData };

// Step 8: Show the final result in the console
console.log("Processed salesData:", result);

// Optional: make it available globally for other Elementor widgets
window.salesData = result.salesData;

} catch (error) {
console.error("Error processing Bizdata dataset:", error);
}
})();
</script>

This approach is ideal for those who prefer a natural language interface over manual pipeline configuration.

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Body>
<runReportResponse>
<ReportBytes>77u/Base64EncodedDataHere</ReportBytes>
</runReportResponse>
</soapenv:Body>
</soapenv:Envelope>

Chaining Operations

The beauty lies in chaining these operations. Instead of wrestling with custom scripts, you build visual pipelines that handle the heavy lifting automatically.

Example Use Case

Imagine this: You’re connecting to an Oracle reporting tool that sends SOAP XML responses.
Inside that XML is a base64-encoded report, like a customer sales list in separated text.
Without help, it’s just a jumble of code.
But with eZintegrations, you start by turning the XML into JSON to reach the report data.
Then, use Data Extractor to grab the base64 part, apply Substitute to remove any extra “77u/” bits, decode it with Base64 Decoding, and if it’s separated by commas, use Delimiter to JSON to make it a neat list.
Now, you have clean JSON ready for your CRM or dashboard, saving you hours of manual work.

Conclusion

In the end, eZintegrations makes XML handling easy and fun, helping both business people and tech teams run smooth automations.

FAQ