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>.
 |
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
 |
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
 |
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
 |
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
__________________________________________________
Copyright © 1985-2008 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.
__________________________________________________
 
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.
|