web-dev-qa-db-fra.com

Analyser le texte dans les applications Azure Logic

Je souhaite créer Azure Logic App qui demandera en permanence un site Web spécifique sur Internet et analysera le code HTML reçu.

J'ai créé Logic App et configuré des actions d'intervalle et de requête HTTP.

Quelle action devrais-je choisir comme prochaine étape pour une opération regex simple sur du code HTML?

Ce qui me vient à l’esprit, c’est de créer Azure Function qui fera le travail, mais je me demande s’il existe une autre solution plus adaptée à cette tâche.

Je veux que ce soit aussi simple que possible.

Modifier:  

Je viens de découvrir une fonctionnalité intéressante. Les applications logiques contiennent des expressions de base pour les types primitifs.

Malheureusement, il manque aucune regex ou string.contains.

Pour le moment, je vais essayer avec Azure Functions.

azureazure-logic-apps
5
pizycki

J'ai réussi à résoudre mon problème avec l'utilisation de Langage de définition de flux de travail et des blocs de construction fournis par Azure.

L'idée de la fonction Azure n'était pas si mauvaise et elle conviendrait parfaitement à toute affaire plus complexe, mais comme je l'ai mentionné, je la voulais aussi simple que possible.

Voici à quoi ressemble mon flux maintenant.

Par souci d'exhaustivité, voici le flux au format JSON

{
    "$connections": {
        "value": {
            "wunderlist": {
                "connectionId": "/subscriptions/.../providers/Microsoft.Web/connections/wunderlist",
                "connectionName": "wunderlist",
                "id": "/subscriptions/.../providers/Microsoft.Web/locations/northeurope/managedApis/wunderlist"
            }
        }
    },
    "definition": {
        "$schema": "https://schema.management.Azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "Condition": {
                "actions": {
                    "Create_a_task": {
                        "inputs": {
                            "body": {
                                "completed": false,
                                "list_id": 000000000,
                                "starred": true,
                                "title": "@{variables('today date')}"
                            },
                            "Host": {
                                "connection": {
                                    "name": "@parameters('$connections')['wunderlist']['connectionId']"
                                }
                            },
                            "method": "post",
                            "path": "/tasks",
                            "retryPolicy": {
                                "type": "none"
                            }
                        },
                        "limit": {
                            "timeout": "PT20S"
                        },
                        "runAfter": {},
                        "type": "ApiConnection"
                    },
                    "Set_a_reminder": {
                        "inputs": {
                            "body": {
                                "date": "@{addHours(utcNow(), 3)}",
                                "list_id": 000000,
                                "task_id": "@body('Create_a_task')?.id"
                            },
                            "Host": {
                                "connection": {
                                    "name": "@parameters('$connections')['wunderlist']['connectionId']"
                                }
                            },
                            "method": "post",
                            "path": "/reminders",
                            "retryPolicy": {
                                "type": "none"
                            }
                        },
                        "limit": {
                            "timeout": "PT20S"
                        },
                        "runAfter": {
                            "Create_a_task": [
                                "Succeeded"
                            ]
                        },
                        "type": "ApiConnection"
                    }
                },
                "expression": "@contains(body('HTTP'), variables('today date'))",
                "runAfter": {
                    "Initialize_variable": [
                        "Succeeded"
                    ]
                },
                "type": "If"
            },
            "HTTP": {
                "inputs": {
                    "method": "GET",
                    "uri": "..."
                },
                "runAfter": {},
                "type": "Http"
            },
            "Initialize_variable": {
                "inputs": {
                    "variables": [
                        {
                            "name": "today date",
                            "type": "String",
                            "value": "@{utcNow('yyyy/MM/dd')}"
                        }
                    ]
                },
                "runAfter": {
                    "HTTP": [
                        "Succeeded"
                    ]
                },
                "type": "InitializeVariable"
            }
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
        "parameters": {
            "$connections": {
                "defaultValue": {},
                "type": "Object"
            }
        },
        "triggers": {
            "Recurrence": {
                "recurrence": {
                    "frequency": "Day",
                    "interval": 1,
                    "startTime": "2017-08-01T23:55:00Z",
                    "timeZone": "UTC"
                },
                "type": "Recurrence"
            }
        }
    }
}
0
pizycki

créer une fonction Azure à l'instar de:

{

log.Info ("La fonction de déclencheur HTTP C # a traité une requête.");

// Get request body

dynamic data = await req.Content.ReadAsAsync<object>();



// Set name to query string or body data

string input = data?.input.ToString();

var regexJson = data?.regexList;

var regexes = regexJson.ToObject<List<RegexReplace>>();



foreach (var regex in regexes) 

{

    var re = Regex.Replace(regex.Regex, "\\\\","\\");

    var replace = Regex.Replace(regex.Replace, "\\\\","\\");

    input = Regex.Replace(input, "\\\"","\"");

    input = Regex.Replace(input, re, replace);

}



input = Regex.Replace(input, "[\\r\\n]", "");



return data.regexList == null

    ? req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a name on the query string or in the request body")

    : req.CreateResponse(HttpStatusCode.OK, input, "application/json");

}

classe publique RegexReplace 

{

public string Regex { get; set; }

public string Replace { get; set; }

}

1
sandeep talabathula

Vous êtes probablement sur la bonne voie. Une fonction Azure serait le moyen le plus approprié d'implémenter cela maintenant. Une application API est une option, mais c'est une plate-forme plus lourde que nécessaire.

0
Johns-305

C'est ma fonction à utiliser pour remplacer du texte dans une chaîne. ceci est réutilisable et l'approche peut être utilisée pour de nombreux aspects similaires du travail dans Logic Apps:

using System.Net;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log)
{
    dynamic data = await req.Content.ReadAsAsync<object>();
    string removeme = data?.removeme;
    string replacewith = data?.replacewith;
    string value = data?.value;

    return req.CreateResponse(HttpStatusCode.OK, value.Replace(removeme, replacewith));
}

Je voudrais ensuite poster un objet comme celui-ci à partir de mon application logique:

{
    "removeme": "SKU-",
    "replacewith": "P-",
    "value": "SKU-37378633"
}

... pour obtenir le résultat: "P-37378633"

0
Stephen Anderson