Créer des mappages pour transformer des données dans Azure Logic Apps à l’aide de Visual Studio Code

S’applique à : Azure Logic Apps (Standard)

Pour échanger des messages qui ont des formats différents XML ou JSON dans un workflow Azure Logic Apps, vous devez passer les données d’un format à l’autre, en particulier si vous avez des lacunes entre les structures de schéma source et cible. La transformation des données vous aide à combler ces lacunes. Pour cette tâche, vous devez créer un mappage qui définit la transformation entre les éléments de données des schémas source et cible.

Pour créer et modifier visuellement un mappage, vous pouvez utiliser 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 XSLT en utilisant des mouvements de glisser-déplacer, une bibliothèque de fonctions prédéfinies pour créer des expressions, et un moyen de tester manuellement les mappages que vous créez et utilisez 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 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, sélectionner des éléments de schéma pour démarrer le mappage, créer différents mappages, enregistrer et tester votre carte, enfin appeler le mappage à partir d’un workflow dans votre projet d’application logique.

Limitations et problèmes connus

• 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 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.

• Mappeur de données ne prend pas en charge actuellement les fichiers (.csv) de valeurs séparées par des virgules.

• Le volet mode Code du Mappeur de données est actuellement en lecture seule.

• La disposition du mappage et la position des éléments sont actuellement automatiques et en lecture seule.

• Pour appeler des mappages créés avec l’outil 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 l’outil Mappeur de données, mais dans le Portail Azure, vous devez les ajouter directement à la ressource de votre application logique Standard.

Prérequis

• 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 moins 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 projet d’application logique Standard local, et un workflow avec 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.

• Pour utiliser la fonction Run XSLT, vos extraits XSLT doivent exister dans des fichiers qui utilisent l’extension de nom de fichier .xml ou .xslt. Vous devez placer vos extraits XSLT dans le dossier InlineXslt de la structure de dossier de votre projet local : Artefacts>DataMapper>Extensions>InlineXslt. Si cette structure de dossier n’existe pas, créez les dossiers manquants.

Créer un mappage de données

1. Dans le menu de gauche de Visual Studio Code, sélectionnez l’icône Azure.

2. Dans le volet Azure, sous la section Mappeur de données, sélectionnez Créer un mappage de données.

   

3. Indiquez un nom pour votre mappage de données.

4. Spécifiez vos schémas source et cible en suivant ces étapes :

   1. Sur la surface de mappage, sélectionnez Ajouter un schéma source.

      

   2. Dans le volet Configurer qui s’ouvre, sélectionnez Ajouter nouveau>Parcourir.

   3. Recherchez et sélectionnez votre fichier de schéma source, puis sélectionnez Ajouter.

      Si votre schéma source ne s’affiche pas dans la fenêtre Ouvrir, dans la liste des types de fichier, remplacez Fichier XSD (*.xsd) par Tous les fichiers (*.*).

      La surface de mappage affiche désormais les types de données du schéma source. Pour les exemples de ce guide,

   4. Sur la surface de mappage, sélectionnez Ajouter un schéma cible.

   5. Dans le volet Configurer qui s’ouvre, sélectionnez Ajouter nouveau>Parcourir.

   6. Recherchez et sélectionnez votre fichier de schéma cible, puis sélectionnez Ajouter.

      Si votre schéma cible ne s’affiche pas dans la fenêtre Ouvrir, dans la liste des types de fichier, remplacez Fichier XSD (*.xsd) par Tous les fichiers (*.*).

      La surface de mappage affiche désormais les types de données du schéma cible.

   Vous pouvez également ajouter vos fichiers de schéma source et cible localement à votre projet d’application logique dans le dossier Artifacts/Schemas, pour qu’ils s’affichent dans Visual Studio Code. Dans ce cas, vous pouvez spécifier vos schémas source et cible dans l’outil Mappeur de données dans le volet Configurer en sélectionnant Sélectionner existant au lieu de Ajouter nouveau.

   Une fois que vous avez terminé, votre mappage ressemble à l’exemple suivant :

   

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

Symbole	Type	Plus d’informations
	Tableau	Contient des éléments ou des nœuds d’élément répétitifs
	Binaire
	Bool	True ou False uniquement
	Complex	Objet XML avec des propriétés enfants, similaire au type d’objet JSON
	DateTime
	Décimal
	Entier	Nombres entiers uniquement
	Null	Ce n’est pas un type de données, mais s’affiche en cas d’erreur ou de type non valide
	Numéro	Entier JSON ou décimal
	Objet	Objet JSON avec des propriétés enfants, similaire au type XML Complexe
	String

Parcourir le mappage

Pour vous déplacer dans le mappage, vous avez les options suivantes :

• Pour faire un panoramique, faites glisser votre pointeur autour de la surface du mappage. Sinon, maintenez enfoncée la roulette de la souris pendant que vous déplacez la souris ou le trackball.

• Quand vous descendez d’un niveau dans le mappage, en bas à gauche, une barre de navigation s’affiche avec les options suivantes :

  

  Option	Autre mouvement
  Faire un zoom arrière	Sur la surface du mappage, appuyez sur Maj + deux clic. -ou- Faites défiler vers le bas avec la roulette de la souris.
  Faire un zoom avant	Sur la surface du mappage, cliquez deux fois. -ou- Faites défiler vers le haut avec la roulette de la souris.
  Zoom d'ajustement	None
  Afficher (masquer) le minimap	None

• Pour monter d’un niveau dans le mappage, dans le chemin de navigation en haut du mappage, sélectionnez un niveau précédent.

Sélectionner les éléments cible et source à mapper

1. Sur la surface du mappage, en commençant à droite, dans la zone du schéma cible, sélectionnez l’élément cible à mapper. Si l’élément souhaité est un enfant d’un élément parent, recherchez et développez d’abord le parent.

2. Maintenant, sur le côté gauche, dans la zone du schéma source, sélectionnez Sélectionner un élément.

3. Dans la fenêtre Schéma source qui s’affiche, sélectionnez un ou plusieurs éléments sources à afficher sur le mappage.

   • Pour inclure un parent et des enfants directs, ouvrez le menu contextuel du parent, puis sélectionnez Ajouter des enfants.

   • Pour inclure un parent et tous les enfants de ce parent, y compris les sous-parents, ouvrez le menu contextuel du parent de niveau supérieur, puis sélectionnez Ajouter des enfants (récursif).

4. Quand vous avez terminé, vous pouvez fermer la fenêtre du schéma source. Vous pouvez toujours ajouter d’autres éléments sources par la suite. Dans le mappage, en haut à gauche, sélectionnez Afficher le schéma source ().

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

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

1. Pour passer en revue ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappage, sélectionnez Afficher le code.

2. Si vous ne l’avez pas déjà fait, sur le mappage, sélectionnez les éléments cibles, puis les éléments sources que vous souhaitez mapper.

3. Déplacez votre pointeur sur l’élément source pour faire apparaître un cercle et un signe plus (+).

   

4. Faites glisser une ligne vers l’élément cible pour que la ligne se connecte au cercle qui s’affiche.

   

   Vous avez maintenant créé un mappage direct entre les deux éléments.

   

   La fenêtre du mode Code reflète la relation de mappage que vous avez créée :

   

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

En cas de transformation plus complexe 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 pour effectuer les tâches de cette transformation.

Le tableau suivant liste les groupes de fonctions disponibles et des exemples de fonctions que vous pouvez utiliser :

Sur le mappage, l’étiquette de la fonction ressemble à l’exemple suivant et suit un code de couleur en fonction du groupe de fonctions. À gauche du nom de la fonction, il y a le symbole correspondant. À droite du nom de la fonction, il y a le symbole du type de données de sortie.

Ajouter une fonction sans relation de mappage

L’exemple de cette section transforme le type d’élément source Chaîne en type DateHeure, qui est le type d’élément cible. L’exemple utilise la fonction En date, qui prend une seule entrée.

1. Pour passer en revue ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappage, sélectionnez Afficher le code.

2. Si vous ne l’avez pas déjà fait, sur le mappage, sélectionnez les éléments cibles, puis les éléments sources que vous souhaitez mapper.

3. En haut à gauche du mappage, sélectionnez Afficher les fonctions ().

   

4. Dans la liste des fonctions qui s’ouvre, recherchez et sélectionnez la fonction que vous souhaitez utiliser, ce qui ajoute la fonction au mappage. Si la fonction ne s’affiche pas sur le mappage, essayez de faire un zoom arrière sur la surface du mappage.

   Cet exemple sélectionne la fonction En date. Vous pouvez également rechercher et sélectionner des fonctions personnalisées de la même manière. Pour obtenir plus d’informations, consultez Créer une fonction personnalisée.

   

   Remarque

   Si aucune ligne de mappage n’existe ou n’est sélectionnée quand vous ajoutez une fonction au mappage, la fonction s’affiche sur le mappage, mais elle est déconnectée de tout élément ou toute autre fonction, par exemple :

   

5. Développez la forme de la fonction pour afficher les détails et les points de connexion de la fonction. Pour développer la forme de fonction, sélectionnez l’intérieur de la forme.

6. Connectez la fonction aux éléments source et cible.

   1. Faites glisser le curseur de la souris et dessinez une ligne entre les éléments sources et le bord gauche de la fonction. Vous pouvez commencer à partir des éléments sources 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.

      

7. Sous l’onglet Propriétés de la fonction, confirmez ou modifiez l’entrée à utiliser.

   

   Pour certains types de données, comme les tableaux, l’étendue de la transformation peut également s’afficher comme disponible. Cette étendue est généralement l’élément immédiat, par exemple, un tableau, mais dans certains scénarios, l’étendue peut exister au-delà de l’élément immédiat.

   La fenêtre du mode Code reflète la relation de mappage que vous avez créée :

   

Par exemple, pour itérer au sein des éléments de tableau, consultez Créer une boucle entre des tableaux. Pour effectuer une tâche quand la valeur d’un élément répond à une condition, consultez Ajouter une condition entre des éléments.

Ajouter une fonction à une relation de mappage existante

Quand il y a déjà une relation de mappage entre des éléments source et cible, vous pouvez ajouter la fonction en suivant ces étapes :

1. Sur le mappage, sélectionnez la ligne du mappage que vous avez créé.

2. Déplacez votre pointeur sur la ligne sélectionnée, puis sélectionnez le signe plus (+) Insérer une fonction qui s’affiche. Par exemple :

   

3. Dans la liste de fonctions qui s’ouvre, recherchez et sélectionnez la fonction que vous souhaitez utiliser.

   La fonction s’affiche sur le mappage, et est automatiquement connectée entre les éléments source et cible.

Ajouter une fonction avec plusieurs entrées

L’exemple de cette section concatène plusieurs types d’éléments sources afin que vous puissiez mapper les résultats au type d’élément cible. L’exemple utilise la fonction Concaténer, qui prend plusieurs entrées.

1. Pour passer en revue ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappage, sélectionnez Afficher le code.

2. Si vous ne l’avez pas déjà fait, sur le mappage, sélectionnez les éléments cibles, puis les éléments sources que vous souhaitez mapper.

3. En haut à gauche du mappage, sélectionnez Afficher les fonctions ().

   

4. Dans la liste des fonctions qui s’ouvre, recherchez et sélectionnez la fonction que vous souhaitez utiliser, ce qui ajoute la fonction au mappage. Si la fonction ne s’affiche pas sur le mappage, essayez de faire un zoom arrière sur la surface du mappage.

   Cet exemple sélectionne la fonction Concaténer :

   

   Remarque

   Si aucune ligne de mappage n’existe ou n’est sélectionnée quand vous ajoutez une fonction au mappage, la fonction s’affiche sur le mappage, mais elle est déconnectée de tout élément ou toute autre fonction. Si la fonction nécessite une configuration, un point rouge s’affiche en haut à droite de la fonction, par exemple :

   

5. Développez la forme de la fonction pour afficher les détails et les points de connexion de la fonction. Pour développer la forme de fonction, sélectionnez l’intérieur de la forme.

6. Dans le volet d’informations de la fonction, sous l’onglet Propriétés, sous Entrées, sélectionnez les éléments de données sources à utiliser comme entrées.

   Cet exemple sélectionne les éléments sources FirstName et LastName comme entrées de fonction, ce qui ajoute automatiquement les connexions respectives sur le mappage.

   

7. 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.

   

   La fenêtre du mode Code reflète la relation de mappage que vous avez créée :

   

Créer une boucle entre des tableaux

Si vos schémas source et cible comprennent des tableaux, vous pouvez créer une relation de mappage de boucle qui itère au sein des éléments de ces tableaux. L’exemple de cette section effectue une boucle dans un tableau source Employee et un tableau cible Person.

1. Pour passer en revue ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappage, sélectionnez Afficher le code.

2. Sur le mappage, dans la zone du schéma cible, sélectionnez le tableau cible et les éléments du tableau cible que vous souhaitez mapper.

3. Sur le mappage, dans la zone du schéma cible, développez le tableau cible et les éléments du tableau.

4. Dans la zone du schéma source, ajoutez le tableau source et les éléments du tableau au mappage.

5. Créez un mappage direct entre les éléments source et cible.

   

   Quand vous créez une relation de mappage entre une paire correspondante d’éléments de tableau, une relation de mappage est automatiquement créée au niveau du tableau parent.

   

   La fenêtre du mode Code reflète la relation de mappage que vous avez créée :

   

6. Continuez à mapper les autres éléments de tableau.

   

Configurer une condition et une tâche à exécuter entre les éléments

Pour ajouter une relation de mappage qui évalue une condition et effectue une tâche quand la condition est remplie, vous pouvez utiliser plusieurs fonctions, comme la fonction Si, une fonction de comparaison comme Supérieur à et la tâche à effectuer comme Multiplier.

L’exemple de cette section calcule une remise à appliquer quand la quantité d’achat dépasse 20 éléments en utilisant les fonctions suivantes :

• Supérieur à : vérifie si la quantité d’éléments est supérieure à 20.
• Si : vérifie si la fonction Supérieur à renvoie true.
• Multiplier : calcule la remise en multipliant le prix de l’article par 10 % et la quantité d’articles.

1. Pour passer en revue ce qui se passe dans le code quand vous créez un mappage, en haut à droite du mappage, sélectionnez Afficher le code.

2. Si vous ne l’avez pas déjà fait, sur le mappage, sélectionnez les éléments cibles, puis les éléments sources que vous souhaitez mapper.

   Cet exemple sélectionne les éléments suivants :

   

3. En haut à gauche du mappage, sélectionnez Afficher les fonctions ().

4. Ajoutez les fonctions suivantes au mappage : Supérieur à, Si et Multiplier

5. Développez toutes les formes de fonction pour afficher les détails et les points de connexion des fonctions.

6. Connectez les éléments sources, les fonctions et les éléments cibles de la façon suivante :

   • L’élément ItemPrice du schéma source à l’élément ItemPrice du schéma cible
   • L’élément ItemQuantity du schéma source au champ Valeur de la fonction Supérieur à
   • La sortie de la fonction Supérieur à au champ Condition de la fonction Si
   • L’élément ItemPrice du schéma source au champ Multiplicande 0* de la fonction Multiplier
   • La sortie de la fonction Multiplier au champ Valeur de la fonction Si
   • La sortie de la fonction Si à l’élément ItemDiscount du schéma cible

   Notes

   Dans la fonction Si, le mot N’IMPORTE LEQUEL s’affiche à droite du nom de la fonction, indiquant que vous pouvez attribuer la valeur de sortie à ce que vous voulez.

7. Dans les fonctions suivantes, sous l’onglet Propriétés, spécifiez les valeurs suivantes :

   Fonction	Paramètre et valeur d’entrée
   Une échelle plus grande	- Valeur n° 1 : l’élément source nommé ItemQuantity - Valeur n° 2 : 20
   Multiplier	- Multiplicande n° 1 : l’élément source nommé ItemPrice - Multiplicande n° 2 : 0,10
   If	- Condition : est-supérieur-à(ItemQuantity,20) - Valeur : multiplier(ItemPrice, 0,10)

   Le mappage suivant montre l’exemple terminé :

   

   La fenêtre du mode Code reflète la relation de mappage que vous avez créée :

   

Enregistrer votre mappage

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

Visual Studio Code enregistre votre mappage sous les artefacts suivants :

• Un fichier <your-map-name>.yml dans le dossier de projet Artifacts>MapDefinitions
• Un fichier <your-map-name>.xslt dans le dossier de projet Artifacts>Maps

Générer un fichier XSLT à un moment quelconque

Pour générer le fichier <your-map-name>.xslt à tout moment, sélectionnez Générer un fichier XSLT sur la barre d’outils de mappage.

Tester votre mappage

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

1. Avant de tester votre mappage, veillez à générer le plus récent fichier <your-map-name>.xslt.

2. Dans la barre d’outils de votre mappage, sélectionnez Tester.

3. Dans le volet Tester le mappage, dans la fenêtre Entrée, collez vos exemples de données d’entrée, puis sélectionnez Tester.

   Le volet de test bascule vers l’onglet Sortie et affiche le code d’état et le corps de la réponse du test.

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

1. Dans le menu de gauche de Visual Studio Code, sélectionnez Explorateur (icône de fichiers) pour voir la structure de votre projet d’application logique.

2. Développez le dossier qui a le nom de votre workflow. Dans le menu contextuel du fichier workflow.json, sélectionnez Ouvrir le concepteur.

3. Sur le concepteur de workflow, suivez ces étapes générales pour ajouter l’action intégrée Opérations du mappeur de données nommée Transformer en utilisant le mappeur de données XSLT.

4. Sur le concepteur, sélectionnez l’action Transformer en utilisant le mappeur de données XSLT.

5. Dans le volet d’informations de l’action qui s’affiche, spécifiez la valeur Contenu et laissez Source de mappage définie sur Application logique. Dans la liste Nom du mappage, sélectionnez le fichier de mappage (.xslt) que vous souhaitez utiliser.

   

   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.

Créer une fonction personnalisée

Pour créer votre propre fonction que vous pouvez utiliser avec l’outil Mappeur de données, suivez ces étapes :

1. Créez un fichier XML (.xml) ayant un nom explicite qui décrit l’objet de votre 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.

2. Dans votre fichier XML, vous devez utiliser le schéma suivant pour la définition de fonction :

   <?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>
   

   Chaque élément XML nommé « fonction » implémente une fonction de style XSLT3.0 avec quelques attributs de plus. La liste des fonctions du Mappeur de données inclut le nom de fonction, la description, les noms et les types de paramètre.

   L’exemple suivant illustre l’implémentation d’un fichier SampleFunctions.xml :

   <?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>
   

3. Sur votre ordinateur local, ouvrez le dossier pour votre projet d’application logique Standard.

4. Ouvrez le dossier Artifacts, puis créez la structure de dossier suivantes, si aucune n’existe : DataMapper>Extensions>Fonctions.

5. Dans le dossier Fonctions, enregistrez le fichier XML de votre fonction.

6. Pour trouver votre fonction personnalisée dans la liste de fonctions de l’outil Mappeur de données, recherchez votre fonction ou développer la collection Fonctions personnalisées.

Étapes suivantes

• Pour les transformations de données avec des opérations B2B dans Azure Logic Apps, consultez Ajouter des mappages pour des transformations dans les workflows avec Azure Logic Apps