Générer du XML avec 4D 2004 - 2e partie

Christophe KEROMEN,

La version 2004 nous a apporté non pas un, mais deux jeux de commandes pour générer des structures XML, l’un préfixé par DOM, l’autre par SAX. Dans une première note technique 4D-200409-27-FR, nous avons traité l’exemple d’une conversion d’enregistrement en structure XML via l’approche DOM. Dans cette seconde partie, nous passons en revue les différents modes de génération de XML avec 4D 2004. ♪

- Titre : Générer du XML avec 4D 2004 - 2e partie

- Auteur : Christophe KEROMEN,

- Parution : 1 octobre 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. Interface de la base exemple

- Méthode CD_ListeXML

- II. Approche « SAX »

- Différence entre SAX et DOM

- Traitement « SAX »

- Méthode SAX_listeEnregistrementsVersXML

- Routine SAX_EnregistrementVersXML

- Routine SAX_AJOUTER_ELEMENT_SIMPLE

- Routine DOM_isXML_correct

- Par balises HTML

- Description du modèle XML

- Validation par une requête http

- Traiter balises HTML

- Routines utilisées

- Obtenir les références à la base de données

- Bibliographie

- Par état rapide

- Le modèle

- Résultat

- Code d’exécution (méthode QR_Executer)

- Bibliographie

- III. Conclusion

- IV. Base exemple

I - Interface de la base exemple

La sélection de l’item de menu « Fichier/démo » nous affiche le dialogue suivant :

Figure 1 – interface de génération XML

Chacun des quatre boutons de la partie supérieure gauche de l’écran appelle un mode de génération différent d’un document XML présentant des données issues de la table [CD] :

· DOM : utilise les nouvelles commandes 4D 2004 d’écriture dans un arbre DOM, puis la sérialisation de cet arbre en fichier texte, (cf. la première partie de cette note technique) ;
· SAX : utilise les nouvelles commandes 4D 2004 d’écriture « SAX » dans un document disque ;
· État rapide : utilise une fonctionnalité des états rapides de 4D 2003 pour générer un état d’après un modèle balisé ;
· Balises Web : utilise la nouvelle commande 4D 2004 TRAITER BALISES HTML pour générer un document XML depuis un modèle comportant des balises semi-dynamiques.

La case à cocher « via SOAP » permet de demander d’exécuter le traitement au travers d’une requête SOAP. Dans le cas contraire, il s’agit d’un appel direct. À noter que la requête peut également s’effectuer au travers d’http (depuis n’importe quel navigateur) en saisissant :

http://serveur:8080/4DACTION/CD_ListeXML/mode

où mode peut prendre les valeurs : DOM-SAX-QR-Web.

La zone de texte centrale affiche les 32 000 premiers caractères du résultat de la génération XML.

Le bouton de droite « Navigateur » affiche le résultat de la génération dans un navigateur, de préférence Internet Explorer qui offre, à la date de cette rédaction, le meilleur rendu.

Méthode CD_ListeXML

C’est la méthode centrale protéiforme qui peut être appelée directement, par une requête HTTP ou au travers d’un service Web.

1. ` Methode : CD_Liste_XML

2. ` Description

3. ` Conversion d’une sélection d’utilisateur en XML et renvoi à un appel direct, HTTP ou SOAP

4. `cette méthode peut aussi être appelée par

5. `get "http://serveur:8080/4DACTION/CD_ListeXML/mode"

6. `ou directement : CD_ListeXML("DOM")

7. `

8. ` Parametres

9. `$1:TEXTE:Mode (DOM-SAX-QR-Web)

10. ` ----------------------------------------------------

12. C_TEXTE($1)

13. C_TEXTE($_vt_Mode)

14. $_vt_Mode:=$1

16. `---Décodage du paramètre d’entrée

17. Si (Est une requete SOAP)

18. `en mode dynamique, 4D s’occupe de tout

19. DECLARATION SOAP($1;Est un texte ;SOAP entrée ;"modeConversionXML")

20. Sinon

21. C_BOOLEEN($_vb_SiRequeteHTTP)

22. Si (Sous chaine($_vt_Mode;1;1)="/")  `requête HTTP

23. $_vt_Mode:=Sous chaine($_vt_Mode;2)  `pour enlever le "/", ex. dans "/DOM"

24. $_vb_SiRequeteHTTP:=Vrai

25. Sinon  `appel direct

26. $_vb_SiRequeteHTTP:=Faux

27. Fin de si

28. Fin de si

30. `--- Constitution de la sélection

31. LECTURE SEULEMENT([CD])

32. TOUT SELECTIONNER([CD])

33. TRIER([CD];[CD]Titre;>)

35. `--- conversion en XML

36. C_TEXTE($_vt_Methode_CallBack)

37. $_vt_Methode_CallBack:=""

38. C_BLOB(geneXML_vx_XML)

39. FIXER TAILLE BLOB(geneXML_vx_XML;0)

40. C_TEXTE(soap_vt_Return)

41. soap_vt_Return:=""

43. Au cas ou

44. : ($_vt_Mode="DOM")

45. soap_vt_Return:=DOM_ListeEnregistrementsVersXML (->[CD];$_vt_Methode_CallBack;->geneXML_vx_XML)

46. : ($_vt_Mode="SAX")

47. soap_vt_Return:=SAX_listeEnregistrementsVersXML (->[CD];$_vt_Methode_CallBack;->geneXML_vx_XML)

48. : ($_vt_Mode="QR")

49. soap_vt_Return:=QR_Executer ($_vt_ModeleXML;->geneXML_vx_XML)

50. : ($_vt_Mode="Web")

51. C_TEXTE($_vt_ModeleXML)  `Nom du modèle semi-dynamique

52. $_vt_ModeleXML:="CD.xml"

53. soap_vt_Return:=XML_traiterModele ($_vt_ModeleXML;->geneXML_vx_XML)

54. Sinon

55. soap_vt_Return:="<erreur>le mode "+$_vt_Mode+" n’est pas reconnu </erreur>"

56. TEXTE VERS BLOB(soap_vt_Return;geneXML_vx_XML;Texte sans longueur )

57. Fin de cas

59. `--- Renvoi du résultat

60. Si (Est une requete SOAP)

61. DECLARATION SOAP(soap_vt_Return;Est un texte ;SOAP sortie ;"CD_Liste_XML_texte")

62. DECLARATION SOAP(geneXML_vx_XML;Est un BLOB ;SOAP sortie ;"CD_Liste_XML_BLOB")

63. `maintenant 4D s’occupe de l’encodage et de l’envoi

64. Sinon

65. Si ($_vb_SiRequeteHTTP)  `requête HTTP

66. `précisons le type MIME "text/xml" pour que le navigateur reconnaisse le XML

67. ENVOYER BLOB HTML(geneXML_vx_XML;"text/xml")

68. Fin de si

69. Fin de si

71. $0:=soap_vt_Return

II - Approche « SAX »

Originellement, le terme SAX (Simple API for XML) désigne une API Java pour relire les flux XML suivant une logique orientée événement.

En version 2004, 4D propose une implémentation de cette API pour le langage 4D ainsi qu’une extension à la génération de documents XML.

Différence entre SAX et DOM

Deux différences séparent les deux nouveaux jeux de commandes d’écriture XML : la cible et la granularité :

- les commandes DOM travaillent sur un arbre en mémoire, leur niveau de travail est l’élément ;

- les commandes « SAX » travaillent sur un fichier disque, leur niveau de travail est l’élément ou un autre type de nœud : commentaire, section CDATA, instruction de traitement.

En fonction de cette séparation, vous choisirez la famille qui vous convient le mieux. Pour notre exemple, point n’est besoin d’autre type de nœud que l’élément.

Traitement « SAX »

Voici le résultat du traitement « SAX » affiché dans un navigateur, vous pouvez constater qu’il ressemble furieusement à ce que nous obtenions précédemment avec l’approche DOM !

Figure 2 – Document XML généré par SAX

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<root>
<!-- Ex. de generation 'SAX' le 31/09/2004 -->
<CD>
<CD.ID_CD>5</CD.ID_CD>
<CD.Titre>4 Stabat mater</CD.Titre>
<CD.Interprete>Divers</CD.Interprete>
<CD.Genre>Musique sacrée</CD.Genre>
<CD.Description>Ce double CD réédité par EMI en 1995 réunit 4 Stabat mater.
Celui de Rossini interprété par l’orchestre Symphonique de Berlin dirigé par Karl Forster.
Il est suivi de l’œuvre de Verdi, Philarmonica Orchestra dirigé par Carlo Maria Guilini.
Sur le deuxième CD, on trouve Francis Poulenc interprété par Régine Crespin.
Cette compilation se termine avec une version moins connue, celle du polonais Karol Szymanowski,
Orchestre Symphonique de la Radio Nationale polonaise par Antoni Wit.</CD.Description>
<CD.Prix>8</CD.Prix>
<CD.DateStock>2003-01-01T00:00:00</CD.DateStock>
</CD>
<CD>
<CD.ID_CD>2</CD.ID_CD>
<CD.Titre>Master serie 1</CD.Titre>
<CD.Interprete>Sheller William</CD.Interprete>
<CD.Genre>Chanson française</CD.Genre>
<CD.Description>Cette compilation de 1987 ressortie en CD en 1991 par Polygram
regroupe les succès du pianiste-compositeur entre 1975 (Photos souvenirs) et
1984 (Simplement)</CD.Description>
<CD.Prix>4,9</CD.Prix>
<CD.DateStock>2003-01-01T00:00:00</CD.DateStock>
</CD>
</root>

Notez cependant l’insertion d’un commentaire juste sous la racine.

Méthode SAX_listeEnregistrementsVersXML

Cette méthode générique convertit une sélection d’enregistrements en structure XML. Elle ne diffère principalement de DOM_listeEnregistrementsVersXML que par l’utilisation d’un document disque comme cible plutôt qu’un arbre DOM en mémoire.

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

2. ` Methode : SAX_listeEnregistrementsVersXML

3. ` Description

4. ` convertit une liste d’enregistrements en structure XML via écriture SAX

5. `

6. ` Notes :

7. `- 4D 2004 (utilise les commandes d’écriture SAX)

8. `- la sélection doit déjà exister

9. `- ici on retourne ds un BLOB, attention à la taille du XML généré

10. `

11. ` Parametres

12. ` Parametres

13. `$1:POINTEUR:Table

14. `$2:TEXTE:Methode à appeler en callback pour chaque enregistrement

15. `$3:POINTEUR:BLOB:structure XML

16. `$0:TEXTE:structure XML

17. `

18. ` Version : 1

19. ` Appel : texteXML:=SAX_listeEnregistrementsVersXML(->Table;$_vt_Methode_CallBack;-> BLOB XML)

20. ` ----------------------------------------------------

22. C_POINTEUR($1)

23. C_POINTEUR($_vp_Table)

24. $_vp_Table:=$1

26. C_TEXTE($2)

27. C_TEXTE($_vt_Methode_CallBack)

28. $_vt_Methode_CallBack:=$2

30. C_POINTEUR($3)

32. C_TEXTE($0)

33. $0:=""

35. `--- Installe une gestion d’erreurs

36. XML_AppelerSurErreur_set

37. C_TEXTE($_vt_Last_xml_Error)

38. $_vt_Last_xml_Error:=""

40. `--- Enregistre le doc XML sur disque

41. C_TEXTE($_vt_chemin)

43. `stockage sur disque dans un fichier temporaire

44. $_vt_chemin:=Dossier temporaire+"SAX_temp.xml"

45. Si (Tester chemin acces($_vt_chemin)=Est un document )

46. SUPPRIMER DOCUMENT($_vt_chemin)

47. Fin de si

49. C_HEURE($_vh_refDoc)

50. $_vh_refDoc:=Creer document($_vt_chemin;"xml")

51. $_vt_chemin:=document

53. Si (ok=1)

55. `--- Écriture des options

56. C_TEXTE($_vt_Encodage)

57. $_vt_Encodage:="UTF-8"

58. C_BOOLEEN($_vb_SiAutonome)

59. $_vb_SiAutonome:=Vrai  `avec ou sans DTD externe

60. C_BOOLEEN($_vb_SiIndentation)

61. $_vb_SiIndentation:=Vrai  `avec whitespaces ou non de présentation

62. SAX ECRIRE OPTIONS XML ($_vh_refDoc;$_vt_Encodage;$_vb_SiAutonome;$_vb_SiIndentation)

64. `--- Création du document XML en lui passant la racine nommée arbitrairement "root"

65. C_TEXTE($_vt_root)

66. $_vt_root:="root"

67. SAX OUVRIR ELEMENT XML($_vh_refDoc;$_vt_root)

68. SAX AJOUTER COMMENTAIRE XML($_vh_refDoc;"Ex. de génération'SAX' le "+Chaine(Date du jour;Spécial forcé ))

70. `--- Export des enregistrements par parcours de la sélection

71. C_ENTIER($i)

73. Boucle ($i;1;Enregistrements trouves($_vp_Table->))

75. `--- Création de l’élément complexe contenant les champs de l’enregistrement courant

76. C_ENTIER($_ve_SiEncodingISO)

77. $_ve_SiEncodingISO:=0  `sans encodage ISO (encodage effectué automatiquement par les commandes SAX)

78. C_TEXTE($_vt_ElementName)  `nom de l’élément, on pourrait églt prendre un nom générique, ex.<row>

79. $_vt_ElementName:=XMLw_Replace_Char (Nom de la table($_vp_Table);"tag";$_ve_SiEncodingISO)

80. SAX OUVRIR ELEMENT XML($_vh_refDoc;$_vt_ElementName)

82. `--- Rétro-appel de la méthode convertissant l’enregistrement courant en XML

83. Si ($_vt_Methode_CallBack#"")

84. C_TEXTE($_vt_callback)

85. $_vt_callback:=$_vt_Methode_CallBack+"("+Caractere(Guillemets )+$_vt_RefElementRecord+Caractere(Guillemets )+")"

86. EXECUTER($_vt_callback)

87. Sinon  `Générique de conversion en XML

88. C_ENTIER($_ve_siEncodageIso)

89. $_ve_siEncodageIso:=Num($_vt_Encodage="ISO-8859-1")  `pas d'encodage ISO

90. SAX_EnregistrementVersXML ($_vh_refDoc;$_vp_Table;$_vt_ElementName;$_ve_siEncodageIso)

91. Fin de si

93. `referme la balise d’enregistrement

94. SAX FERMER ELEMENT XML($_vh_refDoc)

95. $_vt_Last_xml_Error:=XML_AppelerSurErreur_getLastErr

96. Si ($_vt_Last_xml_Error#"") | (ok=0)  `une erreur est survenue on arrête

97. $i:=Enregistrements trouves($_vp_Table->)+1

98. Sinon

99. ENREGISTREMENT SUIVANT($_vp_Table->)

100. Fin de si

102. Fin de boucle

104. SAX FERMER ELEMENT XML($_vh_refDoc)  `referme la racine et ts les éléments ouverts

105. FERMER DOCUMENT($_vh_refDoc)  `referme le doc XML

107. `chargement du doc dans un BLOB

108. C_BLOB($_vx_XML)

109. DOCUMENT VERS BLOB($_vt_chemin;$_vx_XML)

111. Sinon

112. $_vt_Last_xml_Error:="Impossible de créer le document XML"

114. Fin de si

116. `--- Gestion des erreurs, validation et enregistrement

117. Si ($_vt_Last_xml_Error="")  `pas d’erreur

118. `--- Le doc est-il bien formé ? (on pourrait aussi le valider/DTD)

119. $3->:=$_vx_XML

120. C_TEXTE($_vt_XML)

121. $_vt_XML:=DOM_isXML_correct ($3)

122. Si ($_vt_XML#"")

123. $0:=$_vt_XML  `OK

124. Sinon

125. FIXER TAILLE BLOB($3->;0)

126. ALERTE("Doc XML mal formé : l’arbre XML a été copié dans les presse-papiers")

127. Fin de si

128. Sinon  `une erreur est survenue

129. ALERTE($_vt_Last_xml_Error)

130. Fin de si

132. DEBUT SELECTION($_vp_Table->)  `on remet le pointeur en début de sélection

Commentaires

Le document XML s’ouvre et se ferme grâce aux commandes traditionnelles Creer document et FERMER DOCUMENT.

SAX ECRIRE OPTIONS XML : permet de fixer différentes options du document XML : encodage, indentation et de préciser si le document est accompagné ou non d’une DTD.

SAX AJOUTER COMMENTAIRE XML : permet d’ajouter un commentaire dans le document XML.

SAX OUVRIR ELEMENT XML : permet d’ouvrir un nouvel élément XML dont on passe le nom.

SAX FERMER ELEMENT XML : le pendant de la commande précédente, mais attention elle referme le dernier nœud ouvert sans précision de son nom, 4D le gère automatiquement. Il convient dans le cas d’élément complexe de ne l’appeler qu’après avoir rajouté attributs ou enfants.

Routine SAX_EnregistrementVersXML

Cette méthode générique convertit un enregistrement en XML par les commandes SAX. Elle ne diffère de la méthode DOM_EnregistrementVersXML que par l’utilisation d’un paramètre désignant le document au lieu de l’arbre DOM en mémoire. Elle ne traite pas non plus les champs binaires.

Les routines suivantes sont utilisées :

xmlw_Si_ChampBinaire : est-ce un champ binaire (non traité) ;

XMLw_Replace_Char : remplace ou supprime un caractère posant problème ;

XMLw_get_fieldValue : retourne le contenu d’un champ en texte pour écriture XML.

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

2. ` Methode : SAX_EnregistrementVersXML

3. ` Description

4. ` Convertit de manière générique un enregistrement en XML

5. `

6. `Notes :

7. `- ne traite pas les champs binaires

8. `

9. ` Parametres

10. `$1:TEXTE:Ref du document en cours de génération

11. `$2:POINTEUR:Table

12. `$3:TEXTE:Nom parent pour préfixer

13. `$4:ENTIER:1 si encodage ISO à appliquer

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

15. ` SAX_EnregistrementVersXML ($_vh_RefDoc;$_vp_Table;$_vt_ElementName;$_ve_siEncodageIso)

17. C_HEURE($1)

18. C_HEURE($_vh_refDoc)

19. $_vh_refDoc:=$1

21. C_POINTEUR($2)

22. C_POINTEUR($_vp_PtTable)

23. $_vp_PtTable:=$2

25. C_ENTIER LONG($_vl_TableNo)

26. $_vl_TableNo:=Table($_vp_PtTable)

28. C_TEXTE($_vt_prefixe)

29. $_vt_prefixe:=""  `pour garantir unicité entre tables

31. C_ENTIER($_ve_siEncodageIso)

32. $_ve_siEncodageIso:=0  `pas d’encodage ISO

34. Si (Nombre de parametres=2)

35. Sinon

36. $_vt_prefixe:=$3

37. $_ve_siEncodageIso:=$4

38. Fin de si

40. C_ENTIER($i)

41. Boucle ($i;1;Nombre de champs($_vl_TableNo))

42. C_POINTEUR($_vp_Champ)

43. $_vp_Champ:=Champ($_vl_TableNo;$i)

44. Si (xmlw_Si_ChampBinaire ($_vp_Champ))  `on ne traite pas ds cette version

45. Sinon

46. C_TEXTE($_vt_TagName)

47. $_vt_TagName:=XMLw_Replace_Char (Nom du champ($_vl_TableNo;$i);"tag";$_ve_SiEncodingISO)

48. Si ($_vt_prefixe#"")

49. $_vt_TagName:=$_vt_prefixe+"."+$_vt_TagName

50. Fin de si

51. C_TEXTE($_vt_Value)

52. $_vt_Value:=XMLw_get_fieldValue ($_vp_Champ)

54. `Ajout d’un champ et de sa valeur

55. SAX_AJOUTER_ELEMENT_SIMPLE ($_vh_refDoc;$_vt_TagName;$_vt_Value)

56. Fin de si

57. Fin de boucle

Routine SAX_AJOUTER_ELEMENT_SIMPLE

Cette routine se charge d’ajouter un élément et sa valeur au document en cours de génération. L’élément doit être de type simple, c’est-à-dire ne pas contenir d’attributs ou d’enfants.

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

2. ` Methode : SAX_AJOUTER_ELEMENT_SIMPLE

3. ` Description

4. ` Ajoute un élément sa valeur et referme l’élément

5. `

6. ` Parametres

7. `$1:HEURE:Ref doc

8. `$2:TEXTE:Nom de l’élément

9. `$3:TEXTE:Valeur de l’élément

10. ` ----------------------------------------------------

11. `SAX_AJOUTER_ELEMENT_SIMPLE ($_vh_refDoc;$_vt_TagName;$_vt_Value)

13. C_HEURE($1)

14. C_HEURE($_vh_refDoc)

15. $_vh_refDoc:=$1

17. C_TEXTE($2)

18. C_TEXTE($_vt_NomElement)

19. $_vt_NomElement:=$2

21. C_TEXTE($3)

22. C_TEXTE($_vt_ValeurElement)

23. $_vt_ValeurElement:=$3

25. SAX OUVRIR ELEMENT XML($_vh_refDoc;$_vt_NomElement)

26. SAX AJOUTER VALEUR ELEMENT XML($_vh_refDoc;$_vt_ValeurElement)

27. SAX FERMER ELEMENT XML($_vh_refDoc)

Routine DOM_isXML_correct

Nous utilisons la méthode DOM_isXML_correct pour vérifier si la structure XML générée est bien formée, les routines d’écriture SAX ou DOM ne s’en chargeant pas. Pour cela, nous chargeons la structure dans le parseur grâce à DOM Analyser variable XML et vérifions qu’aucune erreur n’est signalée. Cette méthode pourrait être enrichie pour valider la structure par rapport à une DTD de référence.

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

2. ` Methode : DOM_isXML_correct

3. ` Description

4. ` vérifie que l’XML contenu dans le BLOB $1-> est bien formé

5. `si oui, renvoie ses 32 000 premiers caractères dans $0

6. `sinon renvoie une chaîne vide

7. `

8. ` Parametres

9. ` $0:TEXTE:32 000 premiers caractères de la structure XML

10. `$1:POINTEUR:BLOB contenant un doc XML

11. `

12. ` Version : 1

13. ` Appel : texteXML:=DOM_isXML_correct(->BLOB XML)

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

16. C_POINTEUR($1)

17. C_BLOB($_vx_XML)

18. $_vx_XML:=$1->

20. C_TEXTE($_vt_Ref_XML_Analyse)

21. $_vt_Ref_XML_Analyse:=DOM Analyser variable XML($_vx_XML)

23. `--- Conversion en texte

24. C_TEXTE($_vt_XML)

25. DOM EXPORTER VERS VARIABLE($_vt_Ref_XML_Analyse;$_vt_XML)

27. `Bug 4D : DOM EXPORTER VERS VARIABLE devrait décoder en Mac Roman

28. $_vt_XML:=ISO vers Mac($_vt_XML)

29. ECRIRE TEXTE DANS PRESSE PAPIERS($_vt_XML)

31. Si (ok=1) & (DOM_ifNoError ($_vt_Ref_XML_Analyse))

32. `Retour des valeurs

33. $0:=$_vt_XML

34. $3->:=$_vx_XML

35. Sinon

36. FIXER TAILLE BLOB($3->;0)

37. $0:=""

38. Fin de si

40. DOM FERMER XML($_vt_Ref_XML_Analyse)  `l’arbre analysé

Par balises HTML

Quoique cette fonctionnalité ait été un peu sous-employée, le serveur Web de 4D sait servir des documents XML depuis la version 6.5.7. Les balises 4D insérées dans un modèle de document XML permettent très facilement d’obtenir un document XML dynamique, c’est-à-dire dont le contenu est construit par le serveur lors de la requête du client.

Cette fonctionnalité va nous offrir un nouveau moyen de générer du XML.

Description du modèle XML

Nous devons commencer par construire notre modèle qui effectuera les déclarations indispensables (déclaration XML, balise racine) et contiendra des balises propriétaires qui déclencheront les appels à 4D.

Soit le modèle de document XML suivant :

<?xml version="1.0" encoding="ISO-8859-1"?>
<!-- Liste de CD -->
<XML_4D>
<!--4DSCRIPT/web_script_allSelect/1-->
<!--4DSCRIPT/web_script_sortByDefault/1-->
<!--4DLOOP [CD]-->
<CD>
<titre><!--4DVAR [CD]Titre--></titre>
<interprete><!--4DVAR [CD]Interprete--></interprete>
<genre><!--4DVAR [CD]Genre--></genre>
<description><!--4DVAR [CD]Description--></description>
<prix><!--4DVAR [CD]Prix--></prix>
<dateStock><!--4DVAR [CD]Date Stock--></dateStock>
</CD>
<!--4DENDLOOP-->
</XML_4D>

Reportez-vous à la documentation, section « Balises HTML 4D » pour une description détaillée des balises utilisées ici :

- 4DSCRIPT nous permet de déclencher l’exécution de code, ici pour constituer la sélection initiale sur la table [CD], puis la trier ;

- 4DLOOP est l’équivalent HTML de Boucle, avec son pendant 4DENDLOOP (Fin de boucle) ;

- 4DVAR insère la valeur d’un champ, d’une variable ou d’une expression 4D, nous l’utilisons ici directement pour attaquer des champs de la structure.

Notez qu’il nous appartient ici de construire correctement l’arborescence de notre modèle afin de générer un document XML bien formé.

Nous enregistrons ce modèle nommé « CD.xml » dans le dossier Web de notre structure.

Validation par une requête http

Validons notre modèle en demandant son exécution par une requête directe sur le serveur Web de 4D, publié sur le port 8080.

Saisissons l’URL « http://localhost:8080/CD.xml » dans Internet Explorer ou Mozilla (afin de bénéficier de la présentation intégrée du XML), nous obtenons le document ci-dessous :

Figure 3 – Document XML généré par un modèle semi-dynamique

<?xml version="1.0" encoding="UTF-8" ?>
<!-- Liste de CD -->
<XML_4D>
<CD>
<titre>4 Stabat mater</titre>
<interprete>Divers</interprete>
<genre>Musique sacrée</genre>
<description>Ce double CD réédité par EMI en 1995 réunit 4 Stabat mater.
Celui de Rossini interprété par l’orchestre Symphonique de Berlin dirigé par Karl Forster.
Il est suivi de l’œuvre de Verdi, Philarmonica Orchestra dirigé par Carlo Maria Guilini.
Sur le deuxième CD, on trouve Francis Poulenc interprété par Régine Crespin.
Cette compilation se termine avec une version moins connue, celle du polonais Karol Szymanowski,
Orchestre Symphonique de la Radio Nationale polonaise par Antoni Wit.</description>
<prix>8</prix>
<dateStock>1/01/03</dateStock>
</CD>
<CD>
<titre>Master serie 1</titre>
<interprete>Sheller William</interprete>
<genre>Chanson française</genre>
<description>Cette compilation de 1987 ressortie en CD en 1991 par Polygram
regroupe les succès du pianiste-compositeur entre 1975 (Photos souvenirs) et
1984 (Simplement)</description>
<prix>4,9</prix>
<dateStock>1/01/03</dateStock>
</CD>

4D a automatiquement traité notre modèle et remplacé les balises par les données demandées. Le client Web n’a alors aucun moyen de savoir que le document est issu d’un modèle dynamique.

Notez que dans l’élément <description> du premier CD « l’œuvre » n’est pas correctement encodé. En effet, « œ » ne fait pas partie de l’encodage ISO-8859-1.

Traiter balises HTML

Nouveauté de 4D 2004, la commande TRAITER BALISES HTML va nous permettre d’obtenir le même résultat sans passer par une requête Web et donc sans devoir activer le serveur Web !

Extrait de la documentation :

Cette commande permet d’effectuer un traitement sur du code HTML balisé sans qu’il soit nécessaire que le serveur Web envoie une page HTML via une commande du type ENVOYER BLOB HTML ou qu’une page suffixée “.shtml” soit demandée via une URL. Il n’est même pas nécessaire que le serveur Web de 4e Dimension soit démarré.

Paramètres

Type

Description

données Entrée

Texte ou BLOB

Données contenant des balises HTML à traiter

données Sortie

Texte ou BLOB

Données traitées

Voici le code de l’appel dans la base exemple :

1. C_TEXTE($_vt_ModeleXML)  `Nom du modèle semi-dynamique

2. $_vt_ModeleXML:="CD.xml"

3. `$0 : contient un message d’erreur ou les 32 000 premiers caractères

4. $0:=XML_traiterModele ($_vt_ModeleXML;->geneXML_vx_XML)

avec la méthode XML_traiterModele :

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

2. ` Methode : XML_TraiterModele

3. ` Description

4. ` Traite un modèle dynamique XML $1 pour générer un document statique

5. ` le document doit se trouver dans le dossier 'Dossierweb'

6. ` ATTENTION : utilise la commande 4D 2004 'TRAITER BALISES HTML'

7. `

8. ` Parametres

9. ` $1:TEXTE:Nom du modèle

10. ` $2:POINTEUR:BLOB de retour

11. `

12. ` Version : 1

13. ` Appel : texteXML:=XML_TraiterModele(ModeleXML;->BLOBxml)

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

16. C_TEXTE($1)

17. C_TEXTE($_vt_ModeleXML)

18. $_vt_ModeleXML:=$1

20. C_POINTEUR($2)

21. C_POINTEUR($_vp_PtBlobRetour)

22. $_vp_PtBlobRetour:=$2

24. C_TEXTE($_vt_chemin) `chemin d’accès complet au modèle localisé dans DossierWeb

25. $_vt_chemin:=zdoc_get_DossierWeb +$_vt_ModeleXML

27. Si (Tester chemin acces($_vt_chemin)=Est un document )

28. `--- Chargement du modèle dans un BLOB

29. C_BLOB($_vx_ModeleXML)

30. DOCUMENT VERS BLOB($_vt_chemin;$_vx_ModeleXML)

31. `--- traitement des balises 4D et récupération du document traité dans $_vp_PtBlobRetour->

32. TRAITER BALISES HTML($_vx_ModeleXML;$_vp_PtBlobRetour->)

33. `renvoi des 32 000 premiers caractères dans $0

34. $0:=BLOB vers texte($_vp_PtBlobRetour->;Texte sans longueur )

35. Sinon

36. $0:="<erreur>Impossible de localiser le modèle XML</erreur>"

37. Fin de si

Routines utilisées

L’exemple utilise un certain nombre de routines utilitaires. Reportez-vous à la base exemple si vous désirez connaître le détail de leur code.

Ci-dessous leur fonction :

XML_Blob_vers_Browser : affichage d’une structure XML dans un navigateur ;

ENV_siWindows : exécution sous Windows ?

ZDOC_OuvrirDocument : ouverture d’un document ;

zdoc_get_DossierWeb : retourne le chemin d’accès au dossier Web proche de la structure ;

zdoc_get_separateur : retourne le séparateur de chemin en fonction de la plateforme ;

zdoc_get_dossier_Structure : retourne le chemin vers le dossier de la structure ;

zdoc_get_DossierParent : retourne le dossier parent d’un document dont on passe le chemin d’accès complet.

Obtenir les références à la base de données

Vous pouvez constater que la construction du modèle ci-dessus impose de connaître :

- le vocabulaire des balises (4DLOOP, 4DSCRIPT, 4DVAR,…) ;

- les éléments à référencer (n° de la table, du champ de tri, nom des champs…).

Le plugin gratuit 4D Object Link permet d’exporter dans un fichier texte les différentes références de la base de données que nous désirons publier :

Figure 4 : plugin Object link

Voici le contenu de l’export pour notre exemple, dans l’ordre, table, champs, méthodes :

4DObjectLinkDocument

GeneXML

1
[CD]
8
Date Stock
Description
Genre
ID_CD
Interprète
Pochette
Prix
Titre
3
web_script_allSelect
web_script_getField
web_script_sortByDefault
0

Ces références sont ensuite récupérables dans les deux principaux éditeurs Web du marché : DreamWeaver et Adobe GoLive.

Voici ce que cela donne une fois importé dans Dreamweaver MX :

Figure 5 – Edition du modèle dans Dreamweaver MX

Notes

Le plugin 4D Object Link n’est pas carbonisé. Une alternative consiste à utiliser le plugin commercial AutoDoc.
Pour activer les outils de l’onglet 4D, il faut tromper Dreamweaver en changeant l’extension du document : xml -> html.

Bibliographie

Outre la documentation de 4e Dimension, vous pouvez vous référer aux notes techniques suivantes :

· 4D-200406-16-FR - « Profiter de la puissance des balises 4D pour afficher vos données sur le Web » ;
· 4D-200111-35-FR - « 4D Web Enchères ».

Par état rapide

Le processus ressemble fort à celui décrit dans le paragraphe précédent et se fonde également sur un modèle décrivant le document XML à l’aide de balises propriétaires.

Le modèle

Nous utilisons un modèle d’état rapide « QR_modele_XML.xml » stocké dans le dossier « QR_Modeles » présent à côté de la structure de notre démo :

<?xml version="1.0" encoding="ISO-8859-1"?>
<XML_4D>
<!--#4DQRRow--><CD>
<!--#4DQRCol;1--><titre><!--#4DQRData--></titre><!--/#4DQRCol;1-->
<!--#4DQRCol;2--><interprete><!--#4DQRData--></interprete><!--/#4DQRCol;2-->
<!--#4DQRCol;3--><genre><!--#4DQRData--></genre><!--/#4DQRCol;3-->
<!--#4DQRCol;4--><description><!--#4DQRData--></description><!--/#4DQRCol;4-->
<!--#4DQRCol;5--><prix><!--#4DQRData--></prix><!--/#4DQRCol;5-->
<!--#4DQRCol;6--><dateStock><!--#4DQRData--></dateStock><!--/#4DQRCol;6-->
</CD>
<!--/#4DQRRow-->
</XML_4D>

Le modèle se charge de déclarer et de structurer le document XML :

· la balise <!--#4DQRRow--> introduit chaque enregistrement [CD] ;

· la balise <!--#4DQRCol;i--> introduit la colonne i ;

· la balise <!--#4DQRData--> insère le contenu de la colonne i, ici chaque colonne prend sa valeur depuis un champ de la table.

Résultat

Le document XML généré est identique à celui du paragraphe précédent avec la même limitation sur le codage ISO-Latin-1 et la non-prise en compte du œ.

Code d’exécution (méthode QR_Executer)

L’appel de la génération :

1. C_TEXTE($_vt_ModeleXML) `Nom du modèle semi-dynamique

2. $_vt_ModeleXML:="QR_modele_XML.xml"

4. `$0 : contient un message d’erreur ou les 32 000 premiers caractères

5. $0:=QR_Executer ($_vt_ModeleXML;->geneXML_vx_XML)

La méthode QR_Executer :

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

2. ` Methode : QR_Executer

3. ` Description

4. ` génère un document XML pour la table CD en utilisant un modèle d’état rapide

5. `

6. ` Parametres

7. ` $1:TEXTE:Nom du modèle

8. `$2:POINTEUR:BLOB de retour

9. `$0:TEXTE: contient un message d’erreur ou les 32 000 premiers caractères

10. `

11. ` Version : 1

12. ` Appel : texteXML:=QR_Executer ($_vt_ModeleXML;->geneXML_vx_XML)

13. ` ----------------------------------------------------

15. C_TEXTE($1)

16. C_TEXTE($_vt_ModeleXML_path) `nom du modèle XML

17. $_vt_ModeleXML_path:=$1

19. C_POINTEUR($2)

20. C_POINTEUR($_vp_PtBlob)

21. $_vp_PtBlob:=$2

23. C_TEXTE($_vt_ModeleXML_content) `Contenu en texte du modèle XML

24. $_vt_ModeleXML_content:=QR_getModele ($_vt_ModeleXML_path)

26. C_TEXTE($_vt_DocXML_Path) `chemin d’accès au document XML généré

27. $_vt_DocXML_Path:=zdoc_get_dossier_Structure +"QR_Modeles"+zdoc_get_separateur

28. $_vt_DocXML_Path:=$_vt_DocXML_Path+"QR_CD.xml"

30. Si ($_vt_ModeleXML_content#"")

32. C_ENTIER LONG($_vl_zone)

33. $_vl_zone:=QR Creer zone hors ecran

35. QR FIXER TYPE ETAT($_vl_zone;QR ETAT en liste )

36. QR FIXER TABLE ETAT($_vl_zone;Table(->[CD]))

37. TOUT SELECTIONNER([CD])

38. REDUIRE SELECTION([CD];20)

39. TRIER([CD];[CD]Titre;>)

41. `--- Description des colonnes de l’état

42. QR INSERER COLONNE($_vl_zone;1;->[CD]Titre)

43. QR INSERER COLONNE($_vl_zone;2;->[CD]Interprète)

44. QR INSERER COLONNE($_vl_zone;3;->[CD]Genre)

45. QR INSERER COLONNE($_vl_zone;4;->[CD]Description)

46. QR INSERER COLONNE($_vl_zone;5;->[CD]Prix)

47. QR INSERER COLONNE($_vl_zone;6;->[CD]Date Stock)

49. `type de fichier à générer et chemin

50. QR FIXER DESTINATION($_vl_zone;qr fichier HTML ;$_vt_DocXML_Path) `

52. `Indication du modèle à utiliser

53. QR FIXER MODELE HTML($_vl_zone;$_vt_ModeleXML_content)

54. QR EXECUTER($_vl_zone)

55. QR SUPPRIMER ZONE HORS ECRAN($_vl_zone)

57. Si (Tester chemin acces($_vt_DocXML_Path)=Est un document )

59. `retour du document XML ds le pointeur de BLOB

60. DOCUMENT VERS BLOB($_vt_DocXML_Path;$_vp_PtBlob->)

61. $0:=BLOB vers texte($_vp_PtBlob->;Texte sans longueur )

62. Sinon

63. $0:="<erreur>problème dans la génération du document XML</erreur>"

64. Fin de si

65. Sinon

66. $0:="<erreur>Le modèle XML est vide</erreur>"

67. Fin de si

L’ensemble de cette méthode effectue une génération classique d’état rapide dans une zone hors écran. Les deux commandes notables sont :

- QR FIXER DESTINATION qui indique au moteur de construire un document de type HTML et le chemin d’accès vers ce document ;

- QR FIXER MODELE HTML qui passe au moteur d’état rapide le contenu du modèle à utiliser, attention il s’agit bien du contenu lui-même et non d’un chemin d’accès.

La méthode QR_getModele permet de charger le modèle dans une variable texte, type de paramètre attendu par la commande QR FIXER MODELE HTML :

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

2. ` Methode : QR_getModele

3. ` Description

4. ` relit le contenu d’un modèle d’état rapide

5. ` suppose un dossier QR_Modeles près de la structure

6. `

7. ` Parametres

8. ` $0:TEXTE:contenu du modèle

9. ` $1:TEXTE:nom du modèle

10. `

11. ` Version : 1

12. ` Appel : contenuModele:=QR_FixerModele(nomModele)

13. ` ----------------------------------------------------

15. C_TEXTE($1)

16. C_TEXTE($_vt_ModeleXML_path) `chemin d’accès au modèle XML

17. $_vt_ModeleXML_path:=zdoc_get_dossier_Structure +"QR_Modeles"+zdoc_get_separateur +$1

19. C_TEXTE($0)

20. $0:=""

22. C_TEXTE($_vt_ModeleXML_content)

24. Si (Tester chemin acces($_vt_ModeleXML_path)=Est un document )

26. $_vh_Ref:=Ouvrir document($_vt_ModeleXML_path;"";Mode lecture )

27. Si ($_vh_Ref#†00:00:00†)

28. RECEVOIR PAQUET($_vh_Ref;$_vt_ModeleXML_content;32000)

29. FERMER DOCUMENT($_vh_Ref)

30. Si ($_vt_ModeleXML_content#"")

31. $0:=$_vt_ModeleXML_content

32. Sinon

33. ALERTE("Le modèle est vide")

34. Fin de si

35. Fin de si

37. Sinon

38. ALERTE("Le modèle '"+$_vt_ModeleXML_path+"' est introuvable !")

40. Fin de si

Les fonctions des différentes routines utilitaires sont décrites dans le paragraphe précédent.

Bibliographie

· La documentation sur les états rapides.

· 4D-200310-29-FR Etats rapides : les différents types de sorties.

III - Conclusion

Vous pouvez constater qu’en version 2004 les moyens ne manquent pas pour générer des documents XML à partir de vos données 4D.

Deux familles se distinguent :

- DOM et SAX offrant une vue XML et un traitement complet par commande ;

- l’approche orientée « modèle dynamique » représentée par les balises Web et les états rapides.

Notez que la première famille, apparue avec 4D 2004, offre l’intérêt de permettre un encodage du XML en UTF-8, bien meilleure option que la lacunaire conversion en ISO-8859-1. Lors d’un traitement en ligne (requête HTTP ou SOAP), l’approche DOM qui travaille en mémoire sera plus rapide que celle par « SAX » qui impose un passage par disque.

Nous espérons vous avoir donné avec cette note les informations nécessaires pour que vous puissiez effectuer votre choix en fonction des circonstances.

IV - Base exemple

Téléchargez la base exemple.