Developpez.com

Plus de 2 000 forums
et jusqu'à 5 000 nouveaux messages par jour

Developpez.com - 4D
X

Choisissez d'abord la catégorieensuite la rubrique :


Générer du XML avec 4D 2004 - 1ère partie

Date de publication : Septembre 2004

Par Christophe KEROMEN, (Cabinet de Consultants CKTI)
 

La version 2004 nous a apporté deux jeux de commandes pour générer des structures XML, l'un préfixé par DOM, l'autre par SAX. Dans un premier temps, nous utiliserons l'approche DOM pour mettre à jour le code de la note technique « Exemple d'utilisation d'XML : stockage de profils ».

I. Approche DOM
Gestion de l'arbre DOM
Remplissage de l'arbre
II. Modification de l'enregistrement d'une structure XML
Méthode XMLvalues_Record_Save
Méthode XMLvalues_Values2XML_2004
III. Génération d'un document XML pour une sélection d'enregistrements
Appel depuis l'extérieur
Présentation de l'exemple
Traitement par DOM
Méthode CD_ListeXML
Méthode DOM_Liste_EnregistrementsVersXML
Conversion des champs de l'enregistrement, DOM_EnregistrementVersXML :
Méthode DOM_set_ElementWithValue
IV. Conclusion
V. Base exemple


I. Approche DOM


Gestion de l'arbre DOM

Tout se passe en mémoire et le processus commence par la création d'un arbre DOM. Cela s'effectue en passant le nom de l'élément racine à la commande DOM Creer ref XML qui en échange nous renvoie une référence (alpha 16) sur l'élément créé.

La commande DOM ECRIRE OPTIONS XML permet de fixer certaines options de la structure XML :


Encodage

Ce paramètre se passe sous la forme d'une chaîne de caractère spécifiant un encodage (UTF-8, UTF-16, ISO-8859-1,...). La liste des valeurs possibles se retrouve dans la liste déroulante « encodage » dans l'onglet XML du dialogue d'export en utilisation directe. Ce paramètre se retrouvera dans l'attribut encoding de la déclaration XML du document.
Ex: en passant la valeur UTF-8, on obtiendra la déclaration :
<?xml version="1.0" encoding="UTF-8" ?>
La portée de ce paramètre ne se limite pas à fixer l'attribut de la déclaration XML, il s'agit d'une option active que 4D utilisera pour encoder automatiquement toutes les valeurs qui lui seront passées.


Autonome

Ce paramètre permet de préciser si la structure XML se réfère ou non à une DTD externe, sa valeur se retrouvera dans l’attribut standalone de la déclaration XML du document.
Ex. en passant Vrai, on obtiendra la déclaration suivante :
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>


Indentation

Ce paramètre passé à Vrai entraîne une mise en forme de l'arbre XML à l'aide d'espaces et de retours chariot :
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<valeursXML>

   <Champ1>       <value1>liste1_choix1 </value>       <value1>liste1_choix3 </value>       <value1>liste1_choix2 </value>    </Champ1>
   <Champ2>       <value1>liste2_choix2 </value>       <value1>liste2_choix4 </value>    </Champ2>
   <Champ3>       <value1>liste3_choix2 </value>    </Champ3>
</valeursXML>
      Figure 1 - Indentation automatique de l'arbre XML


Passé à Faux, la structure se présente de la manière suivante :
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<valeursXML><Champ1><value1>liste1_choix1</value><value1>liste1_choix3 </value><value1>
liste1_choix2</value></Champ1><Champ2><value1>liste2_choix2</value><value1>liste2_choix4</
value></Champ2><Champ3><value1>liste3_choix2</value></Champ3></valeursXML>
      Figure 2 - Sans indentation automatique de l'arbre XML


Certains parseurs XML n'apprécient que très moyennement les espaces blancs (whitespaces) de mise en forme. Il est donc important de pouvoir maîtriser ce paramètre. Contrairement aux deux premiers paramètres, la valeur passée ne se retrouve pas sous forme d'attributs dans le document XML cible.

DOM EXPORTER VERS VARIABLE permet de convertir l'arbre en mémoire en variable texte ou BLOB (opération de sérialisation). Son pendant pour écrire l'arbre dans un document est DOM EXPORTER VERS FICHIER. Notez que cette commande ne vérifie pas que votre document est bien formé, ni valide. Si vous souhaitez le faire, il faut utiliser la commande DOM Analyser variable XML ou DOM Analyser source XML.

Une fois l'arbre construit et sérialisé dans une variable ou un document disque, il faut penser à le supprimer de la mémoire par l'instruction DOM FERMER XML.


Remplissage de l'arbre

Maintenant que nous avons vu comment créer l'arbre, le sérialiser et le libérer de la mémoire, il serait intéressant de savoir comment le remplir !

Pour cela une première série de commandes travaille sur les éléments :
   · DOM Creer element XML
   · DOM ECRIRE VALEUR ELEMENT XML
   · DOM ECRIRE NOM ELEMENT XML
   · DOM SUPPRIMER ELEMENT XML

Tandis qu'une dernière commande s'intéresse aux attributs :
DOM ECRIRE ATTRIBUT XML.

4D se charge automatiquement :

· de l'encodage des valeurs passées;

· de refermer les éléments :

La commande
   $_vt_RefElement :=DOM Creer element XML($_vt_RefParent ; “toto“)
produit en réalité directement <toto></toto>.

La commande
   DOM ECRIRE VALEUR ELEMENT XML ($_vt_RefElement ;“maValeur“ )
se charge ensuite d’insérer la valeur de l’élément pour obtenir :<toto>maValeur</toto>.


info Note :
Dans la version 2004, les noms des commandes de construction et de parcours d'un arbre DOM ont été renommés pour plus de cohérence avec les commandes d'écriture. Toutes sont désormais préfixées par DOM, ainsi Analyser source XML devient DOM Analyser source XML.


II. Modification de l'enregistrement d'une structure XML


Méthode XMLvalues_Record_Save

L'enregistrement d'une structure XML s'effectuait dans la section "save" de notre méthode xmlvalues_Record . Pour mieux isoler nos modifications, nous allons créer une méthode XMLvalues_Record_Save qui sera appelée à partir de cette section. Cette méthode sera chargée de convertir les champs de notre interface de saisie de valeurs en XML via l'approche DOM.


   ` ----------------------------------------------------
   ` Nom utilisateur (OS) : Christophe Keromen
   ` Date et heure : 13/05/04, 22:05:04
   ` ----------------------------------------------------
   ` Methode : XMLvalues_Record_Save
   ` Description
   ` Conversion des champs en XML
   `
   ` Parametres
   `$0:TEXTE:structure XML à enregistrer
   ` ----------------------------------------------------


C_TEXTE($0)
C_TEXTE($_s_XML)
$_s_XML:=""   `la structure XML à construire
   `--- Création de l'arbre DOM et de l'élément racine
C_TEXTE($_s_root)
$_s_root:="valeursXML"
C_TEXTE($_vt_Ref_DOM_XML)
$_vt_Ref_DOM_XML:=DOM Creer ref XML($_s_root)
   `--- Déclaration XML
C_TEXTE($_vt_Encoding)
$_vt_Encoding:="UTF-8"
C_BOOLEEN($_vb_StandAlone)
$_vb_StandAlone:=Vrai
C_BOOLEEN($_vb_siIndentation)
$_vb_siIndentation:=Vrai  `indentation pour la facilité de lecture de la structure
DOM ECRIRE OPTIONS XML ($_vt_Ref_DOM_XML;$_vt_Encoding;$_vb_StandAlone;$_vb_siIndentation)
$_s_radical:="xmlvalues_S_value"

Boucle ($i;1;Taille tableau(xmlvalues_T_fields))
      `pour chaque champ de concaténation
   $_Pt:=Pointeur vers($_s_radical+Chaine($i))

   Si (Non(Nil($_Pt)))
         ` transforme une liste de valeurs
         `en série d'éléments XML <value> fils de l'élément passé

      XMLvalues_Values2XML_2004 ($_vt_Ref_DOM_XML;xmlvalues_T_fields{$i};$_Pt)
   Fin de si

Fin de boucle

   `--- Sérialisons notre arbre DOM dans une variable de type texte
DOM EXPORTER VERS VARIABLE($_vt_Ref_DOM_XML;$_s_XML)
$0:=$_s_XML
   `libération de la mémoire
DOM FERMER XML($_vt_Ref_DOM_XML)


Méthode XMLvalues_Values2XML_2004

La méthode XMLvalues_Record_Save appelle pour chaque champ XMLvalues_Values2XML_2004 qui se charge de convertir la liste des valeurs choisies en structure XML :

   `----------------------------------------------------
   `Nom utilisateur (OS) : CK
   `Date et heure : 13-5-2004
   `----------------------------------------------------
   `Méthode : XMLvalues_Values2XML_2004
   `Description
   `transforme une liste de valeurs $3
   `en série d'éléments XML <value> fils de l'élément $2
   `Paramètres
   `$1:TEXTE:Ref de l'arbre DOM
   `$2:TEXTE:nom de l'élément père
   `$3:POINTEUR:liste de valeurs à transformer
   `----------------------------------------------------


C_TEXTE($1)
C_TEXTE($2)
C_POINTEUR($3)
C_TEXTE($_vt_Ref_DOM_XML)

$_vt_Ref_DOM_XML:=$1

C_TEXTE($_s_FieldElement;$_s_ChildElement)
$_s_FieldElement:=$2
$_s_ChildElement:="value"
C_POINTEUR($_Pt_valeurs)
$_Pt_valeurs:=$3

Si (Non(Nil($_Pt_valeurs)))

   Si ($_Pt_valeurs->#"")

         `--- Ouverture de l'élément <Champ{indice}>
      C_TEXTE($_vt_RefElement)
      $_vt_RefElement:=DOM Creer element XML($_vt_Ref_DOM_XML;$_s_FieldElement)

         `--- Transformation de la liste de valeurs séparées par des CR en tableau
      TABLEAU TEXTE(xmlvalues_T_temp;0)  `variable globale "locale"
      zgen_TexteVersTableau ($_Pt_valeurs->;->xmlvalues_T_temp;Caractere(Retour chariot ))

         `--- Parcours du tableau et transformation de chaque ligne en élément
      Boucle($i;1;Taille tableau(xmlvalues_T_temp))
            `ouverture de l'élément enfant <value>
         C_TEXTE($_vt_RefValue)
         $_vt_RefValue:=DOM Creer element XML ($_vt_RefElement;$_s_ChildElement)
            `écriture de la valeur de l'élément <value>
         $_s_value:=xmlvalues_T_temp{$i}
         DOM ECRIRE VALEUR ELEMENT XML($_vt_RefValue;$_s_value)
      Fin de boucle

      TABLEAU TEXTE(xmlvalues_T_temp;0)

   Fin de si

Fin de si


III. Génération d'un document XML pour une sélection d'enregistrements

Maintenant que nous maîtrisons l'exécution des commandes DOM dans un cadre particulier, nous allons réaliser une routine qui aura pour objectif de convertir une sélection d'enregistrements en XML de manière générique. Dans cette première note technique, nous utiliserons les commandes DOM et nous verrons dans une seconde partie troisautres moyens de parvenir à nos fins.


Appel depuis l'extérieur

Ce genre de routines sera très utile pour la publication de données vers des clients non 4D : formulaires dynamiques, clients SOAP,...

Notre code est donc conçu de façon à ce qu'il puisse être appelé :

   · depuis un client HTML par un simple 4DACTION
   · depuis un client SOAP.


Présentation de l'exemple

Nous appliquerons ces routines à une structure volontairement très simple comprenant une seule table :

      Figure 3 : la structure d'exemple


Notre dialogue d’interface, accessible par le menu Fichier/démo, nous permettra d’appeler les différents modes de génération et de visualiser le résultat présenté dans une zone texte :


      Figure 4 : dialogue de test des différents modes de génération XML


Notez qu'en version 2004, les zones de texte sont désormais pourvues d’un ascenseur horizontal.


Traitement par DOM

Nous allons parcourir la sélection, et pour chaque enregistrement, parcourir l'ensemble des champs de la table et
les convertir en XML. Nous ne traitons pas les éléments binaires pour lesquels XML ne propose pas aujourd'hui
de solution simple et efficace.

Voici notre pseudo-code :

DOM_ListeEnregistrementsVersXML : parcourt une sélection d'enregistrements et retourne une structure XML :

         <root>
            <nom_table>structure de l'enregistrement</nom_table>
            <nom_table>structure de l’enregistrement</nom_table>
             ... (autant de fois que d’enregistrements dans la sélection)
         </root>
   Pour chaque enregistrement DOM_EnregistrementVersXML : convertit chaque champ en un élément   
   <nom_du_champ>valeur du champ</nom_du_champ>
   Pour chaque champ DOM_set_ElementWithValue : écrit un élément avec sa valeur


Et le résultat dans Internet Explorer (nous retrouvons ici l'un des points forts d'XML, si le document s'ouvre dans le navigateur c'est qu’il est bien formé, c'est-à-dire qu'il répond aux règles syntaxiques XML) :


      Figure 5 : le résultat de la conversion en XML visualisé dans Internet Explorer

Notez l'adresse d’appel : http://localhost:8080/4DACTION/CD_ListeXML/DOM.
Ce qui signifie envoyer une requête Web (http://) au serveur Web sur la même machine (localhost ou 127.0.0.1) sur le port 8080, appeler le point d'entrée 4DACTION/CD_ListeXML/DOM. 4DACTION étant un URL particulier pour le serveur Web de 4D, celui-ci traduit la requête en « appeler la méthode CD_ListeXML en lui passant le paramètre /DOM ».


Méthode CD_ListeXML

Voici le code de la méthode CD_ListeXML

   ` ----------------------------------------------------
   ` Nom utilisateur (OS) : Christophe Keromen
   ` Date et heure : 16/07/04, 09:55:08
   ` ----------------------------------------------------
   ` Methode : CD_Liste_XML
   ` Description
   ` Conversion d'une sélection d'utilisateur en XML et renvoie à un appel HTTP ou SOAP
   ` cette méthode peut aussi être appelée par get "http://serveur:8080/4DACTION/CD_Liste_XML/mode"
   `
   ` Parametres
   `$1:TEXTE:Mode (DOM-SAX-QR-Web)
   ` ----------------------------------------------------

C_TEXTE($1)
C_TEXTE($_vt_Mode)
$_vt_Mode:=$1

   `---Décodage du paramètre d'entrée
Si (Est une requete SOAP)
      `en mode dynamique, 4D s'occupe de tout
   DECLARATION SOAP($1;Est un texte ;SOAP entrée ;"modeConversionXML")
   Sinon  `requête HTTP
   $_vt_Mode:=Sous chaine($_vt_Mode;2)  `pour enlever le "/", ex. dans "/DOM"
Fin de si

   `--- Constitution de la sélection
LECTURE SEULEMENT([CD])
TOUT SELECTIONNER([CD])

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

   `--- conversion en XML
C_TEXTE($_vt_Methode_CallBack)
$_vt_Methode_CallBack:=""

C_BLOB(soap_vx_Return)
FIXER TAILLE BLOB(soap_vx_Return;0)

C_TEXTE(soap_vt_Return)
soap_vt_Return:=""

Au cas ou
   : ($_vt_Mode="DOM")
      soap_vt_Return:=DOM_ListeEnregistrementsVersXML (->[CD];$_vt_Methode_CallBack;->soap_vx_Return)
   : ($_vt_Mode="SAX")
      soap_vt_Return:=SAX_ListeEnregistrementsVersXML (->[CD];$_vt_Methode_CallBack;->soap_vx_Return)
   : ($_vt_Mode="QR")
      soap_vt_Return:=QR_ListeEnregistrementsVersXML (->[CD];$_vt_Methode_CallBack;->soap_vx_Return)
   : ($_vt_Mode="Web")
      soap_vt_Return:=Web_ListeEnregistrementsVersXML (->[CD] ;$_vt_Methode_CallBack ;->soap_vx_Return)
Fin de cas

   `--- Renvoi du résultat
Si (Est une requete SOAP)
   DECLARATION SOAP(soap_vt_Return ;Est un texte ;SOAP sortie ; "CD_Liste_XML_texte")
   DECLARATION SOAP(soap_vx_Return ;Est un BLOB ;SOAP sortie ; "CD_Liste_XML_BLOB")
      `maintenant 4D s’occupe de l’encodage et de l’envoi
   Sinon  `requête http
      `précisons le type MIME "text/xml" pour que le navigateur reconnaisse le XML
   ENVOYER BLOB HTML(soap_vx_Return ; "text/xml")
Fin de si


info Commentaires :

Remarquez la gestion des paramètres d'entrée-sortie suivant l'origine de l'appel, client SOAP ou requête http.

Avec SOAP, les paramètres sont nommés, décrits dans le WSDL et tout assistant du type de celui de 4D permet de générer facilement le code d’appel dit méthode proxy :


      Figure 6 : Assistant SOAP mettant en évidence les paramètres nommés


En revanche, dans le cas d’une requête http, il n'existe aucun moyen de savoir quel URL appeler et quel paramètre passer et suivant quelle syntaxe. D'un strict point de vue de consommation de ressources, la requête http reste cependant plus performante.

Méthode DOM_Liste_EnregistrementsVersXML

   ` ----------------------------------------------------
   ` Nom utilisateur (OS) : christophe Keromen
   ` Date et heure : 30/06/04, 23:02:34
   ` ----------------------------------------------------
   ` Methode : DOM_ListeEnregistrementsVersXML
   ` Description
   ` convertit une liste d'enregistrements en structure XML via écriture DOM
   `
   ` Notes :
   `- 4D 2004 (utilise les commandes d'écriture DOM)
   `- la sélection doit déjà exister
   `- ici on retourne ds un BLOB, attention à la taille du XML généré
   `
   ` Parametres
   `$1:POINTEUR:Table
   `$2:TEXTE:Methode à appeler en callback pour chaque enregistrement
   `$3:POINTEUR:BLOB:structure XML
   `$0:TEXTE:structure XML
   ` ----------------------------------------------------

C_POINTEUR($1)
C_POINTEUR($_vp_Table)
$_vp_Table:=$1

C_TEXTE($2)
C_TEXTE($_vt_Methode_CallBack)
$_vt_Methode_CallBack:=$2

C_POINTEUR($3)

C_TEXTE($0)
$0:=""

XML_AppelerSurErreur_set  `Installe une gestion d'erreurs

C_TEXTE($_vt_Last_xml_Error)
$_vt_Last_xml_Error:=""

   `--- Création du document XML en lui passant la racine nommée arbitrairement "root"
C_TEXTE($_vt_root)
$_vt_root:="root"

C_TEXTE($_vt_Ref_XML)
$_vt_Ref_XML:=DOM Creer ref XML($_vt_root)

   `--- Ecriture des options
C_TEXTE($_vt_Encodage)
$_vt_Encodage:="UTF-8"
`$_vt_Encodage:="ISO-8859-1"

C_BOOLEEN($_vb_SiAutonome)
$_vb_SiAutonome:=Vrai  `avec ou sans DTD externe

C_BOOLEEN($_vb_SiIndentation)
$_vb_SiIndentation:=Vrai  `avec whitespaces ou non de présentation

DOM ECRIRE OPTIONS XML($_vt_Ref_XML;$_vt_Encodage;$_vb_SiAutonome;$_vb_SiIndentation)

   `--- Export des enregistrements par parcours de la sélection
C_ENTIER($i)

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

      `--- Création de l'élément complexe contenant les champs de l'enregistrement courant
   C_ENTIER($_ve_SiEncodingISO)
   $_ve_SiEncodingISO:=0  `sans encodage ISO (encodage effectué automatiquement par les commandes DOM)

   C_TEXTE($_vt_ElementName)  `nom de l'élément, on pourrait églt prendre un nom générique , ex.<row>
   $_vt_ElementName:=XMLw_Replace_Char (Nom de la table($_vp_Table);"tag";$_ve_SiEncodingISO)

   C_TEXTE($_vt_RefElementRecord)
   $_vt_RefElementRecord:=DOM Creer element XML($_vt_Ref_XML;$_vt_ElementName)

      `--- Rétro-appel de la méthode convertissant l'enregistrement courant en XML
   Si ($_vt_Methode_CallBack#"")

      C_TEXTE($_vt_callback)
      $_vt_callback:=$_vt_Methode_CallBack+"("+Caractere(Guillemets)+$_vt_RefElementRecord+Caractere(Guillemets )+")"
      EXECUTER($_vt_callback)

   Sinon  `Générique de conversion en XML

      C_ENTIER($_ve_siEncodageIso)
      $_ve_siEncodageIso:=0  `pas d'encodage ISO
      DOM_EnregistrementVersXML ($_vt_RefElementRecord;$_vp_Table;$_vt_ElementName;$_ve_siEncodageIso)

   Fin de si

   $_vt_Last_xml_Error:=XML_AppelerSurErreur_getLastErr

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

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

   Sinon

      ENREGISTREMENT SUIVANT($_vp_Table->)

   Fin de si

Fin de boucle

   `--- Gestion des erreurs, validation et enregistrement
Si ($_vt_Last_xml_Error="")  `pas d'erreur

      `--- Le doc est-il bien formé ? (on pourrait aussi le valider/DTD)
   C_BLOB($_vx_XML)
   DOM EXPORTER VERS VARIABLE($_vt_Ref_XML;$_vx_XML)
   C_TEXTE($_vt_Ref_XML_Analyse)
   $_vt_Ref_XML_Analyse:=DOM Analyser variable XML($_vx_XML)

      `--- Conversion en texte
   DOM EXPORTER VERS VARIABLE($_vt_Ref_XML;$_vt_XML)
      `Bug 4D : DOM EXPORTER VERS VARIABLE devrait décoder en Mac Roman
   $_vt_XML:=ISO vers Mac($_vt_XML)

   ECRIRE TEXTE DANS PRESSE PAPIERS($_vt_XML)

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

         `Retour des valeurs
      $0:=$_vt_XML
      $3->:=$_vx_XML

   Sinon

      FIXER TAILLE BLOB($3->;0)
      ALERTE("Doc XML mal formé : l'arbre XML a été copié dans les presse-papiers")

   Fin de si

   DOM FERMER XML($_vt_Ref_XML_Analyse)  `l'arbre analysé

Sinon  `une erreur est survenue

   ALERTE($_vt_Last_xml_Error)

Fin de si

DOM FERMER XML($_vt_Ref_XML)  `l'arbre DOM généré
DEBUT SELECTION($_vp_Table->)  `on remet le pointeur en début de sélection

info Commentaires

Il est possible de passer un paramètre $2 désignant une méthode qui se chargera de convertir l'enregistrement courant en XML au lieu de la méthode générique DOM_EnregistrementVersXML. La routine XML_AppelerSurErreur_set appelle une simple gestion d'erreurs, la dernière erreur rencontrée peut être retrouvée en appelant la méthode accesseur XML_AppelerSurErreur_getLastErr.

DOM creer element XML se charge d’encoder les valeurs passées en accord avec l'option fixée dans DOM ECRIRE OPTIONS XML. Cependant, cela ne comprend pas la vérification des règles syntaxiques XML comme par exemple l'interdiction d’espace dans les noms d'éléments. C'est pourquoi nous traitons au préalable le nom de l'élément par la routine XMLw_Replace_Char déjà présentée dans la note technique 4D-200402-04- FR.

Une fois toute notre sélection d’enregistrements parcourue, nous utilisons la commande DOM EXPORTER VERS VARIABLE pour récupérer notre arbre DOM dans un BLOB que nous repassons immédiatement à DOM Analyser variable XML afin de vérifier si notre document est bien formé. Si tel est le cas, nous renvoyons à la méthode appelante la structure XML en BLOB et la structure XML convertie en texte. Cette dernière conversion souffre d’un bug de 4ème Dimension dans la version à la date de rédaction.

En effet, DOM EXPORTER VERS VARIABLE($_vt_Ref_XML;$_vt_XML) devrait décoder notre arbre XML encodé en UTF-8 pour, d'après la documentation, nous le ranger dans une variable texte en codage Mac Roman. Le décodage n'est pourtant pas effectué. C'est pourquoi nous conseillons en attendant la correction de ce bug et pour récupérer une version texte, de passer plutôt par un encodage en ISO-8859-1 puis de décodermanuellement (ISO vers Mac) la version texte de la structure XML.

Conversion des champs de l'enregistrement, DOM_EnregistrementVersXML :

   ` ----------------------------------------------------
   ` Nom utilisateur (OS) : christophe Keromen
   ` Date et heure : 15/07/04, 09:35:02
   ` ----------------------------------------------------
   ` Methode : DOM_EnregistrementVersXML
   ` Description
   ` Convertit de manière générique un enregistrement en XML
   `
   ` Notes :
   ` - ne traite pas les champs binaires
   `
   ` Parametres
   ` $1:TEXTE:Ref de l'élément parent
   ` $2:POINTEUR:Table
   ` $3:TEXTE:Nom parent pour préfixer
   ` $4:ENTIER:1 si encodage ISO à appliquer
   ` ----------------------------------------------------
   ` DOM_EnregistrementVersXML ($_vt_RefElementRecord;$_vp_Table;$_vt_ElementName;
   ` $_ ve_siEncodageIso)


C_TEXTE($1)
C_TEXTE($_vt_RefElement)
$_vt_RefElement:=$1

C_POINTEUR($2)
C_POINTEUR($_vp_PtTable)
$_vp_PtTable:=$2

C_ENTIER LONG($_vl_TableNo)
$_vl_TableNo:=Table($_vp_PtTable)

C_TEXTE($_vt_prefixe)
$_vt_prefixe:=""  `pour garantir unicité entre tables

C_ENTIER($_ve_siEncodageIso)
$_ve_siEncodageIso:=0  `pas d'encodage ISO

Si (Nombre de parametres=2)
Sinon
   $_vt_prefixe:=$3
   $_ve_siEncodageIso:=$4
Fin de si

C_ENTIER($i)
Boucle ($i;1;Nombre de champs($_vl_TableNo))

   C_POINTEUR($_vp_Champ)
   $_vp_Champ:=Champ($_vl_TableNo;$i)

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

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

      Si ($_vt_prefixe#"")
         $_vt_TagName:=$_vt_prefixe+"."+$_vt_TagName
      Fin de si

      C_ENTIER($_vl_TypeChamp)
      LIRE PROPRIETES CHAMP($_vp_Champ;$_vl_TypeChamp)
      C_TEXTE($_vt_Value)
      $_vt_Value:=""

      Au cas ou

         : (($_vl_TypeChamp=Est un champ alpha ) | ($_vl_TypeChamp=Est un texte ))
            $_vt_Value:=$_vp_Champ->

         : (($_vl_TypeChamp=Est un numérique ) | ($_vl_TypeChamp=Est un entier ) | ($_vl_TypeChamp=Est un entier long ))
            $_vt_Value:=Chaine($_vp_Champ->)

         : (($_vl_TypeChamp=Est une date ))
            $_vt_Value:=Chaine($_vp_Champ->;8)  `date Time

         : (($_vl_TypeChamp=Est une heure ))
            $_vt_Value:=Chaine($_vp_Champ->;h mn s )

         : (($_vl_TypeChamp=Est un booléen ))
            $_vt_Value:=Chaine(Num($_vp_Champ->))

         : ($_vl_TypeChamp=Est un BLOB )  `conversion base64 ?
               `-> il faut utiliser BASh, ça marche très bien
            $_vt_Value:="N/A"

         : ($_vl_TypeChamp=Est une image )  `conversion base 64 ?
            $_vt_Value:="N/A"

      Sinon
            `$0:=("Internal Error";"Unkown Fieldtyp - cannot handle";$fieldname)

      Fin de cas

      DOM_set_ElementWithValue ($_vt_RefElement;$_vt_TagName;$_vt_Value)

   Fin de si

Fin de boucle

info Commentaires

La routine xmlw_Si_ChampBinaire nous sert à filtrer les champs binaires que nous ne pouvons pas facilement convertir en texte. Une solution consisterait à utiliser un encodage en base64 grâce à la nouvelle commande de la version 2004, ENCODER.

Comme pour les noms de tables, nous pré-traitons les noms de champs dans la routine XMLw_Replace_Char. Par exemple, le nom du champ “[CD]Date Stock“ devient “DateStock“. 4D n’effectue pas automatiquement ce traitement, or les espaces étant interdits en XML dans les noms de champs, cela se traduirait par un document XML mal-formé et donc inexploitable.

Nous rajoutons également un préfixe (le nom de la table) au nom du champ, ainsi “[CD]Date Stock“ devient réellement “CD.DateStock“ dans le document XML produit. Dans le cadre de cet exemple, cela n’a pas réellement d’intérêt. Dans une version plus évoluée pouvant mixer au sein d’un même document XML des champs provenant de plusieurs tables, il pourrait se produire des conflits entre des champs portant le même nom dans des tables différentes. Nous passons ici d’un nom local “ID“ par exemple à un nom global “Table1.ID“ qui ne peut être confondu avec un autre nom global possédant un nom local identique, “Table2.ID“ par exemple. Une solution plus canonique par rapport à XML consisterait à utiliser des espaces de noms différents pour chacune des tables.

Cette routine n'est pas optimisée. Il serait plus efficace d’analyser une fois pour toute la structure de la table, et construire un tableau en mémoire contenant les éléments nécessaires pour la génération de la structure XML correspondante et d’utiliser ce tableau pour chaque enregistrement. Ici, l'analyse de la table est répétée pour chaque enregistrement.

Méthode DOM_set_ElementWithValue

C'est la méthode qui se charge de créer un élément simple et sa valeur en un seul appel.

   ` ----------------------------------------------------
   ` Nom utilisateur (OS) : christophe Keromen
   ` Date et heure : 30/06/04, 18:00:36
   ` ----------------------------------------------------
   ` Methode : DOM_set_ElementWithValue
   ` Description
   ` écrit un élément avec sa valeur
   `
   ` Parametres
   `$1:TEXTE:Ref Element Parent
   `$2:TEXTE:Nom element à créer
   `$3:TEXTE:Valeur element à créer
   `$0:TEXTE:Ref Element créé
   ` ----------------------------------------------------

C_TEXTE($1)
C_TEXTE($_vt_RefParent)
$_vt_RefParent:=$1

C_TEXTE($2)
C_TEXTE($_vt_NomElement)
$_vt_NomElement:=$2

C_TEXTE($3)
C_TEXTE($_vt_ValeurElement)
$_vt_ValeurElement:=$3

C_TEXTE($0)
C_TEXTE($_vt_RefElement)
$_vt_RefElement:=""
$_vt_RefElement:=DOM Creer element XML($_vt_RefParent;$_vt_NomElement)

DOM ECRIRE VALEUR ELEMENT XML($_vt_RefElement;$_vt_ValeurElement)

$0:=$_vt_RefElement


IV. Conclusion

Cette note technique vous a présenté deux exemples d’application des nouvelles commandes de génération XML par DOM dans 4D 2004. Il est maintenant facile de publier vers l'extérieur vos données sous une forme standardisée même si l'automatisation de nombreuses tâches par 4D ne dispense pas d'un minimum de connaissance des règles XML.

Nous verrons dans la deuxième partie de cette note qu'il existe d’autres moyens de produire du XML dans la version 2004 de 4D.


V. Base exemple

Téléchargez la base exemple.

__________________________________________________
Copyright © 1985-2009 4D SA - Tous droits réservés
Tous les efforts ont été faits pour que le contenu de cette note technique présente le maximum de fiabilité possible.
Néanmoins, les différents éléments composant cette note technique, et le cas échéant, le code, sont fournis sans garantie d'aucune sorte. L'auteur et 4D S.A. déclinent donc toute responsabilité quant à l'utilisation qui pourrait être faite de ces éléments, tant à l'égard de leurs utilisateurs que des tiers.
Les informations contenues dans ce document peuvent faire l'objet de modifications sans préavis et ne sauraient en aucune manière engager 4D SA. La fourniture du logiciel décrit dans ce document est régie par un octroi de licence dont les termes sont précisés par ailleurs dans la licence électronique figurant sur le support du Logiciel et de la Documentation afférente. Le logiciel et sa documentation ne peuvent être utilisés, copiés ou reproduits sur quelque support que ce soit et de quelque manière que ce soit, que conformément aux termes de cette licence.
Aucune partie de ce document ne peut être reproduite ou recopiée de quelque manière que ce soit, électronique ou mécanique, y compris par photocopie, enregistrement, archivage ou tout autre procédé de stockage, de traitement et de récupération d'informations, pour d'autres buts que l'usage personnel de l'acheteur, et ce exclusivement aux conditions contractuelles, sans la permission explicite de 4D SA.
4D, 4D Calc, 4D Draw, 4D Write, 4D Insider, 4ème Dimension ®, 4D Server, 4D Compiler ainsi que les logos 4e Dimension, sont des marques enregistrées de 4D SA.
Windows,Windows NT,Win 32s et Microsoft sont des marques enregistrées de Microsoft Corporation.
Apple, Macintosh, Power Macintosh, LaserWriter, ImageWriter, QuickTime sont des marques enregistrées ou des noms commerciaux de Apple Computer,Inc.
Mac2Win Software Copyright © 1990-2002 est un produit de Altura Software,Inc.
4D Write contient des éléments de "MacLink Plus file translation", un produit de DataViz, Inc,55 Corporate drive,Trumbull,CT,USA.
XTND Copyright 1992-2002 © 4D SA. Tous droits réservés.
XTND Technology Copyright 1989-2002 © Claris Corporation.. Tous droits réservés ACROBAT © Copyright 1987-2002, Secret Commercial Adobe Systems Inc.Tous droits réservés. ACROBAT est une marque enregistrée d'Adobe Systems Inc.
Tous les autres noms de produits ou appellations sont des marques déposées ou des noms commerciaux appartenant à leurs propriétaires respectifs.
__________________________________________________
 



Valid XHTML 1.1!Valid CSS!

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.
Contacter le responsable de la rubrique 4D