Lecture d'une requête SOAP complète

David Adams

4e Dimension (version 2003 et ultérieures) propose la publication de méthodes en tant que Services Web et permet à toute application d’appeler les méthodes 4D en envoyant des messages SOAP au serveur Web natif de 4D. Le système de publication de Services Web de 4D gère toute la complexité de l’analyse, de la navigation et de la conversion de valeurs entre XML et les types natifs de 4D. ♪

- Titre : Lecture d'une requête SOAP complète

- Auteur : David Adams

- Parution : 1 juillet 2004

- Licence : Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.

Sommaire

- I. Résumé

- II. Échantillon de requête SOAP

- III. Rappel : la gestion automatique des messages SOAP

- IV. Lire la requête brute

- Lire les entêtes HTTP

- V. Application : journaliser, étudier et déboguer les requêtes

- Résumé

- Code exemple

- Suggestions

- VI. Exemple : relire des entrées non déclarées

- Description

- La gestion manuelle par rapport à la gestion automatique

- Code échantillon

- VII. Base exemple

I - Résumé

4e Dimension version 2003 et ultérieures propose en natif la publication de méthodes en tant que Services Web et permet à toute application, tout outil ou tout environnement de développement compatible Service Web d’appeler les méthodes 4e Dimension en envoyant des messages SOAP (Simple Object Access Protocol) au serveur Web natif de 4e Dimension.
Les messages SOAP suivent des règles strictes de formatage XML et d’encodage des données. Ces règles sont définies par une série de standards interdépendants.
Par défaut, le système de publication de Services Web de 4e Dimension gère toute la complexité de l’analyse, de la navigation et de la conversion de valeurs entre XML et les types natifs de 4e Dimension.

Des circonstances peuvent se présenter cependant où des développeurs souhaitent lire des messages SOAP directement.

Par exemple :

- pour déboguer des échanges SOAP ;

- pour journaliser des requêtes SOAP ;

- pour lire des entrées SOAP non liées automatiquement ;

- distinguer entre les paramètres entrants passés avec une valeur vide et ceux qui ne sont pas présents dans la requête ;

- analyser les requêtes directement grâce à la commande native Analyser variable XML ou en recourant à un parseur externe ;

- en apprendre plus sur la structure et le contenu des requêtes SOAP ;

- acquérir une meilleure compréhension du fonctionnement du serveur SOAP de 4e Dimension.

- heureusement, il est possible de lire le texte brut des messages SOAP entrants en utilisant le comportement non documenté de la commande LIRE VARIABLES FORMULAIRE WEB. Au besoin, les entêtes HTTP entrants sont accessibles grâce à la commande LIRE ENTETE HTTP.

II - Échantillon de requête SOAP

Les Services Web, en dépit de leur nom, n’ont théoriquement pas besoin de fonctionner au travers du Web. Cependant, en pratique, quasiment toutes les requêtes SOAP sont échangées au travers de HTTP, le protocole du Web 4e Dimension, comme la plupart des environnements, ne prend en charge SOAP qu’au travers de HTTP).
La distinction entre SOAP et les messages HTTP est signifiante, car les messages HTTP peuvent contenir n’importe quel type d’information, tandis qu’un message SOAP doit toujours être un document XML bien formé et se conformer aux règles des messages SOAP. Reformulé plus simplement, les messages HTTP peuvent contenir du XML alors que les messages SOAP sont du XML. Ci-dessous une requête HTTP commentée incluant un message SOAP (des espaces ont été ajoutés pour la lisibilité) :

Notes

Exemples

Entête HTTP

La ligne de requête HTTP et les entêtes sont du texte non structuré en XML. Ces valeurs peuvent être relues par la commande LIRE ENTETE HTTP.

POST /4DSOAP/ HTTP/1.1
User-Agent: 4D built-in SOAP Client
Date: Sat, 20 Dec 2003 23:43:27 GMT
Content-Type: text/xml; charset=utf-8
Host: 127.0.0.1
Connection: Close
SoapAction: « A_WebService#ConvertFeetToMeters »
Content-Length: 508

Corps HTTP/message SOAP

Le corps HTTP de la requête SOAP est un message SOAP complet. Cette donnée peut être relue en appelant la commande LIRE VARIABLES FORMULAIRE WEB puis analysée en utilisant Analyser variable XML.

<SOAP-ENV:Envelope
SOAPENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/encoding:"
xmlns:xsd="http://www.w3;org/1999/XMLSchema"
xmlns:xsi="http://www.w3;org/1999/XMLSchema-instance">
<SOAP-ENV:Body>
<mns:ConvertFeetToMeters
xmlns:mns="http://www.4d.com/namespace/default">
<inFeet xsi:type="xsd:folat">100.1</inFeet>
</mns:ConvertFeetToMeters>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>

La première partie du message ci-dessus est du pur HTTP et ne se conforme pas aux règles XML ou SOAP.
La section entête HTTP est classique et se présenterait de la même façon si les données transportées provenaient d’un formulaire, d’un document téléchargé, ou d’une requête vers une URL.
La seconde partie du message représente le corps HTTP.
Le corps d’une requête HTTP peut être vide, comprendre un fichier téléchargé, des données de champs d’un formulaire, ou toute autre chose acceptée par un serveur Web.

Dans cet exemple, le corps HTTP est un message SOAP complet, respectant toutes les règles de XML et SOAP.

Cette note technique et la base de démo qui l’accompagne montre comment reconstruire les requêtes SOAP complètes reçues par un serveur Web 4e Dimension afin d’en permettre une inspection directe.

III - Rappel : la gestion automatique des messages SOAP

Lorsque 4e Dimension reçoit une requête SOAP, il lit la section SOAP-ENV:Body du message afin de retrouver le nom de la méthode et ses paramètres d’entrée, soulignés dans l’extrait ci-dessous :

1. <mns:ConvertFeetToMeters xmlns:mns="http://www.4d.com/namespace/default">

2. <inFeet xsi:type="xsd:float">100.1</inFeet>

3. </mns:ConvertFeetToMeters>

4e Dimension extrait et convertit automatiquement les paramètres d’entrée puis appelle la méthode spécifiée, ConvertFeetToMeters dans notre exemple. Les paramètres d’entrée peuvent être recopiés dans des paramètres de méthode et/ou n’importe quelle variable ou tableau process lié par la commande DECLARATION SOAP, comme décrit dans le manuel Référence du Langage 4e Dimension. Ci-dessous le code de la méthode ConvertFeetToMeters :

1. ` ---------------------------------------

2. C_REEL($0;$meters_r)

3. C_REEL($1;$feet_r)

5. DECLARATION SOAP($0;Est un numérique ;SOAP sortie ;"outMeters")

6. DECLARATION SOAP($1;Est un numérique ;SOAP entrée ;"inFeet")

8. C_ENTIER LONG($rounding_l)

10. $rounding_l:=soap_GetRounding

12. $feet_r:=$1

14. $meters_r:=$feet_r*0,3048

15. $meters_r:=Arrondi($meters_r;$rounding_l)

17. $0:=$meters_r

18. ` ---------------------------------------

Appelé par le message SOAP listé plus haut, lorsque la $1 est automatiquement traduite en un réel valant 100,1.

IV - Lire la requête brute

Reconstruire le message SOAP Le système de traduction automatique des messages SOAP par 4e Dimension est facile à utiliser et pratique, mais très peu du message SOAP brut est apparent. Heureusement, appelée dans le contexte d’un process SOAP, LIRE VARIABLES FORMULAIRE WEB contient le texte complet de la requête originale à l’exception d’un seul signe égal. LIRE VARIABLES FORMULAIRE WEB découpe normalement les données de formulaire Web en paires nom-valeur.

Les noms des champs et leurs valeurs sont séparés par des signes « égal ». De la même façon, LIRE VARIABLES FORMULAIRE WEB découpe la requête SOAP entrante en deux parties, divisant la requête au premier signe « égal ».

Le code ci-dessous réassemble la requête SOAP initiale :

1. ` ---------------------------------------

2. `soap_GetFullRequest() : Requête SOAP complète :

3. C_TEXTE($0;$result_t)

5. $0:=""

6. $result_t:=""

8. Si (Est une requete SOAP)

10. `Ce code n'a de sens que dans un process démarré par une requête Web Service

11. TABLEAU TEXTE($names_at;0)

12. TABLEAU TEXTE($values_at;0)

13. LIRE VARIABLES FORMULAIRE WEB($names_at;$values_at)

14. $result_t:=""

15. $result_t:=$result_t+$names_at{1}

16. $result_t:=$result_t+"=" `Un signe = est retiré lorsque les items sont découpés

17. $result_t:=$result_t+$values_at{1}

19. Fin de si

21. $0:=$result_t

22. ` ---------------------------------------

En reprenant le message listé plus haut, voici les contenus de $names_at{1} et $values_at{1} :

$names_at{1}

<SOAP-ENV:Envelope
SOAP-ENV:encodingStyle

$values_at{1}

1. "http://schemas.xmlsoap.org/soap/encoding/"

2. xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"

3. xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"

4. xmlns:xsd="http://www.w3.org/1999/XMLSchema"

5. xmlns:xsi="http://www.w3.org/1999/XMLSchema-instance"

6. <SOAP-ENV:Body>

7. <mns:ConvertFeetToMeters xmlns:mns="http://www.4d.com/namespace/default">

8. <inFeet xsi:type="xsd:float">100.1</inFeet>

9. </mns:ConvertFeetToMeters>

10. </SOAP-ENV:Body>

11. </SOAP-ENV:Envelope>

Une fois rassemblé, le message SOAP original constitue un document XML bien formé et peut être parcouru par les commandes XML natives ou celles d’un plugin.

Notes et avertissements :

· La méthode soap_GetFullRequest peut être appelée de n’importe quelle méthode à l’intérieur d’un process créé par une requête à un service Web. Les résultats sont les mêmes, que le code soit appelé depuis la méthode base Sur authentification Web, Compiler_Web, la méthode projet spécifiée dans le message SOAP ou n’importe quelle autre méthode projet.

· Le comportement de LIRE VARIABLES FORMULAIRE WEB exploité par soap_GetFullRequest est non documenté et non supporté, mais ne devrait pas changer.

· La méthode soap_GetFullRequest repose sur des paramètres et des éléments de tableaux de type texte 4D, avec la limitation correspondante à 32 000 caractères. Les paramètres entrants SOAP ne sont pas limités à 32 000 caractères, ils peuvent comporter plusieurs éléments texte, des BLObs, et d’autres données relativement volumineuses. Dans le cadre d’un système acceptant des données importantes en entrée, le code ci-dessus peut ne pas fonctionner.

Lire les entêtes HTTP

En cas de besoin, la section HTTP originale de la requête peut être reconstruite avec le code suivant :

1. ` ---------------------------------------

2. C_TEXTE($headers_t)

3. $headers_t:=""

4. LIRE ENTETE HTTP($headers_t)

5. ` ---------------------------------------

V - Application : journaliser, étudier et déboguer les requêtes

Résumé

Journaliser, étudier et déboguer les messages SOAP constituent d’excellentes applications des techniques présentées dans cette note. Ci-dessous, nous décrivons quelques situations spécifiques où l’accès direct au message SOAP entrant peut se révéler utile, voire indispensable.

· Il est plus facile de résoudre des problèmes relatifs à des requêtes de Services Web en regardant le message SOAP complet. De cette façon, il est possible de déterminer si le problème provient d’appels à DECLARATION SOAP inadéquats ou manquants, de requêtes malformées d’un service Web distant, ou d’un comportement inattendu du système de traduction automatique de 4e Dimension. La capture d’entrées SOAP dans 4e Dimension est une technique de débogage utile, mais ne remplace pas toujours la capture de paquets réseau avant qu’ils n’atteignent 4e Dimension. Pour plus d’information, nous vous renvoyons à l'ouvrage « 4D Web Companion » ou à la Note Technique 4D-200308-22-FR « Détecter et suivre un problème TCP/IP ».

· Le journal du serveur Web de 4e Dimension comprend la même entrée pour toutes les requêtes vers le Service Web, comme dans l’extrait ci-dessous :

1. 209.238.253.9 - - [23/Dec/2003:17:04:31 +1100] "POST /4DSOAP/ HTTP/1.1" 200 632

Si un système nécessite de l’information plus détaillée, du code dédié peut extraire et rassembler de l’information depuis les entêtes HTTP ou le message SOAP, par exemple le nom de la méthode appelée.

Nous allons maintenant nous intéresser à un exemple de code créant une journalisation sur mesure des requêtes SOAP.

Code exemple

Dans cet exemple, le système journalise plusieurs informations pour chaque requête SOAP : l’heure, la date, l’adresse IP du client, le nom de la méthode 4e Dimension et le logiciel utilisé comme user-agent (navigateur/client). La méthode base Sur authentification Web s’exécute une fois pour chaque requête au service Web, elle constitue donc l’emplacement logique pour journaliser les requêtes SOAP.

Le code ci-dessous appelle la méthode soap_LogRequest pour exécuter la tâche d’extraction et d’enregistrement des informations de la requête :

1. ` ---------------------------------------

2. `Méthode Base : Sur Authentification Web

4. C_BOOLEEN($0;$allowRequest_b)

5. C_TEXTE($1) ` URL

6. C_TEXTE($2) ` requête HTTP (entête + corps)

7. C_TEXTE($3;$clientAddress_t) ` adresse IP Client

8. C_TEXTE($4;$serverAddress_t) ` adresse IP Serveur

9. C_TEXTE($5;$userName_t) ` nom Utilisateur

10. C_TEXTE($6) ` Mot de passe

12. $clientAddress_t:=$3

13. $serverAddress_t:=$4

14. $userName_t:=$5

16. $allowRequest_b:=Vrai

18. `la routine ci-dessous montre comment utiliser une requête complète SOAP entrante

19. Si (Est une requete SOAP)

20. ` Enregistrer la requête complète et les entêtes dans un enregistrement

21. soap_SaveRequest ("Sur authentification Web")

22. ` Extrait et enregistre les valeurs spécifiques dans un enregistrement

23. soap_LogRequest ($clientAddress_t;$serverAddress_t;$userName_t)

24. Fin de si

26. $0:=Vrai

27. ` ---------------------------------------

La méthode soap_LogRequest, reproduite ci-dessous, enregistre les informations générales de la requête, aussi bien que l’entête HTTP User-Agent et le nom de la méthode appelée comme service Web.

1. ` ---------------------------------------

2. ` soap_LogRequest

4. C_TEXTE($1;$clientAddress_t)

5. C_TEXTE($2;$serverAddress_t)

6. C_TEXTE($3;$userName_t)

8. $clientAddress_t:=$1

9. $serverAddress_t:=$2

10. $userName_t:=$3

12. Si (Est une requete SOAP)

14. ` ---------------------------------------

15. ` Installe la gestion d'erreurs

16. ` ---------------------------------------

17. C_ENTIER LONG(Error)

18. Error:=0

19. APPELER SUR ERREUR("demo_TraceErrors") ` Ouvre le débogueur en cas d'erreurs

21. ` ---------------------------------------

22. `Récupère les entêtes HTTP et extrait les valeurs souhaitées

23. ` ---------------------------------------

24. TABLEAU TEXTE($httpNames_at;0)

25. TABLEAU TEXTE($httpValues_at;0)

26. LIRE ENTETE HTTP($httpNames_at;$httpValues_at)

27. C_ENTIER LONG($index)

28. $index:=Chercher dans tableau($httpNames_at;"User-Agent") ` User-Agent signifie "navigateur" ou

29. ` "application cliente"

30. C_TEXTE($userAgent_t)

31. Si ($index>0)

32. $userAgent_t:=$httpValues_at{$index}

33. Sinon

34. $userAgent_t:=""

35. Fin de si

37. ` ---------------------------------------

38. `Récupère la requête complète SOAP et extrait les valeurs désirées

39. ` ---------------------------------------

40. C_TEXTE($soapRequest_t)

41. $soapRequest_t:=soap_GetFullRequest

43. `S'il s'agit d'une requête SOAP, les éléments sont organisés de la manière suivante :

44. ` <SOAP-ENV:Envelope

45. ` <SOAP-ENV:Body

46. ` <nom de la méthode

47. `Le code ci-dessous navigue à travers cette structure et extrait le nom de la méthode

48. C_ALPHA(16;$xmlroot;$xmlref)

49. $xmlroot:=Analyser variable XML($soapRequest_t) ` SOAP-ENV:Envelope

50. $xmlref:=$xmlroot ` Préserve la référence originale à l'arbre XML pour la repasser à FERMER XML

51. $xmlref:=Lire premier element XML($xmlref) ` SOAP-ENV:Body

52. $xmlref:=Lire premier element XML($xmlref) ` Nom de la méthode

54. C_TEXTE($methodName_t)

55. $methodName_t:=""

56. LIRE NOM ELEMENT XML($xmlref;$methodName_t)

57. FERMER XML($xmlroot)

59. `Le nom de la méthode peut être préfixé par un alias de namespace (espace de noms)

60. `, comme ceci :

61. ` mns:ConvertFeetToMeters

62. `La seule utilisation possible des ":" dans les noms XML s'applique aux préfixes de namespaces

63. `Le code suivant cherche ":" et s'il les retrouve, retire le préfixe du namespace. `

64. C_ENTIER LONG($index)

66. $index:=Position(":";$methodName_t)

67. Si ($index>0)

68. $methodName_t:=Sous chaine($methodName_t;$index+1)

69. Fin de si

71. ` ---------------------------------------

72. ` Enregistrement des données

73. ` ---------------------------------------

74. `Cette démo journalise dans un enregistrement, vous pouvez préférer utiliser un

75. `autre emplacement, comme un document

76. CREER ENREGISTREMENT([Logged_SOAP_Request])

77. [Logged_SOAP_Request]ID:=Numerotation automatique([Logged_SOAP_Request])

78. [Logged_SOAP_Request]Request_Date:=Date du jour(*)

79. [Logged_SOAP_Request]Request_Time:=Heure courante(*)

80. [Logged_SOAP_Request]Client_IP:=$clientAddress_t

81. [Logged_SOAP_Request]Server_IP:=$serverAddress_t

82. [Logged_SOAP_Request]User_Name:=$userName_t

83. [Logged_SOAP_Request]Method_Name:=$methodName_t

84. [Logged_SOAP_Request]User_Agent:=$userAgent_t

85. STOCKER ENREGISTREMENT([Logged_SOAP_Request])

87. ` ---------------------------------------

88. ` Désactivation de la gestion d'erreurs

89. ` ---------------------------------------

90. APPELER SUR ERREUR("")

92. Fin de si ` (Est une requete SOAP)

93. ` ---------------------------------------

Suggestions

Si vous êtes intéressés par la construction d’un système de journalisation des requêtes SOAP dans un environnement de production, voici quelques suggestions d’implémentations :

- conserver le code s’exécutant en réponse au service Web, ainsi qu’aux requêtes Web aussi rapide que possible.

- le code proposé ci-dessus peut être remodelé et amélioré pour une meilleure flexibilité.

- cet exemple enregistre les données du journal dans des enregistrements principalement parce qu’il est plus facile de le coder de cette manière ! En environnement de production, l’écriture dans des documents disques est à considérer sérieusement.

- dans un système reposant sur 4D Server, réfléchissez à enregistrer les requêtes entrantes dans des enregistrements au lieu d’extraire les données dans le process gérant la requête au Service Web. Un process spécifique ou un client dédié peut être programmé pour examiner périodiquement les enregistrements sauvés et extraire l’information désirée afin de l’inclure dans les enregistrements d’un fichier de journalisation. C’est une stratégie particulièrement intéressante lorsque le serveur Web s’exécute sur un ou plusieurs 4D Clients et qu’en conséquence le fichier de journalisation doit être consolidé sur une machine.

VI - Exemple : relire des entrées non déclarées

Description

Une autre application de la technique décrite dans cette note technique est de lire des valeurs d’un message SOAP qui ne sont pas déclarées par DECLARATION SOAP. Par exemple, la méthode ConvertFeetToMeters reproduite plus haut pourrait accepter un argument optionnel spécifiant la précision de l’arrondi. Le fragment XML ci-dessous montre à quoi ressemble la requête XML avec un nouveau champ nommé inRoundTo (en gras pour la mise en évidence) :

1. <mns:ConvertFeetToMeters xmlns:mns="http://www.4d.com/namespace/default">

2. <inFeet xsi:type="xsd:float">100</inFeet>

3. <inRoundTo xsi:type="xsd:float">3</inRoundTo>

4. </mns:ConvertFeetToMeters>

La gestion manuelle par rapport à la gestion automatique

En utilisant le système de conversion SOAP automatique de 4e Dimension, la méthode ConvertFeetToMeters n’a pas accès à l’entrée inRoundTo. Si ConvertFeetToMeters requiert toujours un argument d’arrondi, l’approche la plus simple est de déclarer l’entrée en tant que paramètre de la méthode ou variable process et de la définir comme entrée SOAP à l’aide de DECLARATION SOAP, comme dans le fragment de code ci-dessous :

1. ` ---------------------------------------

2. C_ENTIER LONG($2)

3. …

4. DECLARATION SOAP ($2 ;Est un entier long ;"inroundTo")

5. ` ---------------------------------------

Note : Les déclarations Compiler et les déclarations SOAP répondent à des objectifs différents et sont toutes les deux nécessaires. Les valeurs utilisées comme entrées ou sorties SOAP devraient être déclarées pour le compilateur et par la commande DECLARATION SOAP.

Étant donné la facilité de déclaration des entrées SOAP, pourquoi les développeurs se trouveraient-ils dans l’obligation de traiter les entrées – ou certaines entrées – SOAP manuellement ?

Voici quelques raisons :

- en utilisant le système de conversion automatique de 4e Dimension, il n’existe aucun moyen de distinguer entre les messages qui n’incluent pas l’entrée et ceux qui incluent une valeur par défaut pour le type. Par exemple, en utilisant le système automatique, le paramètre $2 ci-dessus vaut 0 si inRoundTo est soumis avec une valeur de 0 ou si inRoundTo n’est pas passé du tout ;

- le système automatique de 4e Dimension demande d’associer les entrées avec des paramètres de méthodes, des variables process ou des tableaux process. En outre, toute variable process ou tableau lié à une entrée SOAP doit être déclaré dans la méthode Compiler_Web, ou dans une sous-routine appelée par Compiler_Web. La lecture manuelle des messages SOAP permet aux développeurs d’extraire, convertir, et stocker les entrées librement dans des champs, documents locaux, variables et tableaux process ou interprocess. De plus, si le système de traduction automatique n’est pas utilisé, les valeurs n’ont pas besoin d’être déclarées dans Compiler_Web ;

- dans la vie d’un service Web, les listes de paramètres et les déclarations peuvent changer. La lecture directe du message révèle exactement quels paramètres ont été envoyés. Il devient alors plus facile de supporter des listes de paramètres multiples pour une même méthode, ou de renvoyer une faute SOAP intelligemment lorsque le client SOAP doit mettre à jour son code.

Code échantillon

Le code ci-dessous améliore la méthode ConvertFeetToMeters proposée plus haut en appelant une sous-routine nommée soap_GetRounding qui retourne une valeur d’arrondi depuis le message SOAP ou une valeur d’arrondi par défaut :

1. ` ---------------------------------------

2. C_REEL($0;$meters_r)

3. C_REEL($1;$feet_r)

5. DECLARATION SOAP($0;Est un numérique ;SOAP sortie ;"outMeters")

6. DECLARATION SOAP($1;Est un numérique ;SOAP entrée ;"inFeet")

8. C_ENTIER LONG($rounding_l)

9. $rounding_l:=soap_GetRounding

11. $feet_r:=$1

13. $meters_r:=$feet_r*0,3048

14. $meters_r:=Arrondi($meters_r;$rounding_l)

16. $0:=$meters_r

17. ` ---------------------------------------

La seule différence entre la version originale de la méthode ConvertFeetToMeters et la version modifiée consiste dans les trois lignes de code reprises ci-dessous :

1. ` ---------------------------------------

2. C_ENTIER LONG($rounding_l)

3. $rounding_l:=soap_GetRounding

4. $meters_r:=Arrondi($meters_r;$rounding_l)

5. ` ---------------------------------------

Voici le code de la méthode soap_GetRounding :

1. ` ---------------------------------------

2. C_ENTIER LONG($0;$rounding_l)

3. $rounding_l:=0

5. C_TEXTE($xml_t)

6. $xml_t:=soap_GetFullRequest

8. C_ALPHA(16;$xmlref)

9. $xmlref:=Analyser variable XML($xml_t) ` Analyse de l'XML contenu dans une variable texte ou BLOB

11. C_TEXTE($rounding_t)

12. $rounding_t:=""

14. ` Extrait la valeur de l'élément 'inRoundTo' vers une chaine, si cet élément est trouvé

15. $rounding_t:=xutil_GetValue ($xmlref;"inRoundTo")

17. `Convertit la valeur en nombre (les chaînes vides sont converties en 0)

18. $rounding_l:=Num($rounding_t)

20. Si ($rounding_l<=0) `Modif CK

21. $rounding_l:=2 ` une valeur négative n'a pas de sens, retour de la valeur par défaut 2

22. Fin de si

24. FERMER XML($xmlref) `Toujours faire correspondre un appel à Analyser variable XML

25. ` par un appel à FERMER XML

26. $0:=$rounding_l

27. ` ---------------------------------------

La méthode xutil_GetValue retourne la valeur en texte de n’importe quel élément simple XML, s’il existe. Les commandes de navigation XML natives de 4e Dimension ou celles des nombreuses solutions tierces peuvent également s’utiliser.

VII - Base exemple

Téléchargez la base exemple :

Base pour Windows

Base pour Mac