Créer des mappages pour transformer des données dans les flux de travail d’application logique à l’aide de Visual Studio Code

S’applique à : Azure Logic Apps (Standard)

Lorsque vous échangez des messages qui utilisent différents formats XML ou JSON dans un flux de travail d’application logique, vous devez spécifier comment transformer ou convertir les données du format source au format cible, par exemple entre des documents XML ou entre des documents JSON. Cette tâche est particulièrement importante lorsqu'il existe des écarts entre les structures de données des schémas source et cible. Un schéma décrit les éléments de données, les attributs et les types de données dans un document XML ou JSON.

Pour définir les transformations entre les structures de données et combler les lacunes, vous pouvez créer une carte (fichier .xslt) qui spécifie les relations entre les éléments de données dans les schémas source et cible. Vous pouvez créer ou modifier visuellement un mappage, en utilisant Visual Studio Code avec l’extension Azure Logic Apps (Standard) dans le contexte d’un projet d’application logique Standard. L’outil Mappeur de données fournit une expérience unifiée pour le mappage et la transformation en utilisant des mouvements de glisser-déplacer, des fonctions prédéfinies pour la création d’expressions, et un moyen de tester manuellement les mappages avant que vous ne les utilisiez dans vos workflows.

Après avoir créé votre mappage, vous pouvez l’appeler directement à partir d’un workflow dans votre projet d’application logique ou d’un workflow d’application logique Standard dans le portail Azure. Pour cette tâche, vous pouvez utiliser l’action Opérations du mappeur de données nommée Transformer en utilisant le mappeur de données XSLT dans votre workflow.

Ce guide pratique montre comment créer une carte de données vide, choisir vos schémas source et cible, créer différents types de mappages entre les éléments du schéma, enregistrer et tester votre carte, enfin appeler le mappage à partir d’un workflow dans votre projet d’application logique.

Limitations et problèmes connus

Mappeur de données est actuellement disponible uniquement dans Visual Studio Code, pas dans le Portail Azure. Il est disponible uniquement dans des projets d’application logique Standard, pas des projets d’application logique Consommation.

L’expérience frontale pour Data Mapper est disponible en tant que open source dans le référentiel GitHub public pour l’équipe Azure Logic Apps. Pour plus d’informations, consultez les ressources suivantes :
- Bienvenue dans l’expérience utilisateur Azure Logic Apps
- Expérience utilisateur du mappeur de données nouvelle et améliorée dans Azure Logic Apps
L’outil Mappeur de données fonctionne actuellement uniquement dans Visual Studio Code s’exécutant sur des systèmes d’exploitation Windows.
Mappeur de données ne prend pas en charge actuellement les schémas qui utilisent le format de fichier (.csv) de valeurs séparées par des virgules.
Le volet Code dans Mappeur de données est actuellement en lecture seule.
Sur l’aire du mappeur de données, la disposition et les positions des fonctions sont mobiles, mais les nœuds de schéma sont statiques.
La fonction Filtre traite correctement les conditions numériques placées entre guillemets doubles, par exemple « >=10 ». Toutefois, cette fonction ne se comporte actuellement pas de manière cohérente pour les comparaisons de chaînes telles qu’une vérification indiquant si un nom d’élément est « = « Pen » ».
Lorsque vous créez une correspondance entre les éléments du tableau parent dans les schémas source et cible, le mappeur ajoute automatiquement une boucle pour itérer à travers les éléments du tableau. Cependant, vous devez toujours créer explicitement des correspondances entre les éléments des tableaux source et cible.
Pour appeler des mappages créés avec Mappeur de données, vous pouvez uniquement utiliser l’action Opérations du mappeur de données nommée Transformer en utilisant le mappeur de données XSLT. Pour les mappages créés par un autre outil, utilisez l’action Opérations XML nommée Transformer XML.
Pour utiliser les mappages créés avec Mappeur de données avec des flux de travail dans le Portail Azure, vous devez les ajouter directement à la ressource de votre application logique Standard.

Pour les bogues non bloquants ou les demandes de fonctionnalités, ouvrez un élément avec l’étiquette Data Mapper dans le référentiel GitHub pour l’équipe Azure Logic Apps.

Prérequis

Un compte et un abonnement Azure. Si vous n’avez pas encore d’abonnement, vous pouvez vous inscrire pour obtenir un compte Azure gratuitement.
Visual Studio Code et l’extension Azure Logic Apps (Standard) pour créer des workflows d’application logique Standard.

Remarque

L’extension Mappeur de données précédemment distincte est désormais fusionnée avec l’extension Azure Logic Apps (Standard). Pour éviter les conflits, toute version existante de l’extension Mappeur de données est supprimée lorsque vous installez ou mettez à jour l’extension Azure Logic Apps (Standard). Après l’installation ou la mise à jour de l’extension, veuillez redémarrer Visual Studio Code.
Fichiers de schéma source et cible qui décrivent les types de données à transformer. Ces fichiers peuvent avoir les formats suivants :
- Un fichier de définition de schéma XML avec l’extension de fichier .xsd
- Un fichier JSON (JavaScript Object Notation) avec l’extension de fichier .json
Un projet d’application logique Standard qui inclut un workflow avec ou sans état, avec au minimum un déclencheur. Si vous n’avez pas de projet, suivez ces étapes dans Visual Studio Code :
1. Connectez-vous à votre compte Azure si ce n’est pas déjà fait.
2. Créez un dossier local, un espace de travail et un projet d’application logique Standard, ainsi qu’un flux de travail avec état ou sans état. Pendant la création du workflow, sélectionnez Ouvrir dans la fenêtre actuelle.
Échantillonnez les données d’entrée si vous voulez tester le mappage et vérifier que la transformation fonctionne comme prévu.

Créer un mappage de données

Dans Visual Studio Code, ouvrez le dossier pour votre projet d’application logique Standard.
Dans le menu de gauche de Visual Studio Code, sélectionnez l’icône Azure.
Dans la fenêtre Azure, sous Data Mapper, sélectionnez Créer un mappage de données.

Dans la barre de titre de Visual Studio Code, une fenêtre d'invite s'ouvre pour vous permettre de donner un nom à votre carte.
Dans la zone d’invite, entrez un nom pour la carte.

Pour ce guide, ces étapes utilisent le nom Example-data-map.

Le Data Mapper crée et ouvre une carte de données vierge.
Choisissez vos schémas source et cible en suivant ces étapes :
1. Dans le volet Source, sélectionnez Ajouter un nouveau>Parcourir pour rechercher et charger votre schéma source.
  
  Après avoir ajouté votre schéma source, le volet Source remplit l’élément XML « nœuds » pour les types de données du schéma source, par exemple :
2. Dans le volet Destination, sélectionnez Ajouter un nouveau>Parcourir pour rechercher et charger votre schéma cible.
  
  Après avoir ajouté votre schéma cible, le volet Destination remplit l’élément XML « nœuds » pour les types de données du schéma cible, par exemple :

Conseil

Si vous rencontrez des problèmes de chargement de vos schémas, vous pouvez ajouter vos fichiers de schéma source et cible au dossier Schémas des artefacts/ locaux de votre projet d’application logique. Dans ce scénario, pour spécifier votre schéma source et cible dans Mappeur de données, dans les volets Source et Destination, ouvrez la liste Sélectionner existant, plutôt que d’utiliser Ajouter un nouveau, puis sélectionnez votre schéma.

Types de données de schéma

Le tableau suivant décrit les types de données possibles qui peuvent s’afficher dans un schéma :

Symbole	Type	En savoir plus
	Complexe (tableau)	Contient des éléments ou des nœuds d’élément répétitifs. Un élément de tableau affiche également le point de connexion suivant :
	Bool	True ou False uniquement
	Complex	Objet XML avec des propriétés enfants, similaire au type d’objet JSON
	Date et heure
	Decimal
	Nombre entier	Nombres entiers uniquement
	String

Créer un mappage direct entre les éléments

Pour spécifier une transformation simple entre des éléments qui ont le même type dans les schémas source et cible, suivez ces étapes :

Pour afficher ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappeur, sélectionnez Afficher le code.
Sur l’aire du mappeur, dans le volet Source, recherchez l’élément source que vous souhaitez mapper.
- Par défaut, les éléments parents sont automatiquement développés pour afficher leurs enfants.
- Cet exemple démarre le mappage à partir de l'élément source, mais vous pouvez choisir de démarrer le mappage à partir de l'élément cible.
Déplacez le pointeur de la souris sur le cercle en regard du nom de l’élément source jusqu’à ce que le pointeur passe à un signe plus (+).

Cet exemple crée un mappage à partir de l’élément source Identification de l’employé.
Faites glisser et dessinez une ligne pour que l’élément source se connecte au cercle de l’élément cible dans le volet Destination.

Cet exemple montre comment terminer le mappage avec l’élément cible Identification, qui a le même type de données que l’élément source.

Vous avez maintenant créé un mappage direct entre les deux éléments qui ont les mêmes types de données.

Le volet Code affiche la relation de mappage que vous avez créée :

Conseil

Pour vérifier si vos mappages présentent des problèmes, sélectionnez Afficher les problèmes. Par exemple, un avertissement apparaît dans la liste Problèmes sous l’onglet Avertissements si vous créez un mappage entre des éléments qui ont des types de données incompatibles :

Créer un mappage complexe entre les éléments

Pour spécifier une transformation plus compliquée entre des éléments dans les schémas source et cible, par exemple, des éléments que vous souhaitez associer ou qui ont différents types de données, vous pouvez utiliser une ou plusieurs fonctions qui effectuent la transformation que vous souhaitez dans votre mappage.

Sur la surface de mappage, l'étiquette de fonction est codée par couleur en fonction du groupe de fonctions. Le symbole de la fonction apparaît à côté du nom de la fonction, par exemple :

La capture d’écran affiche un exemple d’étiquette de fonction.

Le tableau suivant liste les groupes de fonctions et des quelques exemples de fonctions que vous pouvez utiliser. Pour obtenir la liste complète, consultez la liste Fonctions dans Data Mapper.

Groupe	Exemples de fonctions
Collection	Moyenne, Nombre, Accès direct, Valeurs distinctes, Filtrer, Index, Jointure, Maximum, Minimum, Inverser, Trier, Sous-séquence, Somme
Conversion	En date, En entier, En nombre, En chaîne
Date et heure	Ajouter des jours, la date du jour, l'heure du jour, la date égale
Comparaison logique	Égal à, Existe, Supérieur à, Supérieur ou égal à, Si, Sinon si, Est nul, Est null, Est un nombre, Est une chaîne, Inférieur à, Inférieur ou égal à, AND logique, NOT logique, OR logique, Est différent de
Mathématique	Absolu, Ajouter, Arc tangente, Plafond, Cosinus, Diviser, Exponentiel, Exponentiel (base 10), Plancher, Diviser par entier, Log, Log (base 10), Module, Multiplier, Puissance, Arrondi, Sinus, Racine carrée, Soustraire, Tangente
Chaîne	Points de code vers chaîne, Concaténer, Contient, Se termine par, Longueur, Minuscules, Nom, Correspondances d’expressions régulières, Remplacement d’expression régulière, Remplacer, Commence par, Chaîne vers points de code, Sous-chaîne, Sous-chaîne après, Sous-chaîne avant, Tronquer, Tronquer à gauche, Tronquer à droite, Majuscules
Utilitaire	Copier, Erreur, Exécuter XPath, Format Date/Heure, Format Nombre, Exécuter XSLT

Ajouter une fonction sans mappage

L’exemple de cette section transforme des données dans l’élément source Chaîne en Date/Heure, qui est le type d’élément cible. L’exemple commence sans créer de mappage et utilise la fonction To Date, qui accepte une seule entrée.

Pour afficher ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappeur, sélectionnez Afficher le code.
Dans la liste Fonctions, recherchez et sélectionnez la fonction que vous souhaitez utiliser, ce qui ajoute la fonction à la surface de mappage. Si la liste Fonctions est réduite, dans le coin supérieur gauche du mappeur, sélectionnez l’icône de fonction ().

Cet exemple montre comment sélectionner la fonction To Date, qui se trouve dans le groupe de fonctions Conversion.

Remarque

Si aucune mappage n’existe sur la carte ou si un mappage n’est sélectionné quand vous ajoutez une fonction au mappage, la fonction s’affiche, mais n’est pas connectée aux éléments ou à toute autre fonction, par exemple :
Connectez la fonction aux éléments source et cible.
1. Faites glisser le curseur de la souris et dessinez une ligne entre l’élément source et le cercle sur le bord gauche de la fonction. Vous pouvez partir de l'élément source ou de la fonction.
2. Faites glisser le curseur de la souris et dessinez une ligne entre le bord droit de la fonction et l’élément cible. Vous pouvez commencer à partir de l’élément cible ou de la fonction.
Le volet Code affiche la relation de mappage que vous avez créée :
Sur la surface du cartographe, sélectionnez la forme de la fonction pour afficher les détails de la fonction.
Sous l’onglet Entrée, confirmez ou modifiez l’entrée à utiliser.

Certains scénarios nécessitent de définir une transformation au-delà de la paire immédiate d'éléments source et cible. Par exemple, pour définir une transformation entre une paire de tableaux et leurs éléments, vous devez créer une boucle entre les tableaux. Ou, pour effectuer une tâche quand la valeur d’un élément répond à une condition, vous devez ajouter une condition entre des éléments.

Ajouter une fonction qui utilise plusieurs entrées

L’exemple de cette section concatène plusieurs types d’éléments sources en tant qu’entrées et mappe une seule sortie à l’élément cible. L’exemple utilise la fonction Concaténer, qui accepte plusieurs entrées.

Pour afficher ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappeur, sélectionnez Afficher le code.
Dans la liste Fonctions, recherchez et sélectionnez la fonction que vous souhaitez utiliser, ce qui ajoute la fonction à la surface de mappage.

Si la liste Fonctions est réduite, dans le coin supérieur gauche du mappeur, sélectionnez l’icône de fonction ().

Cet exemple montre comment sélectionner la fonction Concat, qui se trouve dans le groupe de fonctions Chaîne.

Remarque

Si aucune mappage n’existe sur la carte ou si un mappage n’est sélectionné quand vous ajoutez une fonction au mappage, la fonction s’affiche, mais n’est pas connectée aux éléments ou à toute autre fonction, par exemple :
Sur la surface du cartographe, sélectionnez la forme de la fonction pour afficher les détails de la fonction.
Sous l’onglet Entrée, sélectionnez les éléments de schéma source à utiliser comme entrées.

Cet exemple montre comment sélectionner les éléments de schéma source FirstName et LastName comme entrées de fonction. Le mappeur ajoute automatiquement les correspondances respectives entre les éléments sources et la fonction.
Pour effectuer le mappage, faites glisser le curseur de la souris et dessinez une ligne entre le bord droit de la fonction et l’élément cible. Vous pouvez commencer à partir de l’élément cible ou de la fonction.

Le volet Code affiche les relations de mappage que vous avez créées :

Parcourir les tableaux

Si vos schémas source et cible contiennent des tableaux, vous pouvez créer une boucle pour parcourir les éléments des tableaux. L’exemple de cette section crée une boucle dans un tableau source Employé et un tableau cible Personne, ainsi que des mappages entre les éléments des tableaux.

Pour afficher ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappeur, sélectionnez Afficher le code.
Sur l’aire du mappeur, dans les volets Source et Destination, recherchez les tableaux que vous souhaitez mapper.
Faites glisser et tracez une ligne entre les deux éléments du tableau. Vous pouvez commencer à partir du volet Source ou du volet Destination.

L’exemple suivant commence à partir du volet Source et mappe les éléments Nom dans le tableau source Employé et le tableau cible Personne :

Une fois que vous avez terminé le mappage de la première paire d’éléments de tableau, le mappeur ajoute automatiquement une boucle entre les éléments parents du tableau source et cible, qui ont le type de point de connexion suivant :

L’exemple suivant met en évidence la boucle ajoutée automatiquement entre les tableaux parents source Employé et cible Personne :

Le volet Code affiche la boucle de mappage que vous avez créée :
Continuez à mapper les autres éléments de tableau, par exemple :

Évaluer une condition pour effectuer une tâche

Supposons que vous souhaitiez ajouter un mappage qui évalue une condition et exécute une tâche lorsque la condition est remplie. Pour ce scénario, vous pouvez utiliser plusieurs fonctions.

Dans l’exemple suivante, lorsque la quantité d’achat dépasse 20 éléments, le mappage calcule une remise à appliquer en utilisant les fonctions suivantes :

Groupe de fonctions	Fonction	Objectif dans cet exemple
Comparaison	Une échelle plus grande	Vérifier si la quantité achetée est supérieure à 20.
Comparaison	If	Vérifier si la fonction Supérieur à renvoie vrai.
Mathématique	Multiplier	Si la condition est vraie, multipliez le prix de l'article par 10 % pour calculer la remise.

Dans les volets Source et Destination, recherchez les éléments à mapper dans votre scénario.

Cet exemple utilise les éléments suivants :
- Volet Source : ItemPrice et ItemQuantity
- Volet Destination : ItemPrice, ItemQuantity et ItemDiscount
Dans la liste Fonctions, recherchez et sélectionnez les fonctions que vous souhaitez utiliser, ce qui ajoute les fonctions à la surface de mappage.
- Si la liste Fonctions est réduite, dans le coin supérieur gauche du mappeur, sélectionnez l’icône de fonction ().
- Si nécessaire, déplacez les formes de la fonction sur la surface du cartographe pour faciliter leur sélection.
Cet exemple ajoute les fonctions suivantes à la surface de mappage : Supérieur à, Si et Multiplier
Pour afficher ce qui se passe dans le code quand vous créez des mappages, en haut à droite du mappeur, sélectionnez Afficher le code.

Connectez les éléments sources, les fonctions et les éléments cibles dans l'ordre spécifique requis par votre scénario.

Cet exemple connecte les éléments suivants dans l'ordre spécifié pour créer correctement les mappages :

Démarrer	End
Élément source ItemPrice	Élément cible ItemPrice
Élément source ItemQuantity	Entrée d’une fonction Supérieur à sur le bord gauche de la forme. Cette entrée fournit les données du champ Valeur 1 dans les détails de la fonction.
Sortie d’une fonction Supérieur à sur le bord droit de la forme	Entrée d’une fonction Si sur le bord gauche de la forme. Cette entrée fournit les données du champ Condition dans les détails de la fonction.
Élément source ItemPrice	Entrée d’une fonction Multiplier sur le bord gauche de la forme. Cette entrée fournit les données du champ Multiplicande dans les détails de la fonction.
Sortie d’une fonction Multiplier sur le bord droit de la forme.	Entrée d’une fonction Si sur le bord gauche de la forme. Cette entrée fournit les données du champ Valeur dans les détails de la fonction.
Sortie d’une fonction Si sur le bord droit de la forme.	Élément cible ItemDiscount

L'exemple suivant montre les mappages à ce moment-là :

La capture d'écran montre la surface du mappeur, les éléments de données et les fonctions avec des mappages pour un exemple de scénario de condition.

Dans les détails de la fonction suivante, sous l’onglet Entrée, confirmez ou fournissez les valeurs suivantes :

Fonction	Champ d'entrée et valeur
Une échelle plus grande	- Valeur 1 : élément source ItemQuantity - Value 2 : 20 as a custom value
Multiplier	- Multiplicand 1: Élément source ItemPrice - Multiplicand 2: .10 comme valeur personnalisée
If	- Condition: est supérieur à(ItemQuantity, 20) - Valeur: multiplie(ItemPrice, .10)

Le mappage suivant montre l’exemple terminé :

La capture d’écran montre l’exemple de condition terminé.

Le volet Code affiche le mappage que vous avez créé :

La capture d’écran montre le volet Code avec le mappage conditionnel entre les éléments sources et cibles utilisant les fonctions Supérieur à, Multiplier et Si.

Enregistrer votre mappage

Quand vous avez terminé, dans la barre d’outils du mappage, sélectionnez Enregistrer.

Visual Studio Code enregistre votre mappage de données sous les artefacts suivants :

Un mappeur de données (<your-map-name>.lml) dans le dossier Artifacts>MapDefinitions du projet
Un mappage de données (<your-map-name>.xslt) dans le dossier de projet Artifacts>Maps

Conseil

Pour organiser vos artefacts à des niveaux plus approfondis, vous pouvez utiliser les dossiers et sous-dossiers suivants :

Artefacts/MapDefinitions
Artefacts/Schémas
Artefacts/DataMapper/Extensions/Fonctions
Artefacts/DataMapper/Extensions/InlineXslt

Tester votre mappage

Pour confirmer que la transformation fonctionne comme prévu, vous avez besoin d’exemples de données d’entrée.

Avant de tester votre mappage, enregistrez la carte pour générer un fichier <your-map-name>.xslt actuel.
Dans la barre d’outils de votre mappage, sélectionnez Ouvrir le panneau de test.
Dans le volet Tester le mappage, dans la case Échantillon de données, collez vos exemples d’entrée et sélectionnez Tester.

La zone Résultats affiche les résultats des tests.

Appeler votre mappage à partir d’un workflow dans votre projet

Dans la barre Activité de Visual Studio Code, sélectionnez Explorateur (icône de fichiers) pour voir la structure de votre projet d’application logique.
Développez le dossier qui a le nom de votre workflow. Dans le menu contextuel du fichier workflow.json, sélectionnez Ouvrir le concepteur.
Sur le concepteur de workflow, suivez ces étapes générales pour ajouter l'action intégrée Opérations de mappeur de données nommée Transformer à l'aide de Data Mapper XSLT.
Sur le concepteur, sélectionnez l’action Transformer en utilisant le mappeur de données XSLT.
Dans le volet d’informations de l’action qui s’affiche, spécifiez la valeur Contenu et laissez Source de mappage définie sur LogicApp.
Ouvrez la liste Nom de la carte, puis sélectionnez votre carte (fichier .xslt).

Pour utiliser la même action Transformer en utilisant le mappeur de données XSLT dans le Portail Azure, ajoutez le mappage à la ressource d’application logique Standard.

Exécuter XSLT à partir d’un mappage de données

Vous pouvez exécuter des extraits XSLT exécutables dans un fichier de mappage de données (.xslt) à l’aide de la fonction Exécuter XSLT . Lorsque vous utilisez cette fonction, vous obtenez un fichier de mappage de données qui contient le XSLT exécutable réel. Le fichier Data Mapper (.lml) contient une référence au fichier XSLT exécutable (.xslt ou .xml).

Pour effectuer cette tâche, procédez comme suit :

Créez un fichier de mappage de données (.xslt ou .xml) qui contient l’extrait de code XSLT exécutable que vous souhaitez exécuter.
Placez ou déplacez le fichier d’extrait de code XSLT dans le dossier de projet suivant :

Artefacts>DataMapper\Extensions>InlineXSLT

Remarque

Si vous créez ou enregistrez ce fichier XSLT exécutable dans Visual Studio Code, le fichier apparaît automatiquement dans le dossier du projet Artifacts>Maps . Veillez à déplacer des fichiers d’extraits de code XSLT vers le dossier InlineXslt .
Ouvrez le mappage de données à partir duquel vous souhaitez exécuter le XSLT.
Dans le volet Fonctions , sous Utilitaire, sélectionnez Exécuter XSLT pour ajouter la fonction à l’aire du mappeur.
Sur l’aire du mappeur, sélectionnez Exécuter XSLT.
Dans la liste déroulante Fichier , sélectionnez le fichier .xslt exécutable que vous avez ajouté au dossier InlineXSLT , par exemple :
Connectez la fonction Exécuter XSLT au nœud de destination où vous souhaitez appliquer la logique XSLT, par exemple :

Comme la logique XSLT s’applique uniquement au nœud de destination, vous n’avez pas besoin de connecter la fonction Exécuter XSLT à un nœud source.
Testez votre carte pour vérifier que les résultats attendus apparaissent dans le schéma de destination.

Pour le déploiement, vous avez uniquement besoin du mappage de données résultant avec le XSLT exécutable inline.

Accéder aux nœuds dans l'XML imbriqué

Supposons que vous disposez d’un schéma qui a imbriqué des nœuds XML et que vous souhaitez utiliser ces nœuds de la manière suivante :

Accéder aux attributs ou aux éléments imbriqués.
Appliquez une logique basée sur la structure ou le contenu des données entrantes.

Pour effectuer ces tâches, utilisez la fonction Execute XPath :

Ouvrez la carte de données sur laquelle vous souhaitez travailler.
Dans le volet Fonctions , sous Utilitaire, sélectionnez Exécuter XPath pour ajouter la fonction à l’aire du mappeur.
Sur la surface du mappeur, sélectionnez Exécuter XPath.
Dans la zone d’expression XPATH , entrez une expression qui effectue le travail souhaité.

Pour plus d’informations sur la syntaxe d’expression, consultez syntaxe XPath.

Cet exemple utilise l’expression //Address avec une charge utile de test :

Remarque

Les barres obliques doubles (//) sélectionnent des nœuds à partir du nœud actuel qui correspondent à la sélection, quel que soit l’emplacement des nœuds.
Connectez la fonction Execute XPath au nœud de destination où vous souhaitez exécuter la fonction.

Cet exemple connecte la fonction au nœud Address dans le schéma de destination :

Remarque

Les noms de nœuds sont automatiquement placés entre guillemets doubles ( » « ).
Testez votre carte pour vérifier que les résultats attendus apparaissent dans le schéma de destination.

Cet exemple utilise une charge utile de test et produit correctement des résultats avec plusieurs nœuds Address , car le nœud Adresse source existe dans un tableau Employee , tandis que le nœud Adresse de destination existe dans un tableau Person .

Remarque

Si vous créez un mappage entre des tableaux dans les schémas source et cible, une boucle apparaît automatiquement sur l'interface du mappage pour itérer sur les éléments du tableau. Toutefois, vous devez toujours créer des mappages entre les éléments de tableau source et cible. Pour plus d’informations sur la boucle dans les tableaux, consultez Itérer au sein des tableaux.

Créer des fonctions XML personnalisées

Pour définir une logique réutilisable sur votre carte, vous pouvez créer des fonctions XML personnalisées, qui offrent les avantages suivants :

Réduisez la duplication et prenez en charge les transformations spécifiques au schéma.
Encapsuler une logique complexe dans des composants gérables.
Gérez les cas de périphérie spécifiques au schéma.

Pour créer une fonction XML personnalisée, procédez comme suit :

Créez un fichier XML (.xml) avec un nom explicite qui décrit l’objectif de votre fonction.

Votre fichier XML doit utiliser un schéma spécifique pour les définitions de fonction. Si vous avez plusieurs fonctions liées, vous pouvez utiliser un seul fichier pour ces fonctions. Bien que vous puissiez utiliser n’importe quel nom de fichier, un nom de fichier ou une catégorie explicite facilite l’identification, la recherche et la détection de vos fonctions.
Ajoutez ce fichier XML à votre projet d’application logique dans le dossier suivant :

Artefacts>DataMapper\Extensions>Fonctions
Ouvrez le mappage de données dans lequel vous souhaitez utiliser votre fonction.
Dans le volet Fonctions , sous Utilitaire, sélectionnez votre fonction personnalisée, qui apparaît désormais sur l’aire du mappeur.
Sur la surface du mappeur, sélectionnez votre fonction. Fournissez l’entrée dont la fonction a besoin pour fonctionner.
Connectez la fonction aux points de terminaison requis.

L’exemple suivant montre une fonction personnalisée nommée Age qui retourne l’âge de la date de naissance fournie. La fonction se connecte au nœud source Dat_of_Birth et au nœud autre destination. Pour passer en revue la définition de cette fonction personnalisée, consultez Examiner l’exemple de définition de fonction.
Testez votre carte pour vérifier que les résultats attendus apparaissent dans le schéma de destination, par exemple :

Vérifier le schéma d’une définition de fonction

Votre fichier XML doit utiliser le schéma suivant pour une définition de fonction. Chaque élément XML qui a le "function" nom implémente une fonction de style XSLT 3.0 avec quelques attributs supplémentaires. La liste des fonctions du Mappeur de données inclut le nom de fonction, la description, les noms et les types de paramètre.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
   <xs:element name="customfunctions">
      <xs:complexType>
         <xs:sequence>
            <xs:element maxOccurs="unbounded" name="function">
               <xs:complexType>
                  <xs:sequence>
                     <xs:element maxOccurs="unbounded" name="param">
                        <xs:complexType>
                           <xs:attribute name="name" type="xs:string" use="required" />
                           <xs:attribute name="as" type="xs:string" use="required" />
                        </xs:complexType>
                     </xs:element>
                     <xs:any minOccurs="0" />
                  </xs:sequence>
                  <xs:attribute name="name" type="xs:string" use="required" />
                  <xs:attribute name="as" type="xs:string" use="required" />
                  <xs:attribute name="description" type="xs:string" use="required" />
               </xs:complexType>
            </xs:element>
         </xs:sequence>
      </xs:complexType>
   </xs:element>
</xs:schema>

Passer en revue les exemples de définitions de fonction

Le fichier SampleFunctions.xml suivant montre l’implémentation pour les fonctions suivantes :

"age"
"custom-if-then-else"

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<customfunctions>
   <function name="age" as="xs:float" description="Returns the current age.">
      <param name="inputDate" as="xs:date"/> 
      <value-of select="round(days-from-duration(current-date() - xs:date($inputDate)) div 365.25, 1)"/>
   </function> 
   <function name="custom-if-then-else" as="xs:string" description="Evaluates the condition and returns corresponding value.">
      <param name="condition" as="xs:boolean"/>
      <param name="thenResult" as="xs:anyAtomicType"/>
      <param name="elseResult" as="xs:anyAtomicType"/>
      <choose>
         <when test="$condition">
            <value-of select="$thenResult"></value-of>
         </when>
         <otherwise>
            <value-of select="$elseResult"></value-of>
         </otherwise>
      </choose>
   </function>
</customfunctions>

Ajouter des mappages pour les transformations dans les flux de travail avec Azure Logic Apps

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2025-07-15