DEV Community: Omo Agbagbara

Dynamically Parse JSON as Object or Array

Omo Agbagbara — Mon, 29 Dec 2025 00:15:36 +0000

Walkthrough on how to dynamically parse JSON as object or array in logic apps.

While working as a consultant for an integration consultancy, we had a client who wanted to be able to ingest the client list data set from WorkflowMax into SQL. The client data set consists of basic client information (name, email etc) and a list of the client contacts, of which there might be one or more.

WorkflowMax exposes its data sets in XML, the process of getting the data set from WorkflowMax is quite trivial,

Get an access token,
Get the client list.
Store the result in blob storage.
Trigger an Azure Data Factory pipeline a. To convert the XML to JSON. b. Store th JSON file in blob storage. c. Within the pipeline, insert or upsert top level client details into the database. In order to handle the list of contacts, the outputed json file has to be processed. However for some reason, the azure data factory copy activity, produces an array of contacts when there are multiple contacts, but an object of contacts when there is just one contact.

{ "_id": "64fafdab0148d179b4bad3d6", "index": 0, "guid": "a5a30726-560b-4548-9219-d3e579ff4df0", "name": "Joanna Stephenson", "company": "SYNKGEN", "contacts": [ { "id": 0, "name": "Church Cleveland", "email": "churchcleveland@synkgen.com", "age": 37 }, { "id": 1, "name": "Tabitha Gentry", "email": "tabithagentry@synkgen.com", "age": 26 } ] }
or
{ "_id": "64fafdabea7f6eecf0e80b44", "index": 1, "guid": "3f273e26-2dec-4a56-a139-760977630590", "name": "Lynnette Guerra", "company": "COMTOURS", "contacts": { "id": 1, "name": "Marcie Spence", "email": "marciespence@comtours.com", "age": 40 } }

The json file can be processed by a logic app, however there is no simple way to handle processing elements where the schema contains an object or an array for the same element.

A possible solution can be found at Dynamically Parse JSON as object or Array where the question was answered and a solution proposed.

Creating a logic app to process these records is not complicated, the following page is a walkthrough on how this can be done.

The idea is to read the json file and parse the json payload, for each client, process all the contacts. A solution is to check the length of the contacts element. If it is an array, the number of elements will be returned otherwise it is an object.

However, there is no simple way to implement this logic in logic app. The images below shows what happens if this process is implemented as is.

Contact List is an Array.

Implementing OCR in Azure: A Comparison of Logic App Connectors and Function Apps

Omo Agbagbara — Sun, 13 Jul 2025 11:21:15 +0000

I recently started learning more about the Azure Applied AI Services. It is quite straightforward to setup and understand how it works furthmore, Azure provides a lot of starter samples.See samples.

Being an integration consultant, I tend to implement a few simple integrations using logic apps so I decided to try creating a logic app implementation with the provided connector. Below is the simple ocr process to be implemented.

To perform ocr on an image a computer vision api connector is required. This connector uses the API endpoint and API Key which are generated when Azure AI services multi-service account is first created.

Some of the actions which are available are

For the OCR process the Optical Character Recognition to JSON V3 action will be used with the following setup.

Input Image

This input image was taken on the day of my graduation ceremony in 1998, I recent converted the negative film to digital.
Using the action above, the output for the given input image did not contain any valid text or bounding boxes.

Output Response

However, despite the ease of setup, the results were not as expected. Even after testing with various images, the Logic App's output consistently lacked valid text or bounding boxes. It seemed there might be additional configurations needed for this specific connector action.

Alternate Implementation.

An alternate implementation will be to a function app to call the Azure Applied AI Service to perform the OCR. This function app will use the same Api Key and Api endpoint.
Below is the process to be implemented.

The logic app was setup with a function app action as follows.

The Program.cs is updated as follows

using Azure;
using Azure.AI.Vision.ImageAnalysis;
.
.
// Register ImageAnalysisClient as a singleton
builder.Services.AddSingleton<ImageAnalysisClient>(sp =>
{    
    var endpoint = Environment.GetEnvironmentVariable("AI_ENDPOINT");
    var key = Environment.GetEnvironmentVariable("AI_APIKEY");

    var credential = new AzureKeyCredential(key);
    var client = new ImageAnalysisClient(new Uri(endpoint), credential);
    return client;
});

The HTTP trigger within the Function App was designed to read the image data, perform analysis using VisualFeatures.Read, and then extract the text, bounding polygons, and word confidence scores.

var response = new List<dynamic>();

 // Read the request body into BinaryData
 BinaryData requestData = await BinaryData.FromStreamAsync(req.Body);

 // If you need the string representation
 ImageAnalysisResult result = _ImageAnalysisClient.Analyze(requestData, VisualFeatures.Read);

 foreach (var line in result.Read.Blocks.SelectMany(block => block.Lines))
 {            

     var lineObject = new
     {
         Text = line.Text,
         BoundingPolygon = line.BoundingPolygon.ToList(),
         Words = line.Words.Select(word => new
         {
             Text = word.Text,
             Confidence = word.Confidence.ToString("#.####"),
             BoundingPolygon = word.BoundingPolygon.ToList()
         }).ToList()
     };

     response.Add(lineObject);               
 }

Using this approach produces results which are significantly better and aligned with the expected OCR output.
Below is a summary example of the result based on the original input image.

Conculsion

While the Azure Logic App connectors in Azure logic app, provide a simple and convenient way to interact with the Azure ai services, my experience suggests that the results may not always be as intended for certain operations like OCR. A solution will be to create system apis which can act as proxies to backend services.
The problem with this approach is that there is now an extra set of resources which have to be implemented and maintained. But this an easy task.

Have you had similar experiences with Azure AI services and different integration patterns? Share your thoughts in the comments!

Logic App Http Connector with Swagger + C# Function App

Omo Agbagbara — Sun, 22 Jun 2025 11:38:27 +0000

Over the last couple of weeks, I have had to upgrade some function apps which were written about 6 years ago. These function apps were triggered by logic apps and in most cases, the original implementation invoked the function apps via http connectors.

It got me thinking about using http connectors but incorporating swagger definitions. Incorporating swagger definitions provide a better UX for integrating with function app.

To start off, the function app code has to be annotated with openApi attributes and for c# projects the nugget package must be added. The nugget package to use is Microsoft.Azure.Functions.Worker.Extensions.OpenApi":Version="1.5.1"

In the scenario been discussed, a shipping notice will be created. The shipping notice request will be defined by a ShippingNoticeDTO.

Define the ShippingNoticeDTO

namespace Deltastateonline.Dtos
{
    public class ShippingNoticeDto
    {
        [Required]
        public string ShipmentId { get; set; }
        public DateTime ExpectedArrival { get; set; }
        public List<ProductDto> Products { get; set; }
        public string CarrierName { get; set; }
        public string TrackingNumber { get; set; }
    }

    public class ProductDto
    {
        [Required]
        public string ProductCode { get; set; }
        public string Description { get; set; }
        [Required]
        public int Quantity { get; set; }
    }
}

Implementation

The function code can then be annotated with the attributes as shown below.

[OpenApiOperation(operationId: "CreateShippingNotice", tags: new[] { "Shipping-Notice" }, Summary = "Create Shipping Notice", Description = "This creates a Shipping Notice.", Visibility = OpenApiVisibilityType.Important)]
   [OpenApiParameter(name: "x-functions-key",In = ParameterLocation.Header,Required = true,Type = typeof(string),Summary = "function auth key",Description = "Auth key.")]
   [OpenApiSecurity("function_key", SecuritySchemeType.ApiKey, Name = "code", In = OpenApiSecurityLocationType.Query)]
   [OpenApiSecurity("x-functions-key", SecuritySchemeType.ApiKey, Name = "code", In = OpenApiSecurityLocationType.Header)]
   [OpenApiRequestBody(contentType: "application/json", bodyType: typeof(ShippingNoticeDto), Description = "Shipping Notice Details", Required = true)]
   [OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: "application/json", bodyType: typeof(ResponseObj), CustomHeaderType =typeof(CustomResponseHeader),Summary = "Success", Description = "This returns the response")]
   [OpenApiResponseWithoutBody(statusCode: HttpStatusCode.BadRequest, Description = "Bad Request")]
   [OpenApiResponseWithoutBody(statusCode: HttpStatusCode.InternalServerError, Description = "Internal server error")]

   [Function("ShippingNotice")]
   public async Task<MultipleOutputs<ShippingNoticeDto>> RunAsync([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req , FunctionContext context)
   {           
           string requestBody = await new StreamReader(req.Body).ReadToEndAsync();

           HttpResponseData  response = req.CreateResponse();                      
           ShippingNoticeDto inputRequest = null;
           try
           {
               inputRequest  = JsonConvert.DeserializeObject<ShippingNoticeDto>(requestBody)?? throw new ArgumentNullException(nameof(ShippingNoticeDto));

               var validationResults = new List<ValidationResult>();
               var validationContext = new ValidationContext(inputRequest, null, null);
               bool isValid = Validator.TryValidateObject(inputRequest, validationContext, validationResults, true);                   

               if (!isValid)
               {                  
                   return new MultipleOutputs<ShippingNoticeDto>{ServiceBusMessage = null,HttpResponse = response};  
               }
           }
           catch (System.Exception ex)
           {                    
               response.StatusCode = HttpStatusCode.InternalServerError;               
               return new MultipleOutputs<ShippingNoticeDto>{ServiceBusMessage = null,HttpResponse = response};
           }
           response.StatusCode = HttpStatusCode.OK;               
           await response.WriteAsJsonAsync(new ResponseObj{Message = "Request Created" , correlationid = context.InvocationId});
           return new MultipleOutputs<ShippingNoticeDto>{ServiceBusMessage = inputRequest,HttpResponse = response};        
   }

Logic App Configuration.

The swagger definition for the function app can be used in the logic app as follows

Add a http connector and choose the HTTP + swagger option.
This selection allows a swagger endpoint to be configured.
In this scenario, the swagger definition used can be obtained from the function app OpenApi Document UI.
Enter the url into the endpoint box.
This will provide a list of all the possible operations which are available in the swagger definition. For this scenario, the "Create Shipping Notice" is selected.
The UX now allows the required parameters to be configured.
Configured Payload.

C# Image Resizer Using ZeroMQ and Protobuf

Omo Agbagbara — Fri, 09 May 2025 07:05:41 +0000

Following on from the previous post I decided to attempt to use protobuf rather than json to transmit the data between the producer and the consumers. The updated repo can be found [C# Image Resizer Using ZeroMQ and Protobuf].(https://github.com/deltastateonline/ImageProcessor/tree/Using-Protobuf)

I found this starting point on using protobuf in c# from Fast and efficient data serialisation with Protocol buffers (protobuf) in .NET.

The first step is to add the protobuf-net package then define a class for the Image data definition. This class definition is an exact duplicate of the original, but with the required protobuf annotations.

using ProtoBuf;

namespace Common
{
    [ProtoContract]
    public class ImageDefProto
    {
        [ProtoMember(1)]
        public required string Id { get; set; }
        [ProtoMember(2)]
        public required string Filename { get; set; }
        [ProtoMember(3)]
        public required string InputFolder { get; set; }
        [ProtoMember(4)]
        public required string OutputFolder { get; set; }
        [ProtoMember(5)]
        public decimal Resize { get; set; }
    }
}

The next step is to create a helper class which is used to serialize and deserialize the class into a byte array and from a byte array via a memory stream.

namespace Common
{
   public  static class ProtobufHelpers
    {
        public static byte[] SerializeObject<T>(T record) where T : class
        {
            using (var stream = new MemoryStream())
            {
                Serializer.Serialize(stream, record);
                return stream.ToArray();
            }
        }
        public static T DeserializeObject<T>(byte[] data)
        {
            T obj = default(T);
            using (var stream = new MemoryStream(data))
            {
                obj = Serializer.Deserialize<T>(stream);
            }
            return obj;
        }
    }
}

In the ImageListing project, the image definition object has to be serialized as follows and published.

var msg = new ImageDefProto
{
    Id = messageId.ToString(),
    Filename = file,
    InputFolder = path,
    OutputFolder = outputPath,
    Resize = resize
};

string encodedText = Convert.ToBase64String(ProtobufHelpers.SerializeObject(msg));
publisher.SendFrame(encodedText);

While in the ImageProcessor project the data is deserialized and consumed.

if (!subscriber.TryReceiveFrameString(TimeSpan.FromMilliseconds(5000), out string receivedFrame))
{
    Console.WriteLine("Timeout reached, no more messages. Exiting...");
    break;
}

byte[] textBytes = Convert.FromBase64String(receivedFrame); 
var imageDetails = ProtobufHelpers.DeserializeObject<ImageDefProto>(textBytes);  

Console.WriteLine(JsonSerializer.Serialize(imageDetails, jsonSerializerOptions));
await ResizeImage(imageDetails);

Conclusion

In this implmentation, it can be seen that using protobuf saves about 32% of the space required to transmit the data. This may not seem like much but in high volume systems and systems with limited resources, protobuf would be an excellent option.

Let this post be a practical example for using protobuf.

There are a number of reasons why you would choose using json over protobuf or vice versa -

Ask ChatGPT

In summary.

Using Json

length of string = 305;

eyJJZCI6IjAiLCJGaWxlbmFtZSI6IkM6XFxVc2Vyc1xcb21vXFxQaWN0dXJlc1xcMjAyNS0wMy0wMS1mb290YmFsbFxcSU1HXzQxOTUuSlBHIiwiSW5wdXRGb2xkZXIiOiJDOlxcVXNlcnNcXG9tb1xcUGljdHVyZXNcXDIwMjUtMDMtMDEtZm9vdGJhbGwiLCJPdXRwdXRGb2xkZXIiOiJDOlxcVXNlcnNcXG9tb1xcUGljdHVyZXNcXDIwMjUtMDMtMDEtZm9vdGJhbGxfQ1NoYXJwIiwiUmVzaXplIjoyMH0=

Using Protobuf

length of string = 209;

CgEwEjZDOlxVc2Vyc1xvbW9cUGljdHVyZXNcMjAyNS0wMy0wMS1mb290YmFsbFxJTUdfNDE5NS5KUEcaKUM6XFVzZXJzXG9tb1xQaWN0dXJlc1wyMDI1LTAzLTAxLWZvb3RiYWxsIjBDOlxVc2Vyc1xvbW9cUGljdHVyZXNcMjAyNS0wMy0wMS1mb290YmFsbF9DU2hhcnAqAggU

Please like and leave a comment on this post.

Next feature would be to implement commandline parameters and options for the ImageListing project.

C# Image Resizer Using ZeroMQ

Omo Agbagbara — Wed, 30 Apr 2025 23:35:02 +0000

Introduction

I previously served as the General Secretary of an association based in Brisbane. Throughout the year, we host around three events where professional photographers capture numerous high-quality images. Some of these photos can be as large as 18MB.

Once the events conclude, the pictures need to be uploaded to Google Albums and shared with our community. At our most recent event, the total upload size reached 5GB.

I had previously implemented an image resizer in php which I executed by running

php process.php imageprocessing <input-folder> [<output-folder> [<size>]]

The files in the input folder were processed sequentially, which worked well for a small number of images and for smaller file sizes—around 5MB.

However, when handling a large volume of files, the process became slow and occasionally crashed due to PHP running out of memory.

A more efficient approach would be to distribute the resizing task across multiple workers. This can be achieved using a simple pub/sub messaging pattern, where the publisher gathers a list of all images to be processed and then sends messages containing the necessary details for resizing.

The workers retrieve messages from the queue and handle their processing.

A message can be defined as

{
  "Id": "1",
  "Filename": "2025\\MENS EVENT_2025\\1D2A7537.JPG",
  "InputFolder": "2025\\MENS EVENT_2025",
  "OutputFolder": "2025\\MENS EVENT_2025_CSharp",
  "Resize": 20
}

Solution

The ImageProcessor in the repository has been implemented in C# using ZeroMQ and the NetMq nuget package. It also uses SixLabors.ImageSharp to resize the image.
It consists of

Publisher project - ImageListing
Worker project - ImageProcessor

The publisher

The worker

Both projects can be used as follows:

.\ImageListing.exe "\2025\MENS EVENT_2025" "2025\MENS EVENT_2025_CSharp" 20

.\ImageProcessor.exe 1
.\ImageProcessor.exe 2
.\ImageProcessor.exe 3
.\ImageProcessor.exe 4

Finally

I began experimenting with ZeroMQ in October 2024 while searching for an embedded library—similar to SQLite—that wouldn't require installing additional software.

There are other message brokers such as Rabbitmq, ActiveMQ, Azure Service Bus and Aws SNS/SQS. I worked on Java-HowTo-SNS utilizing AWS SNS for a similar task in Java.

Using ZeroMQ offered a more complete and contained solution. Additionally, by integrating ImageSharp, watermarks can be seamlessly added to images during resizing.

Distribution Calculator In Svelte - Hosted on Amazon S3

Omo Agbagbara — Sun, 19 Jan 2025 06:59:16 +0000

I recently completed building a Simple Calculator to help members calculate their distributions payable from OnePath. Every quarter or so, Onepath
publishes a spreadsheet containing all the distributions payable for the managed funds which they sell. Customers have to go through the sheets, find their fund and copy the distribution cents per share, then do the calculation against the number of units they own.

I think this process is quite tedious and outdated. It would be ideal if Onepath has an app, but building apps is not their primary business.

However they could expose their datasets via an API so that developers can build apps or solutions against their dataset. Building and maintaining APIs has it own issues so it also not in their core business to do this.

In order to build this solution I have had to design an API which is documented at Api

Decision Register

Here are some decisions I made while building this solution.

#	Decision	Reason
1	Use Svelte over React	I decided to build this sample in svelte rather than react because for some reason, I have never wanted to build anything in react, I really dont know why, I never seemed to take to it, I have done a lot of tutorials and training in react, but for some reason I never could get myself to build anything in it.
2	Use Svelte over Vue	I had already built a solution in vue and vuex Visit Kate , Tim and Marty And Joel Podcast Library
3	Use SvelteKit	I started off with a single page application, as you normally do when using a todo app, however, I quickly realised that I would need multiple pages, so I had to recreate the solution using svelteKit. I would recommend that you always start with sveltekit.
4	Host on S3	I have always found it easier to host single page application built on S3, Its quite a simple process to do. Furthermore a cloudfronrt distribution can be placed in front of the S3 bucket. Note that AWS has changed how permission is granted from cloudfront to S3
5	Data Munging	I found it easy to convert the excel sheets to csv and then sql statements using simple php scripts
6	Building the backend Api	Backend Api was built using laravel. There is no longer the option to create api projects with Laravel Lumen so the Api was implemented in Laravel
7	Protecting the backend Api	The backend api was protected using Aws API Gateway

I switched career from being a web developer to being an integration consultant. I didn't want to continue building SAAS because there became too many choices on how you can build and deploy them. Furthermore, the tool chains became too complicated. But I still like to build web applications in my spare time to keep up with the latest tech.
While building this application, I made some use of Copilot to get though some svelte issues which had me stumped. Using copilot was a pleasant experience, I would recommend.

Returning Correct StatusCodes in Azure Function Apps

Omo Agbagbara — Sat, 14 Sep 2024 04:06:15 +0000

I was recently involved in working on some middleware which recieves requests from an asset management system , tranform the data and send it over to an on premise deployment of business management solution.

This middleware has to be implemented as a C# function app. One key feature of this middleware, was to use the guaranteed delivery pattern.

Implementing this as C# function app is quite a trivial which involves.

Receive the request.
Validate request, throw a validation error if neccessary and send response.
Send the request to Service Bus and return an HTTP response

In C# function apps, it is possible to return a HTTP response and send the request to a Service Bus using a class

And this class can be used as follows

However when it comes to returning errors, I encountered a problem using

await response.WriteAsJsonAsync("Some Text");

Using this statement results in the response status code always being 200 OK.
Gone are the days when developers would return a 200 OK status code regardless of the fact that an error has occurred. It is now a must to return the right status code when building APIs.

Code Segments to Trigger Errors

Bad Request with 200 OK Status Code.

Internal ServerError with 200 OK Status Code

Solution

I found that the solution to this is to use

response.WriteString("Some String");

and to set the following in the Program.cs

services.Configure<KestrelServerOptions>(options =>{
            options.AllowSynchronousIO  = true;
        });

Updated Code

Status Codes Being Returned Correctly

This took me a while to find this solution, and I hope it saves you a lot of time and headache in trying to debug what the issue.

Dynamically Parse JSON as Object or Array

Omo Agbagbara — Sun, 28 Jan 2024 10:40:49 +0000

Walkthrough on how to dynamically parse JSON as object or array in logic apps.

WorkflowMax exposes its data sets in XML, the process of getting the data set from WorkflowMax is quite trivial,

Get an access token,
Get the client list.
Store the result in blob storage.
Trigger an Azure Data Factory pipeline a. To convert the XML to JSON. b. Store th JSON file in blob storage. c. Within the pipeline, insert or upsert top level client details into the database. In order to handle the list of contacts, the outputed json file has to be processed. However for some reason, the azure data factory copy activity, produces an array of contacts when there are multiple contacts, but an object of contacts when there is just one contact.



{
    "_id": "64fafdab0148d179b4bad3d6",
    "index": 0,
    "guid": "a5a30726-560b-4548-9219-d3e579ff4df0",
    "name": "Joanna Stephenson",
    "company": "SYNKGEN",
    "contacts": [
    {
        "id": 0,
        "name": "Church Cleveland",
        "email": "churchcleveland@synkgen.com",
        "age": 37
    },
    {
        "id": 1,
        "name": "Tabitha Gentry",
        "email": "tabithagentry@synkgen.com",
        "age": 26
    }     
    ]    
}



{
    "_id": "64fafdabea7f6eecf0e80b44",
    "index": 1,
    "guid": "3f273e26-2dec-4a56-a139-760977630590",
    "name": "Lynnette Guerra",
    "company": "COMTOURS",    
    "contacts": {
    "id": 1,
    "name": "Marcie Spence",
    "email": "marciespence@comtours.com",
    "age": 40
    }
}

The json file can be processed by a logic app, however there is no simple way to handle processing elements where the schema contains an object or an array for the same element.

A possible solution can be found at Dynamically Parse JSON as object or Array where the question was answered and a solution proposed.

Creating a logic app to process these records is not complicated, the following page is a walkthrough on how this can be done.

However, there is no simple way to implement this logic in logic app. The images below shows what happens if this process is implemented as is.

Contact List is an Array.

Contact List is an Object.

A better solution will be to use the scope widget as try, catch and finally blocks.

Try Scope

This contains the condition to check that the element is an array and if it is then compose an output with all the elements.

Catch Scope

This must be configured to run only if the try scope fails and it involves creating an array of the single element.

Finally Scope.

In the finally scope, the output from the previous steps have to be coalesced and the scope must be configured to run after the previous step is skipped or is successful.

The approach outlined works better than that proposed in the solution to the original question, since it can take advantage of for each loop concurrency.