Comment puis-je fusionner les sorties d'une boucle For_Each dans une application Azure Logic vers un seul tableau plat?

Question

J'ai une boucle For_Each dans une application Azure Logic qui appelle une autre application logique imbriquée. Le résultat de chaque itération de la imbriquée Logic Apps est un objet JSON qui contient un tableau de chaînes, comme ceci:

{ 
"Results": ["string a", "string b"] 
} 

Ainsi, la sortie de ma boucle for_each dans le parent logique App ressemble à ceci:

[ 
{"Results": ["string a", "string b"]}, 
{"Results": ["string c", "string d"]} 
] 

Je veux mettre toutes ces chaînes dans une seule liste plate que je peux passer à une autre action.

Comment est-ce que je peux faire ceci? Est-il possible d'utiliser le langage de définition de flux de travail et les fonctions intégrées ou dois-je utiliser une fonction externe (dans un service ou une fonction Azure)?

Answer 1

Reprenant le commentaire utile de @ DerekLi ci-dessus, il semble que ce ne soit pas possible au moment de l'écriture avec la version de schéma Logic Apps 2016-06-01. L'une des grandes forces de Logic Apps est la possibilité de tirer parti de la puissance des fonctions Azure pour résoudre des problèmes de ce type qui ne peuvent pas (encore) être résolus dans le langage de schéma.

Réécrire le tableau est trivial en C# dans une fonction:

using System.Net; 

public class Result 
{ 
    public List<string> Results {get; set;} 
} 

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log) 
{ 
    log.Info("C# HTTP trigger function processed a request."); 

    var inputs = await req.Content.ReadAsAsync<List<Result>>(); 
    var outputs = new List<string>(); 

    foreach(var item in inputs) 
    { 
     log.Info(item.Results.ToString()); 
     outputs.AddRange(item.Results.Where(x => !string.IsNullOrEmpty(x))); 
    } 

    return req.CreateResponse(HttpStatusCode.OK, outputs); 
} 

Et cette fonction peut alors être transmis le résultat de la boucle For_Each:

"MyFunction": { 
    "inputs": { 
       "body": "@body('Parse_JSON')", 
       "function": { 
        "id": "/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/Microsoft.Web/sites/{function-app-name}/functions/{function-name}" 
       }, 
       "method": "POST" 
      }, 
      "runAfter": { 
       "For_each": [ 
        "Succeeded" 
       ] 
      }, 
      "type": "Function" 
} 

Answer 2

Il y a aussi une façon pour le faire en utilisant le langage de définition de workflow. (https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-workflow-definition-language). En utilisant les fonctions string et replace vous pouvez travailler sur votre json comme une chaîne plutôt que sur des objets.

Voici une action Flat_List qui suit une action Parse_JSON avec vos données:

Vos données:

[ 
{"Results": ["string a", "string b"]}, 
{"Results": ["string c", "string d"]} 
] 

composant Flat_List:

"Flat_List": { 
      "inputs": "@replace(replace(replace(string(body('Parse_JSON')),']},{\"Results\":[',','),'}]','}'),'[{','{')", 
      "runAfter": { 
       "Parse_JSON": [ 
        "Succeeded" 
       ] 
      }, 
      "type": "Compose" 
     }, 

Qu'est-ce qui se passe ici? Tout d'abord, nous utilisons string qui prend vos données JSON et donne:

[{"Results":["string a", "string b"]},{"Results":["string c", "string d"]}] 

Nous remplaçons tous les ]},{"Results":[ par ,. Nous remplaçons tous les }] par }. Nous remplaçons tous les [{ par {.

Nous obtenons la chaîne {"Results":["string a","string b","string c","string d"]}

Ensuite, vous êtes libre d'analyser de nouveau à JSON avec:

"Parse_JSON_2": { 
       "inputs": { 
        "content": "@outputs('Flat_List')", 
        "schema": { 
         "properties": { 
          "Results": { 
           "items": { 
            "type": "string" 
           }, 
           "type": "array" 
          } 
         }, 
         "type": "object" 
        } 
       }, 
       "runAfter": { 
        "Flat_List": [ 
         "Succeeded" 
        ] 
       }, 
       "type": "ParseJson" 
      } 

Vous pouvez le voir comme une preuve de concept de la fonction Azure peut être plus facile de re -read plus tard, mais il peut y avoir de nombreuses raisons de ne pas vouloir instancier une nouvelle fonction Azure alors que vous pouvez faire le travail dans Logic App.

Ne hésitez pas à demander plus de détails si nécessaire :)

Answer 3

Vous pouvez utiliser @body (nestedLogicApp) en dehors de la boucle for-each pour accéder à toutes les réponses imbriqué Logic Apps dans un tableau.

Answer 4

Il existe une solution plus simple, fonctionnant avec des variables de tableau. Au niveau supérieur, en dehors de la boucle For Each, Déclarez une variable avec une action InitializeVariable:

"Initialize_Items_variable": { 
    "inputs": { 
     "variables": [ 
      { 
       "name": "Items", 
       "type": "Array", 
       "value": [] 
      } 
     ] 
    }, 
    "runAfter": {}, 
    "type": "InitializeVariable" 
} 

A l'intérieur du Pour chaque, utilisez une action AppendToArrayVariable. Vous pouvez ajouter l'objet Response de l'application Logic imbriquée que vous venez d'appeler.

"Append_to_Items_variable": { 
    "inputs": { 
     "name": "Items", 
     "value": "@body('Nested_Logic_App_Response')" 
    }, 
    "runAfter": { 
    }, 
    "type": "AppendToArrayVariable" 
} 

Espérons que cela aide.