How to check json and do filtering in Logic App - azure-logic-apps

Question

In my Logic App one of the action item gives me Json value as like this . This is recorded in compose action.
{
"device1": 24,
"device2": 25,
"device3": 26
}
I would like to take only that device name and value whose value is equal to and above 25 (in this case device2 and device3)and then pass that value in subsequent method like creating and sending an alert message for each device name whose value is 25 or more.
How can I do that in logic app?

Answer 1

Here is one of the workaround that worked for me. In order to filter the Json in well defined, easy format (i.e., devices whose value is greater than 25) and also for future use, we need to convert the json of format
{
"device1": 24,
"device2": 25,
"device3": 26
}
to
[
{
"deviceName": "\"device1\"",
"value": "24"
},
{
"deviceName": "\"device3\"",
"value": "26"
},
{
"deviceName": "\"device2\"",
"value": "25"
}
]
We first need to convert the Json into array. This can be done in 2 ways
Way -1 (using subString())
syntax in Method 1 step 1
substring(string(outputs('Compose')),1,sub(lastIndexOf(string(outputs('Compose')),'}'),1))
syntax in Method 1 step 2
array(split(string(outputs('Convert_To_Array_Method_1_step_1')),','))
Way -2 (using replace())
syntax in Method 2 step 1
replace(string(outputs('Compose')),'{','[')
syntax in Method 2 step 2
replace(string(outputs('Convert_To_Array_Method_2_step_1')),'}',']')
output:
You need to initialize an array variable in order to store the resultant json.
We can now extract the values inside the json by taking either of syntax in Method 1 step 2or syntax in Method 2 step 2 outputs in For each connector.
In Extract values compose connector I'm trying to extract the values of the devices by taking substring expression.
syntax in Extract values
substring(item(),add(indexOf(item(),':'),1),sub(length(item()),add(indexOf(item(),':'),1)))
Here I'm just extracting the values that are there after ':'.
The same goes with device names too. I'm extracting the device names that are there from index 0 to ':'.
syntax in Formatted JSON
{
"inputs": {
"deviceName": "#substring(item(), 0, indexOf(item(), ':'))",
"value": "#outputs('Extract_Value')"
}
}
Then lastly I'm storing the resultant Formatted Json to a variable.
output:
Now I'm just parsing the the Formatted variable which gives me the results of device name and value.
In the next step I'm using Condition connector to check if the value greater than or equal to 25
syntax in Condition
int(items('For_each_2')['value'])
if the condition is true then it stores the value to Required Values.
output:
Here is the code view of my logic app
{
"definition": {
"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
"actions": {
"Compose": {
"inputs": {
"device1": 24,
"device2": 25,
"device3": 26
},
"runAfter": {},
"type": "Compose"
},
"Convert_To_Array_Method_1_step_1": {
"inputs": "#substring(string(outputs('Compose')),1,sub(lastIndexOf(string(outputs('Compose')),'}'),1))",
"runAfter": {
"Compose": [
"Succeeded"
]
},
"type": "Compose"
},
"Convert_To_Array_Method_1_step_2": {
"inputs": "#array(split(string(outputs('Convert_To_Array_Method_1_step_1')),','))",
"runAfter": {
"Convert_To_Array_Method_1_step_1": [
"Succeeded"
]
},
"type": "Compose"
},
"Convert_To_Array_Method_2_step_1": {
"inputs": "#replace(string(outputs('Compose')),'{','[')",
"runAfter": {
"Convert_To_Array_Method_1_step_2": [
"Succeeded"
]
},
"type": "Compose"
},
"Convert_To_Array_Method_2_step_2": {
"inputs": "#replace(string(outputs('Convert_To_Array_Method_2_step_1')),'}',']')",
"runAfter": {
"Convert_To_Array_Method_2_step_1": [
"Succeeded"
]
},
"type": "Compose"
},
"Final_Formated_JSON": {
"inputs": "#variables('formatedArray')",
"runAfter": {
"For_each": [
"Succeeded"
]
},
"type": "Compose"
},
"Final_Values": {
"inputs": "#variables('Required Values')",
"runAfter": {
"For_each_2": [
"Succeeded"
]
},
"type": "Compose"
},
"For_each": {
"actions": {
"Append_to_array_variable": {
"inputs": {
"name": "formatedArray",
"value": "#outputs('Formated_JSON')"
},
"runAfter": {
"Formated_JSON": [
"Succeeded"
]
},
"type": "AppendToArrayVariable"
},
"Extract_Value": {
"inputs": "#substring(item(),add(indexOf(item(),':'),1),sub(length(item()),add(indexOf(item(),':'),1)))",
"runAfter": {},
"type": "Compose"
},
"Formated_JSON": {
"inputs": {
"deviceName": "#substring(item(), 0, indexOf(item(), ':'))",
"value": "#outputs('Extract_Value')"
},
"runAfter": {
"Extract_Value": [
"Succeeded"
]
},
"type": "Compose"
}
},
"foreach": "#outputs('Convert_To_Array_Method_1_step_2')",
"runAfter": {
"Initialize_variable_to_store_the_formatted_Json_": [
"Succeeded"
]
},
"type": "Foreach"
},
"For_each_2": {
"actions": {
"Condition": {
"actions": {
"Append_to_array_variable_2": {
"inputs": {
"name": "Required Values",
"value": "#items('For_each_2')"
},
"runAfter": {},
"type": "AppendToArrayVariable"
}
},
"expression": {
"and": [
{
"greaterOrEquals": [
"#int(items('For_each_2')['value'])",
25
]
}
]
},
"runAfter": {},
"type": "If"
}
},
"foreach": "#body('Parse_JSON')",
"runAfter": {
"Initialize_variable_to_store_required_values": [
"Succeeded"
]
},
"type": "Foreach"
},
"Initialize_variable_to_store_required_values": {
"inputs": {
"variables": [
{
"name": "Required Values",
"type": "array"
}
]
},
"runAfter": {
"Parse_JSON": [
"Succeeded"
]
},
"type": "InitializeVariable"
},
"Initialize_variable_to_store_the_formatted_Json_": {
"inputs": {
"variables": [
{
"name": "formatedArray",
"type": "array"
}
]
},
"runAfter": {
"Convert_To_Array_Method_2_step_2": [
"Succeeded"
]
},
"type": "InitializeVariable"
},
"Parse_JSON": {
"inputs": {
"content": "#variables('formatedArray')",
"schema": {
"items": {
"properties": {
"deviceName": {
"type": "string"
},
"value": {
"type": "string"
}
},
"required": [
"deviceName",
"value"
],
"type": "object"
},
"type": "array"
}
},
"runAfter": {
"Final_Formated_JSON": [
"Succeeded"
]
},
"type": "ParseJson"
}
},
"contentVersion": "1.0.0.0",
"outputs": {},
"parameters": {},
"triggers": {
"manual": {
"inputs": {
"schema": {}
},
"kind": "Http",
"type": "Request"
}
}
},
"parameters": {}
}

Answer 2

In these situations, I find it much easier to write an Azure Function that does the work.
It'll ultimately keep your LogicApp cleaner than it would otherwise be with a whole heap of functionality to work around (perceived) limitations.
In the Azure Portal, go to the Azure Functions blade and create a new .NET HttpTrigger function with the following code ...
#r "Newtonsoft.Json"
using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public static async Task<IActionResult> Run(HttpRequest req, ILogger log)
{
string thresholdString = req.Query["threshold"];
var threshold = int.Parse(thresholdString);
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var jObject = JObject.Parse(requestBody);
var filteredObject = new JObject(jObject.Properties().ToList().Where(x => (int)x.Value >= threshold));
return new OkObjectResult(filteredObject);
}
... it assumes the JSON you pass in is along the lines of what you provided so be aware of that.
Now call it from your LogicApp like and you'll get the response you desire ...
Action
Result