Exemples de stratégie Map

Exemples de définitions OpenAPI des stratégies Map .

Mappage un à un

L'exemple suivant :
  • mappe les paramètres de la requête de la demande à un objet du corps du message.
  • mappe une chaîne directement à une chaîne unique.
  • mappe une chaîne directement à un entier unique.
La définition référencée, output, définit un objet contenant une chaîne, name, et un entier, age.
      - map:
          title: 1-1 map
          inputs:
            input_string:
              schema:
                type: string
              variable: request.parameters.name_in     # the location of the variable, named "name_in" and found in the query parameters of the request
            input_integer:
              schema:
                type: integer
              variable: request.parameters.age_in    # another variable in the query parameters of the request
          outputs:
            output:
              schema:
                $ref: '#/definitions/output'    # a schema definition reference to use for the output. The schema is for the whole of the message body.
              variable: message.body
          actions:
            - set: output.name_out    # in the actions section, variables are referenced by their name within the map policy
              from: input_string      # if a value field is not used, the mapping is direct with the input value used for the output variable
            - set: output.age_out     # because the 'output' variable is itself an object, further references are made to variables that it contains
              from: input_integer

Mappage plusieurs à un

L'exemple suivant :
  • mappe les paramètres de la requête de la demande à un objet du corps du message.
  • mappe deux chaînes à une chaîne unique en les concaténant.
  • mappe deux entiers à un entier unique en les additionnant.
La définition référencée, output, définit un objet contenant une chaîne et un entier.
      - map:
          title: many-1 map
          inputs:
            input_string_1:
              schema:
                type: string
              variable: request.parameters.first_name
            input_string_2:
              schema:
                type: string
              variable: request.parameters.last_name
            input_integer_1:
              schema:
                type: integer
              variable: request.parameters.balance_1
            input_integer_2:
              schema:
                type: integer
              variable: request.parameters.balance_2
          outputs:
            output:
              schema:
                $ref: '#/definitions/output'
              variable: message.body
          actions:
            - set: output.full_name
              from:
                - input_string_1
                - input_string_2
               value: |
                 var retValue = undefined;
                 if ($(input_string_1) !== undefined && $(input_string_2) !== undefined) { 
                   retValue = $(input_string_1).toUpperCase() + ' ' + $(input_string_2).toUpperCase()"
                 }
                 retValue;
            - set: output.total_balance
              from:
                - input_integer_1
                - input_integer_2
              value:  |
                var i1 = 0;
                var i2 = 0;
                if ($(input_integer_1) !== undefined) i1 = $(input_integer_1);
                if ($(input_integer_2) !== undefined) i2 = $(input_integer_2);
                i1 + i2;

Transformation simple à l'aide de la zone de valeur

L'exemple suivant :
  • mappe un paramètre de la requête de la demande à un objet du corps du message.
  • mappe une chaîne contenant des minuscules en une chaîne unique ne contenant que des majuscules.
La définition référencée, output, définit un objet contenant une chaîne unique.
      - map:
          title: Uppercase map
          inputs:
            input_lowercase:
              schema:
                type: string
              variable: request.parameters.name_in
          outputs:
            output_uppercase:
              schema:
                $ref: '#/definitions/output'
              variable: message.body
          actions:
            - set: output_uppercase.name_out
              from: input_lowercase
              value: $(input_lowercase).toUpperCase()    # the input variable is referenced and calls the toUpperCase method to produce a value for the output variable

Mappage de plusieurs contextes dans un nouveau contexte

L'exemple suivant :
  • mappe un entier de l'en-tête de la demande à un entier d'un nouveau corps de message.
  • mappe une chaîne du corps du message au corps d'un nouveau contexte personnalisé, nommé nouveau_contexte.
      - map:
          title: Context map
          inputs:
            input_integer:
              schema:
                type: integer
              variable: request.headers.age_in      # the 'age_in' header of the request is used as an input
            input_string:
              schema:
                type: string
              variable: message.body.name_in      # as is the 'name_in' field of the request body
          outputs:
            output_integer:
              schema:
                type: integer
              variable: message.body.age_out
            output_string:
              schema:
                type: string
              variable: new_context.body.name_internal    # the context named 'new_context' is created by the map policy and exists only while the assembly is processed
          actions:
            - set: output_string
              from: input_string
            - set: output_integer
              from: input_integer

Mappage à une définition de schéma en ligne

L'exemple suivant :
  • mappe les paramètres des en-têtes de la demande à un objet du corps du message, qui est défini dans la stratégie de mappage.
  • mappe une chaîne directement à une chaîne unique.
  • mappe une chaîne directement à un entier unique.
      - map:
          title: Inline schema map
          inputs:
            input_integer:
              schema:
                type: integer
              variable: request.headers.age_in
            input_string:
              schema:
                type: string
              variable: request.headers.name_in
          outputs:
            output:
              schema:                    # instead of a simple type or a reference to a definition, an inline YAML definition is used
                type: object
                properties:
                  name_out:
                    type: string
                    name: name_out
                  age_out:
                    type: integer
                    format: int32
                    name: age_out
                title: output
              variable: message.body
          actions:
            - set: output.age_out
              from: input_integer
            - set: output.name_out
              from: input_string

Mappage avec une valeur par défaut

L'exemple suivant :
  • mappe une chaîne directement à une chaîne unique.
  • fournit une valeur par défaut pour la chaîne de sortie si aucune chaîne d'entrée valide n'est fournie.
      - map:
          title: Default Map
          inputs:
            input_string:
              schema:
                type: string
              variable: request.headers.name_in
          outputs:
            output_string:
              schema:
                type: string
              variable: message.body.name_out
          actions:
            - set: output_string
              from: input_string
              default: John Smith            # the default field is specified in the same way as a value, in this case providing a fixed value

Mappage d'un tableau dans une valeur unique

La stratégie de mappage suivante :
  • mappe un tableau d'entiers à un entier unique.
  • calcule la somme des entiers dans le tableau.
  • $(0) représente la sortie cumulée car le mappage évalue toutes les valeurs d'élément de tableau.
      - map:
          title: Summation map
          inputs:
            input:
              schema:
                $ref: '#/definitions/balance_array_in'
              variable: request.body
          outputs:
            output:
              schema:
                type: integer
              variable: message.body.total_balance_out    # instead of using a full schema definition of the message body, a single variable in the message body is specified
          actions:
            - set: output
              from: input
              foreach: input      # the foreach field specifies that each value of the array 'input' is to be iterated over
              value: $(0)+$(input) # the $(0) reference is the accumulated value of the 'output' variable

Mappage d'éléments de tableau dans un tableau

La stratégie de mappage suivante :
  • mappe un tableau, dont les éléments sont des objets contenant deux entiers, à un tableau, dont les entrées contiennent une zone d'entrée unique.
  • mappe un tableau à un matrice de même longueur.
  • utilise la différence des valeurs des entiers dans chaque élément de tableau pour créer un entier unique dans chaque élément de tableau.
      - map:
          title: Array summation
          inputs:
            input:
              schema:
                $ref: '#/definitions/balance_and_credit_array'
              variable: request.body
          outputs:
            output_array:
              schema:
                type: array
              variable: message.body
          actions:
            - create: output_array
              from: input
              foreach: input
              actions:
                - set: total_balance_out
                  from:                          # inside the actions section, variables inside the array elements being iterated over are used
                    - integer_in_1
                    - integer_in_2
                  value: $(integer_in_1)-$(integer_in_2)      # the difference of the variables is taken for each array entry of 'input'

Utilisation des options XML avancées

L'exemple suivant :
  • n'inclut pas les éléments vides dans la sortie de la stratégie de mappage
  • utilise des espaces de nom explicites plutôt qu'hérités de l'élément parent
  • indique que toutes les déclarations d'espace de nom seront placées sur l'élément XML racine
  • utilise tous les éléments de tableau plutôt que le premier uniquement
  • ignore les références de variable API Connect
  • mappe les valeurs de propriété d'entrée avec une valeur nulle au document de sortie
  • gère les références de type circulaire de façon optimisée

        actions:
            - set: output, two
              from: input, one
        options:
            includeEmptyXMLElements: false
            namespaceInheritance: false
            inlineNamespaces: false
            mapArrayFirstElementValue: false
            mapResolveApicVariables: false
            mapNullValue: true
            mapOptimizeSchemaDefinition: true
            mapCreateEmptyArray: parent

Augmentation des paramètres d'analyse de la politique de cartographie

Pour augmenter la référence aux paramètres d'analyse, vous pouvez mettre à jour la source YAML avec les paramètres d'analyse souhaités. Dans l'exemple suivant, vous pouvez mettre à jour la source YAML avec les paramètres d'analyse nécessaires.


        - map:
          version: 2.1.0
          title: map
          inputs: {}
          outputs: {}
          actions: []
          parse-settings-reference:
            parse-settings:
              document_type: detect
              max_doc_size: 8388608
              max_nesting_depth: 512
              max_width: 8192
              max_name_length: 256
              max_value_length: 8192
              max_unique_names: 1024
              max_unique_prefixes: 1024
              max_unique_namespaces: 1024
              max_number_length: 128
          options:
            mapEmulateV4EmptyJSONObject: false
            mapEmulateV4DefaultRequiredProps: true
            mapEnablePostProcessingJSON: false
            mapReferenceLimit: 1

Pour plus d'informations, voir Création de paramètres d'analyse.