asp_xml

Module 21: DEVELOPPEMENT ET DEPLOIEMENT DE SITES WEB DYNAMIQUES Page 1 sur 67

Module 21:

DEVELOPPEMENT ET DEPLOIEMENT DE SITES WEB

DYNAMIQUES ContenuI. INTRODUCTION........................................................................................................................................4

1. Pages Web statiques, Pages Web dynamiques.....................................................................................41. Serveur Web passif............................................................................................................................... 42. Serveur Web actif..................................................................................................................................53. Technologies coté client........................................................................................................................54. Technologies coté serveur.................................................................................................................... 55. Présentation de ASP.NET......................................................................................................................56. Créer un site exemple sur votre machine.............................................................................................6

II. Démarrer une application web (Voir tp1.docx)........................................................................................7III. Gestion des états de session et d’application..........................................................................................7

1. Application............................................................................................................................................ 72. Session.................................................................................................................................................. 73. PostBack................................................................................................................................................84. Les Server Controls............................................................................................................................... 85. ViewState..............................................................................................................................................86. Cookies..................................................................................................................................................97. Variable de session............................................................................................................................... 98. Variable d'application......................................................................................................................... 109. QueryString......................................................................................................................................... 10

IV. Travailler la présentation graphique (voir TP2)......................................................................................11V. La navigation du site web (Voir TP3)......................................................................................................11VI. Accès aux données (Voir TP4)...............................................................................................................11


1. Connexion à la base de données.........................................................................................................112. Source de données..............................................................................................................................12

a) SqlDataSource :............................................................................................................................12b) LinqDataSource............................................................................................................................12

3. Résultat............................................................................................................................................... 144. Affichage et mise à jour des données.................................................................................................14

VII. Ajout de contrôles et contrôles de validation (voir TP5).....................................................................14VIII. Création d'un site Web Sécurisé.........................................................................................................14

1. Configuration de l'appartenance.......................................................................................................15

c) Pour ajouter un nouveau dossier au site Web................................................................................15d) Pour créer un utilisateur d'appartenance....................................................................................15e) Pour définir des règles d'accès pour le sous-répertoire PagesMembres.....................................16

2. Connexion de l'utilisateur..................................................................................................................16

f) Pour créer une page d'accueil avec un bouton de connexion.........................................................16g) Pour créer une page de connexion..............................................................................................17h) Affichage des erreurs de connexion.............................................................................................17

3. Affichage d'informations pour les utilisateurs connectés...................................................................17

i) Pour personnaliser l'affichage pour les utilisateurs connectés........................................................17

4. Création d'utilisateurs........................................................................................................................18

j) Pour créer une page d'inscription...................................................................................................18k) Pour créer un lien d'inscription sur la page d'accueil...................................................................18

5. Modification de mots de passe..........................................................................................................19

l) Pour créer une page de modification de mot de passe...................................................................19m) Pour créer un lien de modification de mot de passe sur la page d'accueil..................................19

6. Récupération d'un mot de passe.......................................................................................................20

n) Pour ajouter la récupération de mot de passe............................................................................20

IX. Développer un service Web...................................................................................................................21X. XML et technologies associés.................................................................................................................21

1. XML..................................................................................................................................................... 21

a) Généralité.................................................................................................................................... 21b) Concevoir un document XML.......................................................................................................21

2. DTD..................................................................................................................................................... 223. Pourquoi utiliser une DTD ?................................................................................................................ 224. Types de DTD...................................................................................................................................... 22

c) DTD interne..................................................................................................................................... 22d) DTD externe.................................................................................................................................23e)............................................................................................................................................................ 23

5. Déclarations d’éléments..................................................................................................................... 23

f) Elément texte.................................................................................................................................. 24g) Elément vide................................................................................................................................ 24

6. Indicateurs d'occurrence.....................................................................................................................24

Séquence d'éléments.............................................................................................................................24


h) Choix d'éléments......................................................................................................................... 25i) Choix d'éléments(suite)...................................................................................................................26Elément quelconque..............................................................................................................................26j) Elément à contenu mixte................................................................................................................ 26

7. Déclarations d'attributs.......................................................................................................................27

Type chaîne de caractères..................................................................................................................... 27k) Valeurs par défaut....................................................................................................................... 28l) Déclaration d'un attribut requis......................................................................................................28m) Déclaration d'un attribut optionnel :...........................................................................................28Déclaration d'un attribut avec une valeur fixe :.....................................................................................28n) Type ID......................................................................................................................................... 28NMTOKEN(S).......................................................................................................................................... 29Type énuméré........................................................................................................................................ 29o) TP 21 : Exemple Bibliographie DTD..............................................................................................29a) Exercice1 DTD.............................................................................................................................. 29b) Exercice2 DTD (attributs).............................................................................................................30

8. XSD...................................................................................................................................................... 31

a) Généralité.................................................................................................................................... 31b) Construction d’un schéma...........................................................................................................31c) Déclaration d’un élément simple....................................................................................................31d) Valeur par défaut et valeur fixée pour un type simple................................................................33e) Déclaration d’attributs.................................................................................................................33f) Restriction à des valeurs..................................................................................................................34g) Restriction à un ensemble de valeurs..........................................................................................34h) Restriction à une série de valeurs................................................................................................34i) Eléments complexes........................................................................................................................36j) Les indicateurs.................................................................................................................................38

9. XSLT..................................................................................................................................................... 41

a) Introduction.................................................................................................................................41b) Caractéristiques...........................................................................................................................41c) Structure d’un fichier XSL................................................................................................................42d) format de sortie : <xsl:output>....................................................................................................42e) Règle de transformation : <xsl:template>....................................................................................43f) <xsl:value-of>.................................................................................................................................. 43g) Le déclenchement d’une règle de transformation.......................................................................44h) Exemples de mises en forme.......................................................................................................45i) <xsl:element>non traité.................................................................................................................. 48j) <xsl:attribute>................................................................................................................................. 48k) Syntaxe courte.............................................................................................................................49a) <xsl:param>................................................................................................................................. 49a) <xsl:for-each>.............................................................................................................................. 50a) <xsl:if>..........................................................................................................................................50b) <xsl:choose>................................................................................................................................ 51c) <xsl:number>...................................................................................................................................51d) <xsl:sort>..................................................................................................................................... 51

10. XPath............................................................................................................................................... 52

a) Introduction.................................................................................................................................52a) Sélection d'élément, syntaxe de base...........................................................................52


b) Chemin de localisation.................................................................................................................53c) Exemple de chemins de localisation................................................................................................53d) Axes............................................................................................................................................. 54a) Sélection d'attributs.....................................................................................................................55b) appel de fonctions.................................................................................................................55c) Opérateurs logiques........................................................................................................................56d) Exercice :......................................................................................................................................56e) Syntaxe abrégée.......................................................................................................................... 57

I. INTRODUCTION1. Pages Web statiques, Pages Web dynamiques

Une page statique est représentée par un fichier HTML. Une page dynamique est, elle, générée "à la volée" par le serveur web.Exemple d’une page statique :<html><head>

<title>essai 1 : une page statique</title></head><body><center><h1>Une page statique...</h1></body></html>

1. Serveur Web passif


2. Serveur Web actif

3. Technologies coté client DHTML : combine HTML, JAVASCRIPT et CSS JAVASCRIPT HTML5 : HTML , JAVASCRIPT et CSS 4. Technologies coté serveur PHP / MYSQL JSP ASP .NET5. Présentation de ASP.NET

Asp.NET est basé sur la technologie .NET. Il permet la programmation d’applications Web dynamiques, du côté du serveur.Le schéma suivant illustre le fonctionnement d'ASP.NET dans l'environnement .Net avec le serveur IIS (serveur web fournis par Windows) :

1 = vous tapez une url dans votre navigateur et donc, envoyez une requête pour une page aspx d'un client web vers le serveur IIS

2 = la requête est analysée et le traitement est transféré au runtime, un processus est créé pour exécuter l'application

--> S'il s'agit de la première exécution du code de cette page, le compilateur JIT (Just In Time) compile le code en binaire natif et le stoque en mémoire.

--> Si ce n'est pas la première exécution, le code binaire est chargé depuis le cache. 3 = ce code binaire est exécuté puis renvoyé vers le serveur IIS 4 = IIS renvoie la réponse sous la forme de code HTML strict vers l'utilisateur. Ce code HTML

est affiché dans votre navigateur.


Environnement de développement :Un serveur Web : Seveur IISFramework: installé avec VisualStudio .NetUn EDI : VisualStudio .Net, pas nécessaire mais pratique

Exemple : (dans un fichier bloc note)<%@ Page Language="C#" %><html> <body> <h1>Bonjour</h1> <br /> <h2>Nous sommes le <%= DateTime.Now.ToString() %>.</h2> </body></html>

6. Créer un site exemple sur votre machinea. Allez dans Panneau de configuration\Tous les Panneaux de configuration\Outils

d’administrationb.

c. Ouvrir le bloc-notes et créer un fichier avec ce code puis sauvegarder-le à la racine du site que vous avez créé en le nommant par exemple "bonjour.aspx".<%@ Page Language="C#" %><html> <body> <h1>Bonjour</h1> <br /> <h2>Nous sommes le <%= DateTime.Now.ToString() %>.</h2> </body></html>


d. Exécutez cette page aspx dans votre navigateur en tapant son adresse dans la barre de navigation :http://localhost/PremierePage/bonjour.aspx

II. Démarrer une application web (Voir tp1.docx)

III. Gestion des états de session et d’application Les événements assez particuliers et très importants pour le déroulement et le contrôle d’une application ASP.NET :

1. Application

Evénement Description

Application_Start Exécuté lors du premier appel à une page du site depuis le démarrage de IIS

Application_End Appelé lorsque l'application se termine, cela ne signifie pas que IIS s'arrête mais est d'office appelé si, pour une raison quelconque IIS est arrêté

2. Session

Evénement DescriptionSession_Start appelé lors de chaque nouvelle session d'un navigateur client

Session_End fin de session : lors d'un timeout ou lors d'une destruction explicite (Session.Abandon()) via un lien "Log Out" par exemple

Il faut aussi savoir qu'une session peut stocker ses données en mode "InProc" (dans le process en mémoire) ou en mode "Sql..." (dans une BD SqlServer) .Application et Session sont des notions très importantes en ASP.NET. Elles jouent en effet un rôle très actif au niveau de la vie d'un site et, notamment, au niveau de la pérénité des données véhiculées dans le site lui-même.

Un petit schéma pour mieux visualiser la différence entre "Application" et "Session" :


Soit trois utilisateurs U1, U2 et U3 qui envoient une requête vers le serveur IIS. Il y aura un seul objet "Application" commun à tous les utilisateurs du site mais trois objets "Session" correspondant chacun à un utilisateur précis.

3. PostBack

Cet événement génère un appel au serveur. Dans ASP.NET , la page se rappelle continuellement en déclenchant cet événement. C'est au programmeur de créer les conditions de passage d'une page à l'autre.

IsPostBack est une propriété de la page booléenne (read-only) qui permet justement d'effectuer ce genre de test.Par exemple, on l'utilise dans l'événement Page_Load pour éviter de recharger des données persistantes.

AutoPostBack est une propriété des contrôles qui active le déclenchement d'un aller retour sur le serveur.

4. Les Server ControlsUn petit mot sur les types de contrôles présents dans ASP.NET. Il existe deux jeux de contrôles s'exécutant côté serveur :Les Web Controls, gérés par des événements, ils ressemblent plus aux objets utilisés dans du développement winforms c'est-à-dire qu'ils possèdent des propriétés ("font", "backcolor", ...) facilitant la mise en forme. Ils dépendent de "System.Web.UI.WebControls".Les HTML Controls qui correspondent directement aux balises HTML. Les attributs des balises correspondantes sont accessibles via les propriétés de ces contrôles. Pour faire une analogie avec les "WebControls", ceux-ci ne possèdent qu'une balise "Style" pour la mise en forme, cela est plutôt limitatif.Ces derniers dépendent eux de "System.Web.UI.HtmlControls".

5. ViewStateLe ViewState représente l'état de l'ensemble des contrôles d'un page. Les informations sont sauvées sous forme d'un flux sérialisé dans la page HTML et le champ caché _VIEWSTATE permet le transit de ces informations entre le client et le serveur.Il peut être désactivé au niveau d'un contrôle, au niveau d'une page ou au niveau d'une application en plaçant la propriété EnabledViewState à False.Le plus intéressant est que le programmeur peut y ajouter ses propres informations sous forme d'objets indexés par une clé de type String.

Pour sauvegarder et lire une information, voici comment utiliser le ViewState, par exemple pour modifier un argument dans une requête de sélection : protected void Page_Load(object sender, EventArgs e) { if ( !IsPostBack) { ViewState["tri"]="nom";


ConstruireRequete(); } } void ConstruireRequete() { String tri= Convert.ToString(ViewState["tri"]);

String rq = "SELECT * FROM UneTable ORDER BY " + tri;

}

6. CookiesLes cookies permettent aux applications Web de stocker des informations spécifiques à l'utilisateur. Par exemple, lorsqu'un utilisateur visite votre site, les cookies peuvent vous servir à stocker ses préférences, ou d'autres informations. Lorsque cet utilisateur revient visiter votre site Web, l'application peut récupérer les informations stockées précédemment.

Exemple de Création de cookie

String User = "neo";HttpCookie cookie = new HttpCookie("User");cookie.Values.Add("User", User);Response.Cookies.Add(cookie);

Exemple de Lecture de cookie HttpCookie cookie = Request.Cookies[0]; String User = cookie.Value;

Détecter si le navigateur supporte les cookies Boolean CookiesSupported = Request.Browser.Cookies;

Supprimer un cookieVous ne pouvez pas supprimer directement un cookie sur l'ordinateur d'un utilisateur. Mais vous pouvez donner au navigateur de l'utilisateur l'ordre de supprimer le cookie en réglant la date d'expiration de ce cookie sur une date révolue. La prochaine fois que l'utilisateur soumettra une demande à une page dans le domaine ou le chemin d'accès où se trouve le cookie, le navigateur jugera que le cookie a expiré et le supprimera.String User = "neo";HttpCookie myCookie = new HttpCookie("User");myCookie.Expires = DateTime.Now.AddDays(-1D);myCookie.Values.Add("User", User);Response.Cookies.Add(myCookie);

7. Variable de session

"Session" est un objet qui permet de conserver des données tout le long d’une session utilisateur.Il comporte plutôt comme une table de hachage. Prenons deux pages aspx : page1.aspx : page dans laquelle nous encodons, par l'intermédiaire d'une TextBox, un nom de sociétépage2.aspx : page dans laquelle nous affichons le nom de la société (vous comprenez que le


but est d'avoir une page d'affichage de données de société se trouvant par exemple dans une base de données)

protected void Button1_Click(object sender, EventArgs e) { Session["nom"] = "jouhari"; Response.Redirect("page2.aspx") ; }

Code de la page1.aspx : L'utilisateur introduit un nom de société dans la TextBox nommée "txtNomSoc". Cette information est sauvée en Session avant de passer à la page2.aspx

protected void Page_Load(object sender, EventArgs e) { if (!(Session["nom"] == null)) TextBox1.Text = Session["nom"].ToString(); else TextBox1.Text = "Aucun nom n'a été spécifié";

}Code de la page2.aspx : Un test est effectué pour savoir si la variable de session contient bien une donnée.

8. Variable d'application

La grande différence avec l'objet Session se situe dans le fait qu'un objet Application conserve des données pour l'ensemble des utilisateurs d'un même site web. Il s'utilise de la même manière que l'objet Session. L'objet Application étant commun à tous les utilisateurs du site, il est préférable de bloquer l'accès lors de l'écriture et, bien entendu, de ne pas oublier l'action inverse.

protected void Page_Load(object sender, EventArgs e) { int cpt = 0; Application.Lock(); if(!(Application["Nbr"]==null)) cpt = Convert.ToInt32(Application["NbrVisiteur"]); cpt++; Application["NbrVisiteur"] = cpt; Application.UnLock(); Label2.Text = "Page vue : " + cpt + " fois."; }

9. QueryString

QueryString permet de faire passer des informations via l'URI d'une page à une autre.En reprenant l'exemple d'un ID de société sélectionné dans une page dont les données sont présentées dans une autre page, on aurait très bien pu indiquer cet ID via l'URI lors de l'appel à la deuxième page.


Vous avez choisi la société ayant un ID = 1235, voici comment passer l'identifiant à la page suivante :<A href="page2.aspx?idsoc=1235"></A> Pour récupérer l'ID dans la seconde page, il vous suffira de coder comme suit : <p>Vous avez choisi la société : & Request.QueryString("idsoc")</p>

Vous comprenez maintenant le pourquoi de certaines url complexes du genre :http://www.monsite.com/repertoire/liste.asp?id=1257&lng=fr&action=del&[email protected]

IV. Travailler la présentation graphique (voir TP2)V. La navigation du site web (Voir TP3)

VI. Accès aux données (Voir TP4)1. Connexion à la base de données

1ère façon :

2ème façon (nous avons juste le fichier mdf) :Ajouter le dossier App_Data :

Ajouter un élément existant(vous pouvez également rajouter un nouvel élément pour créer une BD):


Puis choisir son ficher .mdf de sa base de données2. Source de données

Vous avez 2 options :a) SqlDataSource :

Le contrôle SqlDataSource vous permet d'exécuter les opérations d'instructions Select, Update, Insert ou Delete sans écrireInsérer un contrôle SqlDataSource et configurer le ( choisir la table et la connexion .si pas de connexion on vous propose d’en créer une).

b) LinqDataSourceVous utiliserez le Concepteur Objet/Relationnel pour créer une classe qui représente la table de la base de données contenant les valeurs. Le contrôle LinqDataSource agira sur cette classe générée afin de récupérer, de mettre à jour, d'insérer et de supprimer des données.Pour utiliser le contrôle LinqDataSource, il faut créer les classes qui représentent des entités de base de données :Pour créer une classe pour la table Film

1. Si le site Web ne possède pas déjà un dossier App_Code, dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, cliquez sur Ajouter le dossier ASP.NET, puis cliquez sur App_Code.

2. Cliquez avec le bouton droit sur le dossier App_Code, puis cliquez sur Ajouter un nouvel élément.

3. Sous Modèles installés, sélectionnez le modèle Classes LINQ to SQL, renommez le fichier cinema.dbml, puis cliquez sur Ajouter.


Le Concepteur Objet/Relationnel s'affiche.4. Dans l'Explorateur de serveurs, faites glisser la table Film dans la fenêtre du Concepteur

Objet/Relationnel. La table Film et ses colonnes sont représentées comme une entité nommée Film dans la fenêtre du Concepteur O/R.

5. Enregistrez le fichier cinema.dbml.6. Dans l'Explorateur de solutions, ouvrez le fichier cinema.designer.vb.

Remarquez qu'il comporte deux classes : cinemaDataContext et Film. La classe cinemaDataContext représente la base de données et la classe Film représente la table de base de données. Le constructeur sans paramètre pour la classe cinemaDataContext lit la chaîne de connexion du fichier Web.config.

7. Ouvrez le fichier Web.config.


Remarquez que la chaîne de connexion a été ajoutée dans l'élément connectionStrings.8. Fermez le fichier de classe et le fichier Web.config.

Maintenant que vous avez une table de base de données et des classes qui représentent des entités de base de données, vous pouvez utiliser un contrôle LinqDataSource sur une page Web ASP.NET pour gérer des données :Pour créer et configurer un contrôle LinqDataSource

1. Dans Visual Studio, créez une page Web ASP.NET et basculez en mode Design.2. À partir de l'onglet Données de la Boîte à outils, faites glisser un contrôle LinqDataSource et

déposez-le dans l'élément form de la page Web. Vous pouvez conserver à la propriété ID la valeur LinqDataSource1.

3. Affectez à la propriété ContextTypeName la valeur CinemaDataContext.4. Affectez à la propriété TableName la valeur Film.5. Affectez à AutoPage la valeur true et basculez en mode Source.

L'exemple suivant illustre le balisage déclaratif du contrôle LinqDataSource.<asp:LinqDataSource ContextTypeName="CinemaDataContext" TableName="Film" AutoPage="true" ID="LinqDataSource1" runat="server"></asp:LinqDataSource>Remarquez que vous n'avez pas eu à spécifier de commandes de base de données pour sélectionner les données.

3. RésultatVous pouvez à présent ajouter un contrôle DetailsView et le lier au contrôle LinqDataSource ou au contrôle SqlDatasource. Le contrôle DetailsView permet aux utilisateurs de consulter des données gérées par le contrôle LinqDataSource.

4. Affichage et mise à jour des donnéesa) ListViewb) GridViewc) DetailView

VII. Ajout de contrôles et contrôles de validation (voir TP5)VIII. Création d'un site Web Sécurisé

La limitation de l'autorisation de consulter certaines pages à quelques membres et à d'autres utilisateurs authentifiés est une condition de sécurité courante des sites Web. Dans ce cas, l'application doit inviter l'utilisateur à entrer un nom et un mot de passe. Cette procédure pas à pas illustre les tâches suivantes :


Configuration d'une application afin d'inclure des services d'appartenance d'ASP.NET et définition des utilisateurs.

Utilisation de contrôles de connexion afin d'obtenir les informations d'identification de l'utilisateur et d'afficher les informations aux utilisateurs connectés.

Protection d'une ou plusieurs pages dans votre application afin que seuls les utilisateurs connectés puissent les consulter.

Autorisation d'inscription à votre site accordée à de nouveaux utilisateurs. Autorisation de modification et de réinitialisation de leurs mots de passe.1. Configuration de l'appartenance

À une étape ultérieure de cette procédure, vous mettrez des pages dans un sous-répertoire qui est protégé. Vous devez créer le sous-répertoire maintenant afin que vous puissiez configurer sa sécurité ultérieurement dans la procédure pas à pas.

c) Pour ajouter un nouveau dossier au site Web1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom de votre site Web,

puis cliquez sur Nouveau dossier.2. Nommez le dossier PagesMembres.

Avant d'utiliser l'appartenance d'ASP.NET, vous devez configurer votre application afin d'activer l'appartenance et de définir des utilisateurs. Vous pouvez utiliser l'outil Administration de site Web qui fournit un assistant pour définir des paramètres de configuration. Lorsque vous terminez les étapes de l'Assistant, une base de données SQL Server nommée ASPNETDB.MDF est créée dans le dossier App_Data du projet.Pour cette procédure pas à pas, vous définirez un mono-utilisateur.

d) Pour créer un utilisateur d'appartenance1. Dans le menu Site Web, cliquez sur Configuration ASP.NET.2. Sélectionnez l'onglet Sécurité, cliquez sur le lien vers Utilisez l'Assistant Installation de

sécurité pour configurer la sécurité étape par étape, puis cliquez sur Suivant.3. Passez à l'étape 2 de l'Assistant et sélectionnez l'option À partir d'Internet.

L'Assistant affiche une page dans laquelle vous pouvez sélectionner la méthode d'authentification que votre site Web utilisera. Cette option spécifie que votre application utilisera l'authentification par formulaire, dans laquelle les utilisateurs se connecteront à l'application à l'aide d'une page de connexion que vous créerez à une étape ultérieure de cette procédure.

4. Cliquez sur Suivant.L'Assistant affiche un message qui déclare que les informations utilisateur seront stockées à l'aide de Paramètres avancés des fournisseurs. Par défaut, les informations d'appartenance sont stockées dans un fichier de base de données Microsoft SQL Server Express dans le dossier App_Data de votre site Web.

5. Cliquez sur Suivant.L'Assistant affiche une option pour créer des rôles. Vous effectuerez cette étape séparément à une étape ultérieure de cette procédure pas à pas. Par conséquent, n'activez pas la case à cocher Active les rôles pour ce site Web.

6. Cliquez sur Suivant.L'Assistant affiche une page dans laquelle vous pouvez créer de nouveaux utilisateurs.

7. Entrez les informations qui définissent un utilisateur de votre application. Utilisez les valeurs suivantes comme indications (vous pouvez utiliser toutes valeurs que vous souhaitez, mais assurez-vous de noter vos entrées pour une étape ultérieure de la procédure pas à pas) :


o Nom d'utilisateur Votre nom (sans espaces) ou un nom d'exemple.o Mot de passe Un mot de passe. Un mot de passe fort est requis (mot de passe qui inclut des

majuscules et des minuscules, un signe de ponctuation et qui comprend au moins huit caractères).

o Adresse de messagerie Votre adresse de messagerie personnelle. À une étape ultérieure de cette procédure pas à pas, vous vous enverrez un message électronique, vous avez donc besoin d'une adresse de messagerie valable.

o Question de sécurité et Réponse de sécurité Tapez une question et une réponse à la question qui puissent être utilisées ultérieurement si vous avez besoin de récupérer votre mot de passe.

8. Cliquez sur Créer un utilisateur.L'Assistant affiche une page de confirmation.

Remarque :Gardez l'outil Administration de site Web ouvert.

Précédemment dans la procédure pas à pas, vous avez créé un dossier nommé PagesMembres. Dans cette partie de la procédure pas à pas, vous créerez une règle qui assure que seuls les utilisateurs connectés peuvent accéder aux pages de ce dossier.

e) Pour définir des règles d'accès pour le sous-répertoire PagesMembres1. Dans l'Assistant, cliquez sur Suivant.

L'Assistant affiche une page qui vous permet de créer des règles d'accès. 2. Dans la zone Ajouter une nouvelle règle d'accès, développez le nœud de votre site Web. 3. Sélectionnez PagesMembres, le dossier que vous avez créé précédemment.4. Sous La règle s'applique à, sélectionnez Utilisateurs anonymes.5. Sous Autorisation, sélectionnez Refuser.

La règle que vous créez refuse l'accès aux utilisateurs anonymes, c'est-à-dire les utilisateurs qui ne sont pas connectés.

6. Cliquez sur Ajouter cette règle.La nouvelle règle est affichée dans la grille au-dessous. Lorsque les utilisateurs demandent une page du sous-répertoire PagesMembres, les règles sont vérifiées pour déterminer si l'accès à la page est autorisé à l'utilisateur.

7. Cliquez sur Terminer.Vous en avez maintenant fini avec l'Assistant. L'Assistant ferme et vous revenez à l'onglet Sécurité de l'outil Administration de site Web.

2. Connexion de l'utilisateur Dans le cadre de votre application, vous devez établir l'identité de l'utilisateur afin que l'application puisse effectuer des actions, telles que l'affichage ou le masquage des informations, selon l'identité de l'utilisateur. Pour obtenir l'identité de l'utilisateur, l'utilisateur doit être connecté.Dans cette procédure pas à pas, vous ajouterez un lien sur la page d'accueil qui mène les utilisateurs à une page de connexion, puis vous créerez la page de connexion.

f) Pour créer une page d'accueil avec un bouton de connexion1. Ouvrez ou basculez vers la page Default.aspx de votre site. (Si vous n'avez pas de page

Default.aspx, vous pouvez en ajouter une ou utiliser une page différente.)2. Basculez en mode Design.


3. Tapez le texte statique tel que Bienvenue sur notre site et dans la barre d'outils « Mise en forme », utilisez la liste déroulante « Format du bloc » pour mettre en forme le texte en Heading 1.

4. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle LoginStatus sur la page.Par défaut, le contrôle LoginStatus est affiché comme un lien. Lorsque les utilisateurs cliquent sur ce dernier, l'application affiche une page de connexion. Vous pouvez à présent créer la page de connexion.

g) Pour créer une page de connexion1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur votre application Web, puis

sélectionnez Ajouter un nouvel élément. Ajoutez un Formulaire Web nommé Login.aspx à votre site.

Remarque :Pour cette procédure pas à pas, la page doit être nommée Login.aspx. Par défaut, l'authentification par formulaire est configurée pour utiliser une page portant ce nom. Même si vous n'aurez pas à le faire dans cette procédure pas à pas, il est possible de modifier la page de connexion par défaut, c'est-à-dire la page vers laquelle les utilisateurs sont redirigés, dans le fichier Web.config.

2. Dans la page Login.aspx, basculez en mode Design.3. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle Login sur la

page. Le contrôle Login est un contrôle unique qui invitera l'utilisateur à entrer les informations d'identification et les validera.

h) Affichage des erreurs de connexionLe contrôle Login inclut la validation qui aide les utilisateurs à entrer des informations correctes. Par exemple, si un utilisateur ignore le mot de passe, un contrôle de validateur affiche un astérisque (*) en regard de la zone Mot de passe. Vous pouvez fournir des informations plus complètes sur les erreurs de connexion en ajoutant un contrôle ValidationSummary à la page.

3. Affichage d'informations pour les utilisateurs connectésVous allez maintenant modifier la page d'accueil pour personnaliser l'affichage selon que l'utilisateur est connecté ou non. Les utilisateurs anonymes verront un message générique qui les invite à se connecter. Les utilisateurs connectés verront un message qui les accueille par leur nom de connexion.

i) Pour personnaliser l'affichage pour les utilisateurs connectés1. Basculez vers la page Default.aspx ou ouvrez-la.2. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle LoginView sur

la page. Le contrôle LoginView est affiché avec son modèle AnonymousTemplate ouvert. Ce modèle vous permet de définir le contenu que les utilisateurs verront avant qu'ils se soient connectés.

3. Cliquez sur la zone d'édition du contrôle LoginView pour activer l'édition.4. Dans la zone d'édition du modèle AnonymousTemplate du contrôle LoginView, tapez Vous

n'êtes pas connecté. Cliquez sur le lien Connexion pour vous inscrire.


5. Dans le panneau Tâches LoginView, dans la liste Affichages, cliquez sur LoggedInTemplate. Si vous ne voyez pas le panneau Tâches LoginView, cliquez avec le bouton droit sur le titre du contrôle LoginView et sélectionnez Afficher la balise active.Vous définissez à présent le contenu qui sera affiché aux utilisateurs qui se sont déjà connectés.

6. Cliquez sur la zone d'édition du contrôle LoginView pour activer l'édition, puis tapez Vous êtes connecté. Bienvenue,

7. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle LoginName sur le modèle après le texte.

4. Création d'utilisateurs Dans la première partie de la procédure pas à pas, vous avez créé un utilisateur avec l'outil Administration de site Web. Cette stratégie est utile si vous utilisez une petite liste définie d'utilisateurs ; par exemple, si vous créez des utilisateurs pour une petite équipe. Dans de nombreux sites Web, toutefois, les utilisateurs sont autorisés à s'inscrire. ASP.NET inclut le contrôle CreateUserWizard qui exécute la même tâche que vous avez effectuée précédemment à l'aide de l'outil Administration de site Web.Dans cette partie de la procédure pas à pas, vous ajouterez une fonctionnalité qui permet aux utilisateurs de s'inscrire sur votre site Web. Pour commencer, vous créerez une page d'inscription.

j) Pour créer une page d'inscription1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom de votre site Web,

cliquez sur Ajouter un nouvel élément et ajoutez un nouveau formulaire Web nommé Register.aspx.

Remarque :Veillez à créer la page à la racine du site Web et non dans le dossier PagesMembres.

2. Dans la page Register.aspx, basculez en mode Design et tapez le texte statique tel que Inscription dans la page. Dans la barre d'outils Mise en forme, utilisez la liste déroulante Format du bloc pour mettre en forme le texte en Heading 1.

3. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle CreateUserWizard sur la page.

4. Dans la fenêtre Propriétés pour le contrôle CreateUserWizard, affectez ~/Default.aspx à la propriété ContinueDestinationPageUrl.Cela configure le contrôle afin que lorsque les utilisateurs cliquent sur Continuer après avoir créé un utilisateur, le contrôle retourne à la page d'accueil.

5. À partir du groupe Standard de la Boîte à outils, faites glisser un contrôle HyperLink sur la page. Dans la fenêtre Propriétés pour le contrôle HyperLink, affectez Accueil à la propriété Text et ~/Default.aspx à la propriété NavigateUrl.Vous pouvez à présent ajouter un lien vers la page d'accueil qui affiche la page d'inscription. Pour cette procédure pas à pas, supposez que vous souhaitez afficher le lien d'inscription uniquement aux utilisateurs qui ne sont pas connectés.

k) Pour créer un lien d'inscription sur la page d'accueil1. Basculez vers la page Default.aspx ou ouvrez-la. 2. Cliquez avec le bouton droit sur le contrôle LoginView ajouté précédemment, puis

sélectionnez Afficher la balise active. Dans le panneau Tâches LoginView, sélectionnez


AnonymousTemplate dans la zone de liste Affichages pour activer l'édition dans le modèle anonyme.

3. À partir du groupe Standard de la Boîte à outils, faites glisser un contrôle HyperLink sur le modèle anonyme. Dans la fenêtre Propriétés pour le contrôle HyperLink, affectez Inscription à la propriété Text et Register.aspx à la propriété NavigateUrl. Le lien Inscription sera affiché uniquement aux utilisateurs qui ne sont pas connectés.

5. Modification de mots de passe Il arrive que les utilisateurs souhaitent modifier leur mot de passe et il est souvent difficile d'effectuer cette tâche manuellement. Vous pouvez donc utiliser un autre contrôle ASP.NET pour permettre aux utilisateurs de modifier leur mot de passe seuls. Pour modifier un mot de passe, les utilisateurs doivent connaître leur mot de passe. Dans cette procédure pas à pas, vous ajouterez une page dans laquelle les utilisateurs connectés peuvent modifier leur mot de passe.

l) Pour créer une page de modification de mot de passe1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le dossier PagesMembres,

cliquez sur Ajouter un nouvel élément et ajoutez un nouveau formulaire Web nommé ChangePassword.aspx.

Remarque :Veillez à créer la page dans le dossier PagesMembres.

2. Vous mettez la page dans le dossier réservé aux membres parce que seuls les utilisateurs connectés peuvent modifier leur mot de passe.

3. Dans la page ChangePassword.aspx, basculez en mode Design et tapez du texte statique tel que Modifier le mot de passe. Dans la barre d'outils Mise en forme, utilisez la liste déroulante Format du bloc pour mettre en forme le texte en Heading 1.

4. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle ChangePassword sur la page.

5. Dans la fenêtre Propriétés pour le contrôle ChangePassword, affectez ~/Default.aspx à la propriété ContinueDestinationPageUrl.

6. Cela configure le contrôle de sorte que, lorsque les utilisateurs cliquent sur Continuer après avoir modifié un mot de passe, le contrôle retourne à la page d'accueil.Vous pouvez à présent ajouter un lien vers la page d'accueil qui affiche la page de modification de mot de passe. Vous rendrez le lien disponible uniquement aux utilisateurs qui sont connectés.

m) Pour créer un lien de modification de mot de passe sur la page d'accueil1. Basculez vers la page Default.aspx ou ouvrez-la.2. Cliquez avec le bouton droit sur le contrôle LoginView, puis cliquez sur Afficher la balise

active. Dans le menu Tâches LoginView, dans la liste Affichages, cliquez sur LoggedInTemplate.Cela bascule le contrôle LoginView en mode édition pour le contenu qui s'affichera aux utilisateurs qui sont connectés.

3. À partir du groupe Standard de la Boîte à outils, faites glisser un contrôle HyperLink sur la zone d'édition. Dans la fenêtre Propriétés, pour le contrôle HyperLink, affectez Modifier le mot de passe à la propriété Text et ~/PagesMembres/ChangePassword.aspx à la propriété NavigateUrl.


Le lien Modifier le mot de passe sera affiché uniquement aux utilisateurs qui sont connectés, contrairement au lien Inscription que vous avez créé précédemment.

6. Récupération d'un mot de passe Il arrive que les utilisateurs oublient leur mot de passe. Vous pouvez ajouter une page de récupération du mot de passe à votre site Web afin qu'ils puissent de nouveau se connecter à votre site. La récupération de mot de passe peut prendre deux formes :

Vous pouvez envoyer aux utilisateurs le mot de passe qu'ils ont sélectionné (ou que vous avez créé pour eux lorsque vous avez configuré le site). Cette option requiert que le site stocke le mot de passe en utilisant le chiffrement réversible.

Vous pouvez envoyer aux utilisateurs un nouveau mot de passe qu'ils peuvent modifier à l'aide de la page Modifier le mot de passe que vous avez créée précédemment. Cette option est utile si le site Web stocke des mots de passe à l'aide d'une méthode de chiffrement non réversible telle que le hachage.

Remarque :Retourner un mot de passe en texte clair par message électronique n'est pas recommandé pour les sites qui requièrent un niveau élevé de sécurité. Pour les sites au niveau de sécurité élevé, il est recommandé de retourner des mots de passe chiffrés, avec SSL (Secure Sockets Layer) par exemple.Par défaut, le système d'appartenance (membership) d'ASP.NET sécurise des mots de passe par hachage, ce qui signifie que les mots de passe ne peuvent pas être récupérés. Par conséquent, dans cette partie de la procédure pas à pas, votre site Web enverra un nouveau mot de passe aux utilisateurs.

Remarque :La récupération de mot de passe requiert que votre site Web puisse envoyer des messages électroniques. Si vous n'êtes pas en mesure de configurer votre site Web pour envoyer des messages (comme l'explique « Configuration de l'application pour la messagerie électronique » dans cette procédure pas à pas), vous ne serez pas en mesure d'ajouter la récupération de mot de passe à votre site.

n) Pour ajouter la récupération de mot de passe1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom de votre site Web,

cliquez sur Ajouter un nouvel élément et ajoutez un nouveau formulaire Web nommé RecoverPassword.aspx.

Remarque :Veillez à créer la page à la racine du site Web et non dans le dossier PagesMembres.

2. Dans la page RecoverPassword.aspx, basculez en mode Design et tapez du texte statique tel que Redéfinir la valeur de mon mot de passe. Dans la barre d'outils Mise en forme, utilisez la liste déroulante Format du bloc pour mettre en forme le texte en Heading 1.

3. À partir du groupe Connexion de la Boîte à outils, faites glisser un contrôle PasswordRecovery sur la page.

4. À partir du groupe Standard de la Boîte à outils, faites glisser un contrôle HyperLink sur la page. Dans la fenêtre Propriétés pour le contrôle HyperLink, affectez Accueil à la propriété Text et ~/Default.aspx à la propriété NavigateUrl.

5. Basculez vers la page Default.aspx.


6. Cliquez avec le bouton droit sur le contrôle LoginView, puis cliquez sur Afficher la balise active. Dans le menu Tâches LoginView, dans la liste Affichages, cliquez sur AnonymousTemplate.Cela bascule le contrôle LoginView en mode édition pour le contenu qui s'affichera aux utilisateurs qui ne sont pas connectés.

7. À partir du groupe Standard de la Boîte à outils, faites glisser un contrôle HyperLink sur le modèle. Dans la fenêtre Propriétés, pour le contrôle HyperLink, affectez Vous avez oublié votre mot de passe ? à la propriété Text et ~/RecoverPassword.aspx à la propriété NavigateUrl.

IX. Développer un service Web voir le tpX. XML et technologies associés

1. XML a) Généralité

XML (eXtensible Markup Language) est un "langage de balisage extensible", développé par laW3C ( http://w3.org ). "Langage de balisage Extensible" signifie que le XML n'est pas limité (toutcomme le HTML) à un balisage prédéfini extrêmement figé mais au contraire tout un chacunpourra définir ses propres balises.Exemple : <telephone>00.00.00.02.01</telephone>est une ligne comprise par le XML et exploitable, alors qu'elle ne le sera jamais en HTML.

b) Concevoir un document XMLUn document XML doit commencer par une déclaration, qui indique l’utilisation du langage XML, la version et le jeu de caractère.<?xml version="1.0" encoding="utf-8" ?>

La description du contenu se fait grâce à des balises. Une balise est appelé un élément. Les éléments encadrent le contenu de ce que l’on veut dire. Elles s’écrivent de cette manière : <elemenet1>contenu</ elemenet1>

Exemple1 :


Cet exemple contient un seul élément. Il s’agit de l’élément annonce.<?xml version="1.0" encoding="utf-8" ?><annonce>Ceci est un fichier XML.</annonce>

Exemple2 :<?xml version="1.0" encoding="utf-8" ?><musique> <titre>Les marionnettes</titre> <titre>Anges et démons</titre></musique>

Exemple 3 :<?xml version="1.0" encoding="utf-8" ?><notes> <eleve> <nom>ROBIN</nom> <prenom>Marc</prenom> <moyenne>12,5</moyenne> </eleve> <eleve> <nom>GRUNG</nom> <prenom>Stéphanie</prenom> <moyenne>11,3</moyenne> </eleve></notes>Exemple 4 : ce fichier et erroné. Il faut un élément qui contient l’ensemble de tous les éléments.<?xml version="1.0" encoding="utf-8" ?><notes> <eleve> <nom>ROBIN</nom> <prenom>Marc</prenom> <moyenne>12,5</moyenne> </eleve> </notes><musique> <titre>Les marionnettes</titre> <titre>Anges et démons</titre></musique>

2. XML et C#Pour utiliser les classes XML il faut importer l’espace de noms System.Xml.

a) Création d’un XmlDocument Pour pouvoir travailler sur un document XML ou sur une chaine de caractère XML, il faut créer un objet de type XmlDocument. Il existe deux méthodes du XmlDocument qui nous seront utile pour remplir notre objet XmlDocument : Load et LoadXml.Load Permet de charger le contenu d’un document ou d’un objet

contenant du XML dans le XmlDocument.Argument :- Un objet Stream : charge le XmlDocument depuis le flux spécifié- String : URL vers le fichier contenant le XML- TextReader : charge depuis un TextReader- XmlReader : charge depuis un XmlReader

LoadXml Attend en argument une chaine de caractères contenant du


XML.

Voici un exemple d’utilisation de ces deux méthodes :

XmlDocument document = new XmlDocument(); document.Load(@"C:\ Stagiaires.xml");

XmlDocument document = new XmlDocument(); document.LoadXml("<Stagiaire id='1' nom=’Madani'><prenom>Ali</couleur></Stagiaire>");


Rappel : En C# l’arobase (@) devant une chaine de caractère permet d’éviter d’avoir à échapper le caractère d’échappement et donc d’avoir \\.

b) Sauvegarder un XmlDocumentMaintenant que nous avons appris à créer un XmlDocument et à le remplir, nous allons voir comment le sauvegarder. Pour ce faire, on utilise la méthode Save du XmlDocument.

document.Save(@"C:\Stagiaires.xml ");

Pour pouvoir sauvegarder le document, il faut que celui-ci soit valide. En particulier qu’il possède un noeud racine. Nous verrons comment créer un noeud racine plus tard. Pour revenir à la méthode Save, si vous ne mettez en String qu’un nom de fichier (Fruit.xml) par exemple, votre fichier se trouvera dans le document bin\Debug de votre projet (par défaut).

c) Déplacement On entend par déplacement le fait d’accéder à un endroit précis du document XML pour accéder aux données, aux noeuds enfants etc … Pour cela on va donner plusieurs méthodes et propriétés qui permettent ceci et on expliquera un exemple qui les regroupera toutes (comme XmlDocument hérite de XmlNode, on retrouva des méthodes dans les deux).

Toutes les propriétés qui suivent se retrouvent dans XmlDocument et XmlNode sauf une : DocumentElement.

Pour effectuer une modification, un ajout ou tout autre action, il faut se placer dans le document à un endroit où l’on poura effectuer notre action et donc il faut récupérer un objet que l’on appellera noeud courant. Cette méthode et ces propriétés permettent de récupérer l’objet qui vous interessera. Nous verrons des exemples concret dans les parties suivantes.

d) Lecture d’information / affichageIl existe différent moyen de lire les données contenu dans le fichier XML. Nous allons commencer par voir les méthodes qui permettent de lire les informations d’un noeud ou groupe de noeud. Il y aura aussi des méthodes qui permettent de récupérer des informations qu’il suffira ensuite d’afficher.Ceci s’applique sur les XmlNode :


Exemple d’affichage utilisant le document Xml de fruit vu plus haut :

e) TP 1 : Lire un document XMLQuestion 1 : Afficher le document XML « Stagiaires.xml »

static void Main(string[] args) { XmlDocument doc = new XmlDocument(); doc.Load("Stagiaires.xml"); //document.Load(@"C:\Stagiaires.xml"); foreach (XmlNode e in doc.ChildNodes) { Console.WriteLine(e.Name); }

foreach (XmlNode e in doc.DocumentElement.ChildNodes) { Console.WriteLine(" " + e.Name + " id= " + e.Attributes["id"].Value); foreach (XmlNode i in e.ChildNodes) { Console.WriteLine(" " + i.Name + " Valeur : " + i.InnerText); } Console.WriteLine("\n\n"); } Console.Read(); }

Question2 : Affichez le document XML « ecole.xml »


<?xml version = “1.0” encoding = “utf-8”?><ecole> <options> <option nomoption = "Réseau"> <matierespreponderantes> <matiere1> Réseau </matiere1> <matiere2> Système </matiere2> </matierespreponderantes> <profPrincipal > Madame Fatima </profPrincipal > </option> <option nomoption = "Développeur"> <matierespreponderantes> <matiere1> Algorithmique et développement </matiere1> <matiere2> Base de données </matiere2> </matierespreponderantes> <profPrincipal> Monsieur Adil </profPrincipal> </option> </options> <etudiant nom = "Madani" prenom = "Ali" nomoption ="Réseau"/> <etudiant nom = "Madani" prenom = "Moad" nomoption ="Développeur"/></ecole>

3. XmlReader Un autre moyen est d’utiliser un objet de type XmlReader. Il correspond à un lecteur qui fournit un accès en lecture seule, qui n’est pas mis en cache et qui ne peut être lut que dans un seul sens : le sens normal de la lecture (du haut du fichier vers le bas). Exemple

XmlReader reader = XmlReader.Create("Stagiaires.xml"); while (!reader.EOF) { reader.Read(); Console.Write(reader.Value); } reader.Close(); Console.Read();

On créé un objet reader de type XmlReader sur lequel on utilise la méthode Create du Xmlreader qui permet de créer un flux et qui attend, dans notre exemple, l’URL d’un fichier XML. Notre XmlReader instancié et initialisé nous allons maintenant faire la boucle pour lire les données. La propriété EOF


retourne un booléen qui détermine si le reader est à la fin de la lecture ou non. La méthode Read du XmlReader permet de lire le noeud suivant (puisque le reader se déplace de noeud en noeud). Après la boucle on ferme le reader avec la méthode Close. Le Console.Read() n’étant là que pour nous permettre de lire ce qui est affiché dans la console.


Maintenant voici les tableaux qui recensent les méthodes et propriétés utiles du XmlReader :

4. Création / AjoutMéthodes du XmlDocument

Ce qui suit sont les méthodes du XmlNode qui permettent la création où l’ajout de noeud dans le Xml.

XmlDocument document = new XmlDocument(); //On charge le fichier XML : path correspond à l'url du fichier document.Load(@"C:/Stagiaires.xml"); // On récupère dans un XmlNode le noeud racine XmlNode node = document.DocumentElement; //On créer un attribut avec la méthode CreateAttribute du XmlDocument XmlAttribute nodeattr = document.CreateAttribute("test"); //On donne une valeur à l'attribut nodeattr.Value = "Valeur"; // On ajoute l'attribut au noeud node.Attributes.Append(nodeattr);

Pour créer un attribut, on instancie un objet XmlAttribute qui va contenir le résultat de la méthode CreateAttribute (qui prend en argument un string qui correspond au nom de l’attribut) du XmlDocument. La Méthode Value du XmlDocument permet d’obtenir ou de définir la valeur de l’attribut. Ensuite on l’ajoute au noeud (dans l’exemple le noeud est le noeud racine).

5. XmlTextWriter On a vu que XmlReader permet de récupérer un flux en lecture seule. Ici XmlTextWriter va permettre de récupérer un flux dans lequel on peut écrire.Tableau des méthodes du XmlTextWriter :


L’exemple qui va suivre va être la création d’un document Xml en utilisant un objet XmlTextWriter :

f) TP 2 – Ecrire un document XML avec C#Question 1 : Exécuter le code suivant. Ensuite, afficher le document xml « text.xml »

class Program { static void Main(string[] args) { XmlTextWriter rw = new XmlTextWriter(@"C:\test.xml", Encoding.UTF8); rw.WriteStartDocument(); rw.WriteStartElement("Root"); rw.WriteStartElement("Noeud"); rw.WriteAttributeString("id", "value"); rw.WriteString("Sa fonctionne"); rw.WriteComment("Commentaire"); rw.WriteEndElement(); rw.WriteEndElement(); rw.WriteEndDocument(); rw.Close(); } }

Question 2 : Créer un document XML avec C# qui enregistre 3 stagiaires avec leur groupeQuestion 3 : Réaliser les questions en relation avec XML dans le TP15


6. DTDUne DTD (Document Type Definition) est un modèle permettant de décrire la grammaire d’un document XML.La DTD définira aussi des contraintes portant sur la sémantique, la structure et les valeurs applicables pour un élément du document

7. Pourquoi utiliser une DTD ?Dans le cadre de l’utilisation de xml pour échanger de l’information.il est absolument nécessaire de s’assurer de la validité du document avant d’effectuer le traitement.

8. Types de DTDUne DTD peut se présenter sous deux formes : Interne ou Externe

g) DTD interneLa DTD est définie dans le document XMLLes éléments placés entre crochets après la zone de déclaration du DOCTYPE constituent la DTD interneExemple

<!DOCTYPE biblio[ <!ELEMENT biblio (livre)*> <!ELEMENT livre (titre, auteur, nb_pages)> <!ELEMENT titre (#PCDATA)> <!ELEMENT auteur (#PCDATA)> <!ELEMENT nb_pages (#PCDATA)>]>

h) DTD externeLes deux types de DTD externes sont les DTD de type public et les DTD de type system. Le mot-clef SYSTEM indique que le fichier qui suit se trouve sur l'ordinateur local et qu'il est disponible uniquement à titre privé. Par contre, le mot-clé PUBLIC indique une ressource accessible pour tous sur un serveur web distant via un URI Exemple de déclaration de DTD externe de type SYSTEM :

i) Document XML

<?xml version="1.0" encoding="utf-8" ?><!DOCTYPE biblio SYSTEM "bibliographie.dtd">

Le fichier associé est le suivant :

<?xml version="1.0" encoding="utf-8" ?><!ELEMENT biblio (livre)*><!ELEMENT livre (titre, auteur, nb_pages)><!ATTLIST livre type (roman | nouvelles | poemes | théâtre) #IMPLIED lang CDATA "fr"


><!ELEMENT titre (#PCDATA)><!ELEMENT auteur (#PCDATA)><!ELEMENT nb_pages (#PCDATA)>

Exemple de déclaration de DTD externe de type PUBLIC :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

9. Déclarations d’élémentsLa DTD contient la description des éléments et des attributs qui seront acceptés dans le document XMLUne déclaration d’élément prend la forme :

<!ELEMENT [nom de l’élément]([contenu de l’élément ou type])>

Exemple :

<!ELEMENT personne (nom, email)>

<personne><nom> …</nom><email> …</email></personne>

Le « Nom » est le nom de l'élément et type_element est le type auquel il est associé. Un élément peut être de type texte, vide (EMPTY ), séquence ou choix d'élément. Dans ces deux derniers cas, on indique la liste des éléments-enfants.

j) Elément texteCet élément est le plus répandu, puisque c'est celui qui contient... le texte. Il se déclare ainsi : <!ELEMENT elt (#PCDATA)>

k) Elément videUn élément vide est, comme son nom l'indique, un élément qui n'a aucun contenu -que ce soit de type texte, ou bien un autre élément. Le mot-clef utilisé pour la déclaration de ce type d'élément est EMPTY :

<!ELEMENT elt EMPTY>

Exemple d’utilisation:<elt/>Un élément vide peut fort bien posséder un ou plusieurs attributs. Par exemple

<img width="100" height="30" src="paysage.jpg" alt="Paysage de neige"/>


10. Indicateurs d'occurrence

Lors de la déclaration de séquence ou de choix d'éléments, à chaque élément enfant peut être attribuée une indication d'occurence (?, + ou *). Exemples d'indicateur d'occurences :

<!ELEMENT elt0 (elt1, elt2?, elt3+, elt*)>

elt1 ne comprend aucune indication d'occurence. Il doit donc apparaître une seule et unique fois dans l'élément elt0 ; elt2 a pour indication d'occurence ?. Cela signifie que l'élément doit apparaître au maximum une fois (il peut ne pas apparaître du tout) ; elt3 a pour indication d'occurence +. Cela signifie que l'élément doit apparaître au moins une fois ; elt4 a pour indication d'occurence *. Cela signifie que l'élément doit apparaître autant de fois que l'auteur le désire. Séquence d'éléments

<!ELEMENT elt0 (elt1, elt2, elt3)>

Exemple d'utilisation valide :

<elt0> <elt1></elt1> <elt2></elt2> <elt3></elt3></elt0>

Exemples d'utilisations non valides :

<elt0> <elt1></elt1> <elt3></elt3></elt0>

... car l'élément elt2 est manquant.

<elt0> <elt1> </elt1> <elt3> </elt3> <elt2> </elt2></elt0>

... car l'ordre des éléments n'est pas respecté.

l) Choix d'éléments<!ELEMENT elt0 (elt1 | elt2 | elt3)>Exemple d'utilisation valide :


<elt0> <elt2></elt2></elt0>

Exemple d'utilisation non valide :


Choix d'éléments(suite)

<!ELEMENT choix.elt0 (elt1* | elt2* | elt3*)>

Exemple d'utilisation valide :


Exemples d'utilisation non valide :


m) Choix d'éléments(suite)Exemple d'utilisation d'un choix d'éléments avec indicateur d'occurence global :<!ELEMENT elt0 (elt1 | elt2 | elt3)*>Exemple d'utilisation valide :

<elt0> <elt2> </elt2> <elt3> </elt3> <elt1> </elt1></elt0>

Elément quelconqueL'élément quelconque peut contenir tout autre élément défini dans la DTD, aussi bien qu'être vide ou contenir du texte. Les éléments-enfants éventuels peuvent apparaître dans n'importe quel ordre, et en quantité non définie. Il est préférable de ne pas utiliser trop souvent ce type de déclaration, car on perd les avantages qu'offre la rédaction d'une DTD, de fixer des contraintes précises sur la structure du document XML qui lui est lié. Le mot-clef utilisé pour la déclaration de ce type d'élément est ANY.


<!ELEMENT elt ANY>

n) Elément à contenu mixteUn élément à contenu mixte peut contenir aussi bien du texte, que des éléments-enfants. Il se présente comme une liste de choix, avec des indicateurs d'occurence bien choisis. Le texte contenu peut se trouver à n'importe quel endroit dans l'élément.Exemple de déclaration :

<!ELEMENT citation (#PCDATA | auteur+)>

Exemple d'utilisation :

<citation> Etre ou ne pas être <auteur>Shakespeare</auteur></citation>

ExerciceRédiger un document xml valide à cette DTD ex1.dtd

<?xml version="1.0" encoding="ISO-8859-1"?> <!ELEMENT biblio (livre)*> <!ELEMENT livre (titre, auteur, nb_pages)> <!ELEMENT titre (#PCDATA)> <!ELEMENT auteur (#PCDATA)> <!ELEMENT nb_pages (#PCDATA)>

Réponse

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE biblio SYSTEM "ex1.dtd"><biblio> <livre> <titre>langage xml</titre> <auteur>tdiG3</auteur> <nb_pages>40</nb_pages> </livre></biblio>

11. Déclarations d'attributsComme on peut trouver dans un document XML des éléments possédant des attributs, il est normal que la DTD permette de définir des contraintes sur ces derniers.


Les attributs d’un élément sont assemblés sous la forme d'une liste. Chaque attribut défini dans la liste possède un nom et un type. On peut lui donner une valeur par défaut, ou bien le spécifier obligatoire. Le mot-clef de la déclaration de cette liste est ATTLIST. Exemple:

<!ATTLIST elt attr CDATA>

l’élément « elt » possede un attribut de type text, CDATA permet de définir un bloc de caractères ne devant pas être analysés par le processeur XML. Chaque attribut peut être requis, optionnel ou fixe et avoir une valeur par défaut. Les exemples suivants montrent la déclaration d'un attribut appelé « attr » attaché à un élément nommé « elt ». Type chaîne de caractères CDATAIl s’agit là du type d'attribut le plus courant. Une chaîne de caractères peut être composée de caractères ainsi que d'entités analysables. Le mot-clef utilisé pour la déclaration de chaîne de caractère est CDATA. Exemple de déclaration de CDATA :

<!ATTLIST elt attr CDATA>

Exemples d'utilisations :

<elt attr="Chaîne de caractères">

o) Valeurs par défautDéclaration d'un attribut avec une valeur par défaut :

<!ATTLIST elt attr CDATA "valeur">

Un tel attribut n'est pas obligatoire. S'il est omis dans le fichier XML lors de l'utilisation de l'élément elt, il est considéré comme valant valeur. Dans cet exemple, si on écrit <elt>(...)</elt>, cela est équivalent à écrire <elt attr="valeur">(...) < /elt>.

p) Déclaration d'un attribut requisDéclaration d'un attribut requis :

<!ATTLIST elt attr CDATA #REQUIRED>

Un tel attribut est obligatoire. Son absence déclenche une erreur du vérificateur syntaxique.

q) Déclaration d'un attribut optionnel :

<!ATTLIST elt attr CDATA #IMPLIED>

Déclaration d'un attribut avec une valeur fixe :

<!ATTLIST elt attr CDATA #FIXED "valeur">

r) Type ID Ce type sert à indiquer que l'attribut en question peut servir d'identifiant dans le fichier XML. Deux éléments ne pourront pas posséder le même atribut possédant la même valeur. On interdit par exemple...


<elt1 attr="machin"/><elt2 attr="truc"/><elt1 attr="machin"/>

... ainsi que

<elt1 attr="machin"/><elt2 attr="machin"/><elt1 attr="truc"/>

Exemple de déclaration de type ID optionnel :

<!ATTLIST elt attr ID #IMPLIED>

NMTOKEN(S)Un attribut de type CDATA peut contenir n'importe quel caractère, s'il respecte les contraintes de forme. Les attributs de type NMTOKEN ne peuvent contenir que des lettres, des chiffres, un point [ . ] , un tiret [ - ], un trait de soulignement [ _ ] et un deux-points [ : ]. Les attributs de type NMTOKENS peuvent contenir les mêmes caractères que les attributs de type NMTOKEN, plus des espaces blancs. Par espace blanc, on entend un ou plusieurs espaces, retours chariot, sauts de ligne ou tabulations. Type énuméréOn peut parfois désirer limiter la liste de valeurs possibles pour un attribut. On le définit alors comme étant de type énuméré. Donner une autre valeur dans le fichier XML provoque une erreur. Exemple de déclaration d'une liste de choix d'attributs :

<!ATTLIST img format (BMP | GIF | JPEG) "JPEG">

JPEG :c’est la valeur par défaut

s) TP 3 : Exemple Bibliographie DTD Document XML

<?xml version="1.0" encoding="utf-8" ?><!DOCTYPE biblio SYSTEM "bibliographie.dtd">

Le fichier associé est le suivant :

<?xml version="1.0" encoding="utf-8" ?><!ELEMENT biblio (livre)*><!ELEMENT livre (titre, auteur, nb_pages)><!ATTLIST livre type (roman | nouvelles | poemes | théâtre) #IMPLIED lang CDATA "fr" ><!ELEMENT titre (#PCDATA)><!ELEMENT auteur (#PCDATA)><!ELEMENT nb_pages (#PCDATA)>


a) Exercice1 DTD

Rédiger une DTD pour une bibliographie. Cette bibliographie :

contient des livres et des articles ; les informations nécessaires pour un livre sont :

o son titre général ;o les noms des auteurs ;o ses tomes et pour chaque tome, son nombre de pages ;o des informations générales sur son édition comme par exemple le nom de l'éditeur, le lieu

d'édition, le lieu d'impression, son numéro ISBN ; les informations nécessaires pour un article sont :

o son titre ;o les noms des auteurs ;o ses références de publication : nom du journal, numéro des pages, année de publication et

numéro du journal on réservera aussi un champ optionnel pour un avis personnel.

b) Exercice2 DTD (attributs)

Modifier la DTD précédente...

... en ajoutant un attribut optionnel soustitre à l'élément titre ; ... en faisant de l'élément tome un élément vide et en lui ajoutant un attribut requis nb_pages et

un attribut optionnel soustitre ; ... en faisant de l'élément nom_journal un attribut de l'élément journal et en lui donnant

comme valeur par défaut Feuille de Chou ; ... en faisant de l'élément annee un attribut de type énuméré, prenant comme valeurs possibles

2000, 2001, 2002, "avant_2000" et "inconnue" et proposant comme valeur par défaut inconnue.

Utiliser cette DTD pour créer un fichier XML valide.


12. XSD

a) GénéralitéLes documents XML peuvent être normés grâce à un schéma XSD (XML Schema Definition). Cela sert à donner des règles de structure pour un document XML. Lorsqu’un document XML est échangé entre deux partenaires, le fait de joindre un schéma permet à chacun de compléter le document de la même manière et avec la même rigueur. Sans cela l’échange pourrait être compromis ou n’aurait peut-être pas de sens.

Le schéma permet d’indiquer l’arborescence du document. le schéma permet d’indiquer le type des éléments du document.

Il existe de nombreux types décrits sur le site http://www.w3.org/XML/Schema le schéma permet de préciser le nombre d’occurrences (nombre de fois où sont répétés

les éléments).

b) Construction d’un schéma

Un schéma XSD doit commencer par une déclaration, qui indique l’utilisation du langage XML (comme les documents XML eux-mêmes), suivis d’une balise comportant l’indication d’un schéma global :<?xml version="1.0" encoding="utf-8"?><xs:schema id="XMLSchema" xmlns:xs="http://www.w3.org/2001/XMLSchema">

…</xs:schema>

C’est entre les deux balises indiquant l’utilisation d’un schéma que l’on déclare tous les éléments du document XML.Le schéma est composé de balises, qui débutent toutes par <xsd: et se terminent toutes par </xsd:

c) Déclaration d’un élément simple

Voici une liste des types simples:Type Exemplestring Une phrasebyte -1, 126integer -126789, -1, 0, 1, 126789positiveInteger 1, 126789negativeInteger -126789, -1nonNegativeInteger 0, 1, 126789nonPositiveInteger -126789, -1, 0int -1, 126789675unsignedInt 0, 1267896754long -1, 12678967543233


short -1, 12678decimal -1.23, 0, 123.4, 1000.00float -INF, -1E4, -0, 0, 12.78E-2, 12,

INF, NaNdouble -INF, -1E4, -0, 0, 12.78E-2, 12,

INF, NaNboolean true, false 1, 0time 13:20:00.000dateTime 1999-05-31T13:20:00.000-05:00date 1999-05-31

Un élément simple s’écrit comme suit : <xs:element name="MonElement" type="xs:Untype"/>

Exemple 1:<xs:element name="matricule" type="xs:string"/>

name="matricule" correspond à la déclaration d’un élément nommé matricule, et type="xs:string" correspond au type de contenu (string) qui sera saisi entre l’élément.

Document XML validé :< matricule> ceci est du texte < /matricule>

Document XML non validé :

< matricule> < matricule> ceci est du texte < /matricule>

< /matricule>

Exemple 2:

<?xml version="1.0" ?><xs:schema …="">  <xs:element name="remarque" type="xs:string"/> <xs:element name="contacts" type="xs:int" /> </xs:schema>

Ce schéma déclare deux éléments : remarque et contacts.A chaque élément est associé un type via l'attribut type.remarque de type xs:string ,type simple prédéfini de XML Schema.contacts de type xs:int, type simple prédéfini de XML Schema.

Exemple 3:


<?xml version="1.0" encoding="utf-8" ?><courriers> <lettre> <destinataire>Mme CORY</destinataire> <date>13/01/07</date> <contenu>Congé maternité</contenu> </lettre> <lettre> <destinataire>Mme TILLY</destinataire> <date>13/01/07</date> <contenu>Avancement</contenu> </lettre></courriers>

Dans cet exemple, destinataire, date et contenu sont des éléments simples on va les déclarer dans notre fichier XSD comme suit : <xs:element name="destinataire" type="xs:string" /> <xs:element name="date" type="xs:date"/> <xs:element name="contenu" type="xs:string"/>

d) Valeur par défaut et valeur fixée pour un type simpleUn élément simple peut avoir une valeur par défaut ou une valeur fixée. Une valeur par défaut est affectée si aucune autre valeur ne l’est.

<xs:element name="color" type="xs:string" default="red"/>

Une valeur fixée est aussi affectée mais peut être changée.<xs:element name="color" type="xs:string" fixed="red"/>

e) Déclaration d’attributsLes attributs sont déclarés de types simples :<xs:element name="element1" > <xs:complexType > <xs:attribute name="NomAttr" type ="TypeAttr" /> </xs:complexType></xs:element>

Seuls les éléments complexes peuvent avoir des attributsExemple d’élément XML

<lastname lang="EN">Smith</lastname>Voici la définition correspondante de type simple

<xs:attribute name="lang" type="xs:string"/>On peut affecter une valeur par défaut

<xs:attribute name="lang" type="xs:string" default="EN"/>On peut affecter une valeur fixe

<xs:attribute name="lang" type="xs:string" fixed="EN"/>On peut rendre un attribut optionnel

<xs:attribute name="lang" type="xs:string" use="optional" />On peut rendre un attribut obligatoire


<xs:attribute name="lang" type="xs:string" use=" required" />L’atribut lang ne doit pas apparaitre

<xs:attribute name="lang" type="xs:string" use=" prohibited " />

f) Restriction à des valeursCet exemple définit un élément age avec une restriction : la valeur doit être comprise entre 0 et 100 <xs:element name="age" > <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="100"/> </xs:restriction> </xs:simpleType> </xs:element>

g) Restriction à un ensemble de valeursPour limiter l’étendue d'un élément de XML à un ensemble de valeurs acceptables, on a l’habitude d’utiliser l’énumération. Cet exemple montre l’élément "voiture" avec restriction à "Audi","Golf" et "BMW" <xs:element name="voiture"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> </xs:element>

h) Restriction à une série de valeursRestriction de "letter" à des lettres minuscules : <xs:element name="letter"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-z]"/> </xs:restriction> </xs:simpleType> </xs:element>

Restriction de "initials" à trois lettres majuscules : <xs:element name="initials"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[A-Z][A-Z][A-Z]"/> </xs:restriction> </xs:simpleType> </xs:element>Restriction de "choice" à l’une des trois lettres x, y ou z : <xs:element name="choice"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[xyz]"/>


</xs:restriction> </xs:simpleType> </xs:element> On préserve tous les espaces dans la chaîne : <xs:element name="reponse1"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="preserve"/> </xs:restriction> </xs:simpleType> </xs:element>

On remplace toutes les zones d’espaces, de tabulations, de justifications par des espaces <xs:element name="reponse2"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="replace"/> </xs:restriction> </xs:simpleType> </xs:element> On remplace toutes les zones d’espaces dans la chaîne par un espace <xs:element name="reponse3"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="collapse"/> </xs:restriction> </xs:simpleType> </xs:element>


i) Eléments complexes Exemples d’éléments complexes

Élément vide <product pid="1345"/> Élément contenant d’autres éléments

<employee> <firstname >John</firstname> <lastname>Smith</lastname> </employee>

Élément contenant que du texte <food type="dessert">Ice cream</food>

Élément contenant des éléments et du texte <description> It happened on <date lang="norwegian">03.03.99</date> .... </description>

Comment définir un élément complexe ? Observons cet élément complexe qui contient d’autres éléments <employee> <firstname>John</firstname> <lastname>Smith</lastname> </employee> On peut définir l’élément dans un schéma de différentes manières :Première façon : L'élément "employee" peut être déclaré directement en distinguant ses composants, comme ceci: <xs:element name="employee"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> Mais ceci :

ne conduit que "employee" à utiliser l’appellation complexTypeLes enfants "firstname" et "lastname" sont entourés de "sequence" les conduisant à être utilisés dans l’ordre où ils apparaissent.

Deuxième façon : L'élément "employee" peut avoir l’attribut « type » qui se réfère au nom du type complexe à utiliser : <xs:element name="employee" type="personinfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType>

En utilisant cette méthode :plusieurs éléments peuvent ainsi se référer au type complexe "persoinfo", comme ceci (exemple ): <xs:element name="employee" type="personinfo"/> <xs:element name="student" type="personinfo"/> <xs:element name="member" type="personinfo"/> <xs:complexType name="personinfo">


<xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType>On peut également se baser sur un élément d’un type complexe existant et lui ajouter des éléments : <xs:element name="employee" type="fullpersoninfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> <xs:complexType name="fullpersoninfo"> <xs:complexContent>  <xs:extension base="personinfo"> <xs:sequence> <xs:element name="addresse" type="xs:string"/> <xs:element name="ville" type="xs:string"/> <xs:element name="pays" type="xs:string"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType>

"employee" doit contenir, dans l'ordre : "firstname", "lastname", "adresse", "ville" et "pays".

Comment définir un type complexe pour un élément vide ?Exemple : <product prodid="1345" />XSD : <xs:element name="product"> <xs:complexType> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType> </xs:element>Pour que plusieurs éléments puissent se rapporter au même type complexe : <xs:element name="product" type="prodtype"/> <xs:complexType name="prodtype"> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType>

Type complexe à contenu mixte

Il peut contenir des attributs, des éléments et du texteExemple : l’élément "letter "

<letter> Dear Mr.<name>John Smith</name>. Your order <orderid>1032</orderid> will be shipped on <shipdate>2001-07-13</shipdate>. </letter>


Notez que le texte qui paraît entre les éléments "name", "orderid" et " shipdate" sont tous les enfants de "letter".

Le texte suivant déclare l’élément "letter " : <xs:element name="letter"> <xs:complexType mixed="true" > <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType> </xs:element>

Pour permettre à du texte d'apparaître entre les enfants-éléments de "letter", l'attribut mixed doit être à "vrai".L'étiquette <xs:sequence> signifie que les éléments définis (name, orderid et shipdate) doivent apparaître dans cet ordre à l'intérieur d'un élément "letter"

j) Les indicateursLes indicateurs permettent de contrôler l’usage des éléments à l’intérieur du type complexe.Il existe 7 types d’indicateurs :Indicateurs d’ordre : Sont employés pour définir comment les éléments devraient se produire

All Choice Sequence

Indicateurs d’occurrence : maxOccurs minOccurs

Indicateurs de groupes : Group name attributeGroup name

Allindique que les éléments enfant peuvent apparaître dans n'importe quel ordre et que chaque élément doit se produire une et une seule fois : <xs:element name="person"> <xs:complexType> <xs:all> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:all> </xs:complexType> </xs:element>

L’indicateur choiceindique qu'un seul parmi les éléments enfants peut se produire: <xs:element name="person"> <xs:complexType>


<xs:choice> <xs:element name="employee" type="employee"/> <xs:element name="member" type="member"/> </xs:choice> </xs:complexType> </xs:element>

L’indicateur sequenceSpécifie que les éléments enfants doivent apparaître dans un certain ordre : <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element>

Indicateurs d’occurrencespécifie comment un élément peut se produire .L’indicateur maxOccurs : indique le nombre maximum de fois qu’un élément peut se produire <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="nom" type="xs:string"/> <xs:element name="nom_fils" type="xs:string" maxOccurs="10"/> </xs:sequence> </xs:complexType> </xs:element>

L’indicateur minOccurs : indique le nombre minimum de fois qu’un élément peut se produire. <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="nom" type="xs:string"/> <xs:element name="nom_fils" type="xs:string" maxOccurs="10" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:element>Pour permettre à un élément d’apparaître un nombre illimité de fois, utiliser un maxOccurs="unbounded"

L’élément <any>permet d’étendre le document de XML avec des éléments non indiqués par le schéma.L'exemple suivant est un fragment du schéma "family.xsd". Il montre une déclaration de l'élément "person". En employant <any> on peut prolonger (après <lastname>) "person" avec n'importe quel élément : <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/>


<xs:element name="lastname" type="xs:string"/> <xs:any minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:element>


13. XSLT

a) Introduction

XSL signifie eXtensive Stylesheet Langage, ou langage extensible de feuille de style. XSLT signifie eXtensible Stylesheet Langage Transformation. XSLT: partie de XSL, ensemble de règles de transformation d'un document XML vers un autre document.

Comme son nom l'indique, le XSL ne sert pas uniquement de langage de feuille de style. Il est aussi un très puissant manipulateur d'éléments. Il permet de transformer un document XML source en un autre, permettant ainsi, à l'extrême, d'en bouleverser la structure. Le fonctionnement du XSL est fondé sur les manipulations de modèles (templates). Les éléments du document XML d'origine sont remplacés (ou légèrement modifiés) par ces modèles. Un modèle contient ainsi le texte (éléments, attributs, texte...) de remplacement d'un élément donné. Tout élément pouvant être remplacé dans le fichier de sortie par tout type de contenu texte, XSL est un outil privilégié de production de fichiers HTML à partir de sources XML. PHP fait ainsi appel à des bibliothèques de procédures de type XSL quand il doit gérer l'interfaçage avec des bases de données XML. Un fichier XSL étant un fichier XML, il doit respecter les normes de syntaxe de ce format. Structure d'un document XSL

b) CaractéristiquesUn langage de manipulation d'arbres Change un dialecte XML en un autre Langage déclaratif basé sur la recherche de motifs dans un arbre Transformation dirigée par le document Pas vraiment un langage de formatage

Un langage de réécriture pour XML subdivisé en:


XSLT (Transformation) : est un langage permettant de produire un document XML ou texte à partir d'un autre document par application de règles de transformation

XSL-FO (Formatting Object): est une DTD XML qui définie la présentation d'un texte sur un document papier (PS, GV, PDF,DPS).

Utilise XPath pour la localisation des noeuds

c) Structure d’un fichier XSLProgramme XSLT est un document XML.Les éléments XSLT sont préfixés par xsl: (XSL utilise les domaines de noms) :<?xml version="1.0" encoding="utf-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> ..... ..... </xsl:stylesheet>

L'élément <xsl:stylesheet> est l'élément racine du document XSL. C'est lui qui contient tous les modèles, y compris celui qui est associé à la racine du document XML, modèle que l'on note <xsl:template match="/">. L'attribut match="/" indique que ce modèle s'applique à la racine du document XML.

d) format de sortie : <xsl:output>

Cet élément se placer comme premier enfant de <xsl:stylesheet>, permet de spécifier des options concernant l'arbre de sortie. L'utilisation de cet élément est de la forme : <xsl:output method="xml | html | text" version="nmtoken" encoding="chaine" omit-xml-declaration="yes | no" standalone="yes | no" doctype-public="chaine" doctype-system="chaine" cdata-section-elements="elt" indent="yes | no" media-type="chaine" />

method identifie la méthode de transformation. Dans le cas où elle est égale à text, aucune mise

en forme n'est effectuée. version identifie la version de la méthode de sortie (xml 1.0, html 4.01...). encoding indique la version du jeu de caractères à utiliser pour la sortie. omit-xml-declaration indique au processeur XSLT s'il doit ajouter ou non une déclaration XML. standalone indique au processeur XSLT s'il doit créer un arbre de sortie avec ou sans déclaration

de type de document. doctype-public indique l'identifiant public utilisé par la DTD associée à la transformation. doctype-system indique l'identifiant system utilisé par la DTD associée à la transformation. cdata-section-elements indique les éléments dont le contenu doit être traité lors de la

transformation via une section CDATA. indent présente la transformation sous forme d'arbre dans le cas où la valeur de cet attribut est

égale à yes. media-type indique le type MIME des données résultantes de la transformation.

Exemple : <xsl:output method="html" version="html4.01" encoding="ISO-8859-1" doctype-public="-//W3C//DTD HTML 4.01//EN" doctype-system="http://www.w3.org/TR/html4/strict.dtd" />


permet d'indiquer que le fichier de sortie sera au format HTML 4.01, conforme à la DTD publique de l'HTML du W3C, et que le jeu de caractères utilisé est l'ISO-8859-1. Le résultat en sortie est un fichier HTML commençant par

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">

... et possédant dans son <head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />

L'utilisation d'un tel élément permet donc de se dispenser de la spécification explicite du codage de caractères via un élément <meta> lors de l'écriture de la feuille de style XSL.

e) Règle de transformation : <xsl:template>Le corps d’une feuille de style (stylesheet) est une succession de règles de réécriture: les <xsl:template>.Une règle "template" permet de sélectionner un nœud de l'arbre XML pour un traitement (transformation).< xsl:template > est nécessairement enfant de l'élément racine <xsl:stylesheet>.syntaxte :<xsl:template name="nommodele" match=" "pattern_XPATH" mode="modemodele"> actions...</xsl:template>

match: identifie les nœuds du document sur laquelle va s'appliquer la règle.pattern_XPATH : est une ou plusieurs expressions XPATH connectées par un ou « | »actions : description d'une action qui définit la transformation à appliquer sur un nœudname: correspond au nom associé au modèle. mode: permet à un élément d'avoir plusieurs modèles, chacun générant une sortie différente.

Exemple :Règle s’appliquant à la racine du document XML : <xsl:template match="/"> [action] </xsl:template>

Règle s’appliquant au nœud (l’élément) livre du document XML :

<xsl:template match="livre"> [action] </xsl:template>

Règle s’appliquant au nœud livre fils du nœud bibliotheque: <xsl:template match="bibliotheque/livre"> [action] </xsl:template>

Règle s’appliquant au nœud livre et au nœud article <xsl:template match="article|livre"> [action] </xsl:template>

f) <xsl:value-of>

Cet élément permet d'insérer la valeur d'un nœud dans la transformation. Ce nœud est évalué en fonction d'une expression. Cette expression peut correspondre à un élément, à un attribut ou à tout autre nœud contenant une valeur. L'utilisation de cet élément est de la forme :


<xsl:value-of select="expression" disable-output-escaping="yes | no" />

La valeur de select est évaluée et c'est cette évaluation qui sera insérée dans la transformation. disable-output-escaping agit sur la transformation des caractères. Dans le cas où sa valeur est

yes, la chaîne < est insérée dans la transformation en tant que signe <, ce qui peut entraîner des erreurs. Dans le cas contraire, la chaîne < est insérée telle quelle dans la transformation.

Exemple :Le document xml :<?xml version="1.0" encoding="utf-8" ?><?xml-stylesheet type="text/xsl" href="cc.xslt"?><bibliotheque> <nom>bibliotheque amal</nom> <article>Les big data</article> <livre> <auteur>asma</auteur> <titre>transformation cristaline</titre> </livre> <livre> <auteur>ahmed</auteur> <titre>Economie 1</titre> </livre> <livre> <titre>Infographie 2</titre> <auteur>safa</auteur> </livre></bibliotheque>

Le document XSL cc.xslt:<?xml version="1.0" encoding="utf-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"> <xsl:template match="/"> <html > <head> <title>bibliotheque</title> </head> <body> <h1> <xsl:value-of select="bibliotheque/nom"/> </h1>

<h2> <xsl:value-of select="bibliotheque/livre/auteur"/> </h2>

</body> </html> </xsl:template></xsl:stylesheet>

g) Le déclenchement d’une règle de transformation Le déclenchement d’une règle de transformation définie avec <xsl:template> est fait soit par <xsl:apply-templates> soit par <xsl:call-template>Exemple 1 :

Le document xsl :<?xml version="1.0" encoding="utf-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"> <xsl:template match="/"> <html > <head> <title>bibliotheque</title>


</head> <body> <xsl:apply-templates select="bibliotheque/nom"/> </body> </html> </xsl:template> <xsl:template match="/bibliotheque/nom"> <h1> <xsl:value-of select="text()" /> </h1> </xsl:template> </xsl:stylesheet>

Exemple 2 (on travaille avec le même document XML): <xsl:template match="/"> <html > <head> <title>bibliotheque</title> </head> <body> <xsl:for-each select="bibliotheque/livre/auteur"> <xsl:call-template name="tata" /> </xsl:for-each> </body> </html> </xsl:template> <xsl:template name="tata"> <h1> <xsl:value-of select="text()" /> </h1> </xsl:template>

Exemple 3 :

<xsl:template match="/"> <html > <head> <title>bibliotheque</title> </head> <body> <xsl:apply-templates select="bibliotheque/nom"/> <h2> <xsl:apply-templates select="bibliotheque/livre"/> </h2> </body> </html> </xsl:template> <xsl:template match="/bibliotheque/nom"> <h1> <xsl:value-of select="text()" /> </h1> </xsl:template> <xsl:template match="/bibliotheque/livre"> <xsl:value-of select="titre"/>: <xsl:value-of select="auteur" /><br/> </xsl:template>

h) Exemples de mises en forme

Exemple 1Exemple d'un document XML:


<?xml version="1.0" encoding="utf-8" ?><?xml-stylesheet type="text/xsl" href="c.xslt"?><bouteille> <marque>Cristaline</marque> <composition>calcium 71mg/l, magnésium 5,5mg/l, chlorure 20mg/l traces de fer.</composition> <source> <ville>St-Cyr la Source</ville> <departement>Loiret</departement> </source> <code_barre>3274080005003</code_barre> <contenance>150cl</contenance> <ph>7,45</ph></bouteille>

Et voici la feuille de style XSL associée : <?xml version="1.0" encoding="utf-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl">

<xsl:template match="/"> <html> <head> <title>Exemple de sortie HTML</title> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" /> </head> <body>

<h1> Bouteille de marque <xsl:value-of select="bouteille/marque" /> </h1> <h2>Composition:</h2> <p> <xsl:value-of select="bouteille/composition" /> </p> <h2>Lieu d'origine:</h2> <p> Ville de <b> <xsl:value-of select="bouteille/source/ville" /> </b>, dans le département <b> <xsl:value-of select="bouteille/source/departement" /> </b> </p> <h2>Autres informations</h2> <ul> <li> Contenance: <xsl:value-of select="bouteille/contenance" /> </li> <li> pH: <xsl:value-of select="bouteille/ph" /> </li> </ul> </body> </html> </xsl:template></xsl:stylesheet>

Ouvrir le document XML dans un navigateur. Visualiser le résultat.

Exemple 2 Le fichier XML : l’élément composition contient un nombre indéterminé de <ion_positif><?xml version="1.0" encoding="utf-8" ?><?xml-stylesheet type="text/xsl" href="XSLTFile.xslt"?>


<bouteille> <marque>Cristaline</marque> <composition> <ion_positif>calcium 71mg/l</ion_positif> <ion_negatif>nitrate 1mg/l</ion_negatif> <ion_positif>magnésium 5,5mg/l</ion_positif> <ion_negatif>chlorure 20mg/l</ion_negatif> <autres_materiaux>fer</autres_materiaux> </composition> <source> <ville>St-Cyr la Source</ville> <departement>Loiret</departement> </source> <code_barre>3274080005003</code_barre> <contenance>150cl</contenance> <ph>7,45</ph></bouteille>

Remarquer l’utilisation de de <xsl:for-each select="ce_qu_on_cherche_a_afficher"/>, qui permet de faire une boucle sur l'élément cherché : <?xml version="1.0" encoding="utf-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:template match="/"> <html> <head> <title>Exemple de sortie HTML</title> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" /> </head> <body> <h1> Bouteille de marque <xsl:value-of select="bouteille/marque" /> </h1> <h2>Composition:</h2> <h3>Ions positifs</h3> <ul> <xsl:for-each select="bouteille/composition/ion_positif"> <li> <xsl:value-of select="." /> </li> </xsl:for-each> </ul> <h3>Ions négatifs</h3> <ul> <xsl:for-each select="bouteille/composition/ion_negatif"> <li> <xsl:value-of select="." /> </li> </xsl:for-each> </ul> <h3>Autres matériaux</h3> <ul>  <xsl:for-each select="bouteille/composition/autres_materiaux"> <li> <xsl:value-of select="." /> </li> </xsl:for-each> </ul> <h2>Lieu d'origine</h2> <p> Ville de <b> <xsl:value-of select="bouteille/source/ville" /> </b>, dans le département <b>


<xsl:value-of select="bouteille/source/departement" /> </b> </p> <h2>Autres informations</h2> <ul> <li> Contenance: <xsl:value-of select="bouteille/contenance" /> </li> <li> pH: <xsl:value-of select="bouteille/ph" /> </li> </ul> </body> </html> </xsl:template></xsl:stylesheet>

i) <xsl:element>non traité

Cet élément insère un nouvel élément dans la transformation. Le nom de l'élément est donné par l'attribut name. L'utilisation de cet élément est de la forme :

<xsl:element name="nomelement" use-attribute-sets="jeuattr"> </xsl:element>

name correspond au nom de l'élément à créer. use-attribute-sets correspond au jeu d'attributs à associer à l'élément créé. Par exemple :

<xsl:element name="p"><xsl:value-of select="texte" /></xsl:element>

... permet de créer dans le fichier HTML un élément de paragraphe renfermant le contenu de l'élément texte du document XML.

j) <xsl:attribute>

Cet élément définit un attribut et l'ajoute à l'élément résultat de la transformation. L'utilisation de cet élément est de la forme :

<xsl:attribute name="nom">valeur</xsl:attribute>

name correspond au nom de l'attribut à ajouter dans le contexte courant. valeur correspond à la valeur à lui donner. Par exemple :

<image><xsl:attribute name="src">test.gif</xsl:attribute></image>

... permet d'ajouter à l'élément image l'attribut src et de lui affecter la valeur test.gif, ce qui a pour effet de produire en sortie l'élément suivant :

<image src="test.gif"></image>

On aurait pu, de manière tout à fait équivalente, écrire

<xsl:element name="image"><xsl:attribute name="src">test.gif</xsl:attribute>

</xsl:element>


... ce qui a pour effet de produire en sortie

<image src="test.gif"></image>

k) Syntaxe courte

Il est possible de créer des éléments de manière plus compacte, à l'aide d'une syntaxe particulière. Supposons par exemple que nous ayons dans un fichier XML l'élément : <image source="test.gif" texte_alternatif="Image de test"/> et que nous souhaitions obtenir dans le fichier de sortie l'élément <img src="test.gif" alt="Image de test"/>. Il existe deux manières : La syntaxe longue, avec... <xsl:element name="img"> <xsl:attribute name="src"> <xsl:value-of select="@source" /> </xsl:attribute> <xsl:attribute name="alt"> <xsl:value-of select="@texte_alternatif" /> </xsl:attribute> </xsl:element>La syntaxe courte, utilisant des accolades...

<img src="{@source}" alt="{@texte_alternatif}" />

La seconde syntaxe est plus compacte ; mais elle présente deux inconvénients :Dès lors que des expressions XPath sont un peu longues, cette syntaxe complique la relecture de la feuille de style ;

Une feuille XSL est avant tout un fichier XML. En tant que tel, on peut souhaiter sa transformation ou son traitement automatisé. La syntaxe longue s'y prête plus facilement. ccc

a) <xsl:param>Déclare un paramètre nommé:

<xsl:param name = "QName" select = "Expression"/>

Select : la valeur de la variable.L'élément <xsl:param> doit être déclaré comme un enfant immédiat d'un élément <xsl:template>Exemple : <xsl:param name="x"/> <xsl:param name="y" select="''"/>

<xsl:param name="n" select="2"/>

Exemple complet : <xsl:template match="/bibliotheque"> <html > <head> <title>bibliotheque</title> </head> <body> <xsl:apply-templates select="nom"/> <xsl:call-template name="NbreLivre" /> </body> </html> </xsl:template>


<xsl:template name="NbreLivre"> <xsl:param name="nbre" select="count(//livre)"/> <strong> le nombre de livre est: <xsl:value-of select="$nbre"/> </strong> </xsl:template>

a) <xsl:for-each>

Cet élément de bouclage, que l'on a déjà rencontré, crée une boucle dans laquelle sont appliquées des transformations. Son utilisation est de la forme : <xsl:for-each select="noeuds"></xsl:for-each>

select correspond au jeu de nœuds devant être parcouru par la boucle. Exemple: comme nous avons plusieurs livres, il faut une boucle pour afficher les noms des auteurs.

<xsl:template match="/"> <html > <head> <title>bibliotheque</title> </head> <body> <h1> <xsl:value-of select="bibliotheque/nom"/></h1> <xsl:for-each select="bibliotheque/livre"> <h2> <xsl:value-of select="auteur"/> </h2> </xsl:for-each> </body> </html> </xsl:template></xsl:stylesheet>

Ou bien : <xsl:template match="/"> <html > <head> <title>bibliotheque</title> </head> <body> <h1> <xsl:value-of select="bibliotheque/nom"/> </h1> <xsl:for-each select="bibliotheque/livre/auteur"> <h2> <xsl:value-of select="text()"/> </h2> </xsl:for-each> </body> </html> </xsl:template>

a) <xsl:if>

Cet élément permet la fragmentation du modèle dans certaines conditions. Il est possible de tester la présence d'un attribut, d'un élément, de savoir si un élément est bien le fils d'un autre, de tester les valeurs des éléments et attributs. L'utilisation de cet élément est de la forme :

<xsl:if test="condition">action</xsl:if>


test prend la valeur 1 ou 0 suivant le résultat de la condition (vrai ou faux). action correspond à l'action devant être effectuée (texte à afficher, second test, gestion de chaîne...). Exemple d'utilisation:

<ul> <xsl:for-each select="livre"> <li> <b><xsl:value-of select="auteur" /><br /></b> <xsl:value-of select="titre" />.

<xsl:if test="@langue='français'">Ce livre est en français.</xsl:if> </li> </xsl:for-each></ul>

Dans le code précédent, si l'attribut langue de l'élément livre vaut francais, le processeur ajoutera au fichier de sortie la phrase "Ce livre est en français". Il ne se passe rien si ce n'est pas le cas.

b) <xsl:choose>

Cet élément permet de définir une liste de choix et d'affecter à chaque choix une transformation différente. Chaque choix est défini par un élément <xsl:when> et un traitement par défaut peut être spécifié grâce à l'élément <xsl:otherwise>. Exemple d'utilisation :

<ul> <xsl:for-each select="livre"> <li> <b><xsl:value-of select="auteur" /><br /></b> <xsl:value-of select="titre" /> <xsl:choose> <xsl:when test="@langue='francais'">Ce livre est en français.</xsl:when> <xsl:when test="@langue='anglais'">Ce livre est en anglais.</xsl:when> <xsl:otherwise>Ce livre est dans une langue non répertoriée.</xsl:otherwise> </xsl:choose> </li> </xsl:for-each></ul>

c) <xsl:number>

Cet élément permet d"insérer un nombre formaté pouvant servir de compteur. L'utilisation de cet élément est de la forme :

<xsl:number level="single | multiple | any" count="noeud" from="noeud" value="expression" format="chaine" lang="nmtoken" grouping-separator="car" grouping-size="nombre" />

level indique quels niveaux doivent être sélectionnés pour le comptage. count indique quels nœuds doivent être comptés dans les niveaux sélectionnés ; dans le cas où cet attribut n'est pas défini, les nœuds comptés sont ceux ayant le même type que celui du nœud courant. from identifie le nœud à partir duquel le comptage commence.


value indique l'expression correspondant à la valeur du compteur ; si cet attribut n'est pas défini, le nombre inséré correspond à la position du nœud (position()). format spécifie le format de l'affichage du nombre ; cela peut être un chiffre, un caractère (a-z, A-Z) et comprendre un caractère de séparation tel que le point (.), le trait d'union (-) ou autre. Les formats possibles sont "1", "01", "a", "A", "i", "I". lang spécifie le jeu de caractères à utiliser ; par défaut, il est déterminé en fonction des paramètres du système. grouping-separator identifie le caractère permettant de définir la séparation entre les centaines et les milliers. grouping-size spécifie le nombre de caractères formant un groupe de chiffres dans un nombre long ; le plus souvent la valeur de cet attribut est 3. Ce dernier attribut fonctionne avec... ...grouping-separator ; si l'un des deux manque, ils sont ignorés.

Exemple d'utilisation :

<ul><xsl:for-each select="livre"> <xsl:sort select="auteur" /> <xsl:number level="any" from="/" format="1." /> <li><b><xsl:value-of select="auteur" /></b><br /><xsl:value-of select="titre" /></li></xsl:for-each></ul>

d) <xsl:sort>

Cet élément permet d'effectuer un tri sur un jeu de nœuds. Il doit être placé soit dans un élément <xsl:for-each> soit dans un élément <xsl:apply-templates>. C'est un élément vide qui peut être appelé plusieurs fois pour effectuer un tri multicritères. Chaque appel à cet élément provoque un tri sur un champ spécifique, dans un ordre prédéfini. L'utilisation de cet élément est de la forme :

<xsl:sort select="noeud" data-type="text | number | elt" order="ascending | descending" lang="nmtoken" case-order="upper-first | lower-first" />

select permet de spécifier un nœud comme clé de tri. data-type correspond au type des données à trier. Dans le cas où le type est number, les données

sont converties puis triés. order correspond à l'ordre de tri. Cet attribut vaut ascending ou descending. lang spécifie quel jeu de caractères utiliser pour le tri ; par défaut, il est déterminé en fonction

des paramètres système. case-order indique si le tri a lieu sur les majuscules ou minuscules en premier.

Par exemple :

<ul> <xsl:for-each select="livre"> <xsl:sort select="auteur" order="descending" /> <li><b><xsl:value-of select="auteur" /></b><br /><xsl:value-of select="titre" /></li>


</xsl:for-each></ul>

Dans cet exemple, la liste des livres est classée dans l'ordre alphabétique décroissant des noms d'auteur.

14. XPath

a) Introduction

XPath, ou les expressions de sélection, sont des chaînes de caractères qui permettent de sélectionner des nœuds dans un document source.

L’expression Xpath peut être utilisée dans- attribut match du template- attribut select de value-of , for-each- attribute test de if

Une expression XPath :

s’évalue en fonction d’un noeud contexte désigne un ou plusieurs chemins dans l’arbre à partir du noeud contexte a pour résultat :

un ensemble de noeuds ou une valeur, numérique, booléenne ou alphanumérique

Remarque : On ne peut pas mettre n’importe quelle expression XPath dans l’attribut match. L’expression doit toujours désigner unensemble de nœuds.Pas bon : <xsl:template match="1">

a) Sélection d'élément, syntaxe de base<xsl:value-of select="nom_element" />Exemples:

<xsl:value-of select="bouteille " /><xsl:value-of select="bouteille/source/ville" />Sélectionner tous les fils de l’élément bouteille :<xsl:value-of select="bouteille/*" /><xsl:value-of select="*/paragraphe" />

L'utilisation de // permet d'appliquer la recherche aux descendants et non pas seulement aux fils directs : <xsl:value-of select="section//paragraphe" />

Le caractère . sélectionne le nœud courant .on sélectionne tous les éléments paragraphe descendant de l’élément courant :<xsl:value-of select=".//paragraphe" />

La chaîne .. sélectionne le père du noeud courant. Par exemple, ../paragraphe sélectionne tous les noeuds paragraphe frères du noeud courant :<xsl:value-of select="../paragraphe" />


b) Chemin de localisation Un chemin de localisation peut être de type absolu ou relatif.Dans le cas où il est de type absolu, il commence toujours par le signe / indiquant la racine du document XML ; Dans le cas où il est de type relatif, le nœud de départ est le nœud contextuel courant.

La syntaxe de composition d'un chemin de localisation peut être de type abrégé ou non abrégé. Toute syntaxe non abrégée ne trouve pas forcément d'équivalence en syntaxe abrégée. Un chemin de localisation est composé de trois parties :

un axe, qui spécifie le type de relation arborescente) entre le noeud contextuel et les noeuds à localiser.

un nœud spécifiant le type de nœud à localiser; 0 ou n prédicats, qui sont des expressions arbitraires pour raffiner l'ensemble des noeuds obtenus

par l'étape de localisation.La syntaxe d'une étape de localisation est le nom de l'axe et le noeud de test séparés d'un point-virgule (;), suivi de 0 ou n expresions repérées par des crochets. Par exemple, dans child::para[position()=1] , child est le nom de l'axe, para le noeud de test et[position()=1] est un prédicat.

c) Exemple de chemins de localisation

Ci-après sont présentés quelques exemples de chemins de localisation utilisant une syntaxe non-abrégée :

child::livre sélectionne l'élément livre enfant du noeud contextuel

child::* sélectionne tous les éléments enfant du noeud contextuel

child::text() sélectionne tous les noeuds textuels du noeud contextuel

child::node() sélectionne tous les enfants du noeud contextuel, quelque soit leur type

attribute::prix sélectionne l'attribut prix du noeud contextuel

attribute::* sélectionne tous les attributs du noeud contextuel

descendant::livre sélectionne tous les descendants livre du noeud contextuel

ancestor::livre sélectionne tous les ancêtres livre du noeud contextuel

ancestor-or-self::livre sélectionne tous les ancêtres livre du noeud contextuel et le noeud contextuel lui-même si c'est un div

descendant-or-self::livre sélectionne tous les descendants livre du noeud contextuel et le noeud contextuel lui-même si c'est un para

self::livre sélectionne le noeud contextuel si c'est un élément livre, et rien dans le cas contraire

child::livre/descendant::chapitre sélectionne les descendants chapitre de l'element livre enfant du noeud contextuel

child::*/child::livre sélectionne tous les petits enfants livre du noeud contextuel

/ sélectionne la racine du document


/descendant::livre sélectionne tous les éléments livre descendants du document contenant le noeud contextuel

/descendant::chapitre/child::paragraphe sélectionne tous les éléments paragraphe qui ont un parent chapitre et qui sont dans le même document que le noeud contextuel

child::para[position()=1] sélectionne le premier enfant para du noeud contextuel

child::para[position()=last()] sélectionne le dernier enfant para du noeud contextuel

child::para[position()=last()-1] sélectionne l'avant dernier para enfant du noeud contextuel

child::para[position()>1] sélectionne tous les enfants para du noeud contextuel autres que le premier

following-sibling::chapitre[position()=1] sélectionne le prochain chapitre frère du noeud contextuel

preceding-sibling::chapitre[position()=1] sélectionne le précédent chapitre frère du noeud contextuel

/descendant::figure[position()=42] sélectionne le 42ième élément figure du document

/child::doc/child::chapitre[position()=5]/child::section[position()=2] sélectionne la 2ième section du 5ième élément chapitre de l'élément doc du document

child::para[attribute::type="warning"] sélectionne tous les enfants para du noeud contextuel qui ont un attribut type dont la valeur est warning

child::para[attribute::type='warning'][position()=5] sélectionne le 5ième enfant para du noeud contextuel qui a un attribut type dont la valeur est warning

child::para[position()=5][attribute::type="warning"] sélectionne le 5ième enfant para du noeud contextuel si celui-là a un attribut type de valeur warning

child::chapter[child::title='Introduction'] sélectionne l'enfant chapter du noeud contextuel qui a un ou plus enfant title avec un contenu textuel égal à 'Introduction'

child::chapter[child::title] sélectionne l'enfant chapter du noeud contextuel qui a un ou plus enfant title

child::*[self::chapter or self::appendix] sélectionne tous les enfants chapter et appendix du noeud contextuel

child::*[self::chapter or self::appendix][position()=last()] sélectionne le dernier enfant chapter ou appendixdu noeud contextuel

d) Axeschild : contient les enfants directs du nœud contextuel. descendant : contient les descendants du nœud contextuel. Un descendant peut être un enfant, un petit-enfant... parent : contient le parent du nœud contextuel, s'il y en a un. ancestor : contient les ancêtres du nœud contextuel. Cela comprend son père, le père de son père... Cet axe contient toujours le nœud racine, excepté dans le cas où le nœud contextuel serait lui-même le nœud racine.


following-sibling : contient tous les nœuds cibles du nœud contextuel. Dans le cas où ce nœud est un attribut ou un espace de noms, la cible suivante est vide. preceding-sibling : contient tous les prédécesseurs du nœud contextuel ; si le nœud contextuel est un attribut ou un espace de noms, la cible précédente est vide. following : contient tous les nœuds du même nom que le nœud contextuel situés après le nœud contextuel dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms. preceding : contient tous les nœuds du même nom que le nœud contextuel situés avant lui dans l'ordre du document, à l'exclusion de tout descendant, des attributs et des espaces de noms. attribute : contient les attributs du nœud contextuel .namespace : contient tous les nœuds des espaces de noms du nœud contextuel .self : contient seulement le nœud contextuel. descendant-or-self : contient le nœud contextuel et ses descendants. ancestor-or-self : contient le nœud contextuel et ses ancêtres. Cet axe contiendra toujours le nœud racine.

a) Sélection d'attributs section[@titre] sélectionne les éléments section qui ont un attribut titre. section[@titre="Introduction"] sélectionne les éléments section dont l'attribut titre a pour valeur Introduction. afficher le contenu de l'attribut :<xsl:value-of select=paragraphe/@titre >permet l'affichage du titre de l'élément paragraphe fils de l'élément courant (si rien n'est précisé, par défaut il s'agit du premier élément paragraphe fils).

b) appel de fonctions

comment() sélectionne tous les nœuds commentaires fils du noeud courant. text() sélectionne tous les nœuds fils du nœud courant, ne contenant que du

texte. node() sélectionne tous les nœuds fils du noeud courant. id("32") sélectionne l'élément, normalement unique, qui a un attribut de type ID

(cf. le paragraphe "Déclaration d'attribut de type ID") valant "32".last() : retourne un nombre égal à l'index du dernier nœud dans le contexte courant. position() : retourne un nombre égal à la position du nœud dans le contexte courant. D’autres fonctions sont disponibles :

Manipulation de chaînes de caractèresBeaucoup de fonctions existent. Citons pour mémoire notamment : string(noeud?) : cette fonction convertit un objet en chaîne de caractères selon les règles suivantes : un ensemble de nœuds est converti en chaîne de caractères en retournant la valeur textuelle du premier nœud de l'ensemble dans l'ordre du document. Si l'ensemble des nœuds est vide, une chaîne vide est retournée. un nombre est converti en chaîne suivant des règles dépendant de sa nature (NaN, nombre entier, non-entier, zéro...).


la valeur booléenne false est convertie en chaîne de caractères "false", de même pour la valeur booléenne true. Cette fonction n'a pas pour objet de convertir des nombres en chaînes de caractères pour les présenter aux utilisateurs ; il existe des fonctions de transformations XSLT pour ce faire (format-number et xsl:number) concat(chaine1, chaine2, chaine*) : retourne une chaîne résultant de la compilation des arguments string-length(chaine?) : cette fonction retourne le nombre de caractères de la chaîne. Dans le cas où l'argument est omis, la valeur retournée est égale à la longueur de la valeur textuelle du nœud courant

Manipulation de booléensOutre la fonction logique not(), ainsi que les fonctions true() et false(), une fonction utile est lang(chaine). Elle teste l'argument chaine par rapport à l'attribut xml:lang du nœud contextuel ou de son plus proche ancêtre dans le cas où le nœud contextuel ne contient pas d'attribut de ce type. La fonction retourne true si l'argument est bien la langue utilisée ou si la langue utilisée est un sous-langage de l'argument (par exemple, en//us). Sinon elle retourne false.

Manipulation de nombresVoici quelques fonctions de manipulations de nombres : floor(nombre) : retourne le plus grand entier inférieur à l'argument passé à la fonction. ceiling(nombre) : retourne le plus petit entier supérieur à l'argument passé à la fonction. round(nombre) : retourne l'entier le plus proche de l'argument passé à la fonction.

c) Opérateurs logiquesLes opérateurs logiques not(), and et or peuvent être utilisés, comme par exemple section[not(@titre)] sélectionne les éléments section qui n'ont pas d'attribut titre. Attention : lorsque, dans la DTD par exemple, l'attribut est défini comme ayant une valeur par défaut, même s'il n'est pas explicité dans le document XML, il est considéré comme existant.

d) Exercice :Document XML :<?xml version="1.0" encoding="utf-8" ?><?xml-stylesheet type="text/xsl" href="cours.xslt"?><COURS CODE="TC234"> <SUJET>Publication XSLT</SUJET> <ENSEIGNANTS>  <NOM>Amann</NOM> <NOM>Rigaux</NOM> </ENSEIGNANTS>


<cours></COURS>

<PROGRAMME> <SEANCE ID="1">Documents XML</SEANCE> <SEANCE ID="2">Programmation XSLT</SEANCE> <ANNEE>2002</ANNEE><ENSEIGNANTS></ENSEIGNANTS>

</PROGRAMME></COURS>

//cours: //SEANCE: NOM[position()=2] : /COURS/@CODE[.="TC234"] :

/COURS/ENSEIGNANTS : nœuds ENSEIGNANTS fils d’un élément racine COURS//SEANCE[@ID=2] : tout nœud de type SEANCE ayant un attribut ID valant 2NOM[position()=2] : tout nœud NOM qui est le deuxième fils de son père/COURS[@CODE="TC234"] : tout élément racine COURS dont la valeur de l’attribut CODE est TC234 Cette syntaxe va être présentée par plusieurs exemples. Les parties qui dépendent du fichier XML analysé sont écrites de cette manière. child::para : sélectionne l'élément para enfant du nœud contextuel. child::* : sélectionne tous les éléments enfants du nœud contextuel. child::text() : sélectionne tous les nœuds de type texte du nœud contextuel. child::node() : sélectionne tous les enfants du nœud contextuel, quel que soit leur type. attribute::name : sélectionne tous les attributs name du nœud contextuel. attribute::* : sélectionne tous les attributs du nœud contextuel. descendant::para : sélectionne tous les descendants para du nœud contextuel. ancestor::div : sélectionne tous les ancêtres div du nœud contextuel. ancestor-or-self::div : sélectionne tous les ancêtres div du nœud contextuel et le nœud contextuel lui-même si c'est un div. descendant-or-self::para : sélectionne tous les descendants para du nœud contextuel et le nœud contextuel lui-même si c'est un para. self::para : sélectionne le nœud contextuel si c'est un élément para, et rien dans le cas contraire.

child::chapitre/descendant::para : sélectionne les descendants para de l'élément chapitre enfant du nœud contextuel. child::*/child::para : sélectionne tous les petits-enfants para du nœud contextuel. /child:: : sélectionne l'élément racine du document. /descendant::para : sélectionne tous les éléments para descendants du document contenant le nœud contextuel. /descendant::olist/child::item : sélectionne tous les éléments item qui ont un parent olist et qui sont dans le même document que le nœud contextuel. child::para[position()=1] : sélectionne le premier enfant para du nœud contextuel. child::para[position()=last()] : sélectionne le dernier enfant para du nœud contextuel.


child::para[position()=last()-1] : sélectionne l'avant-dernier enfant para du nœud contextuel. child::para[position()1] : sélectionne tous les enfants para du nœud contextuel autres que le premier. following-sibling::para[position()=1] : sélectionne le prochain para cible du nœud contextuel. On pourrait continuer encore longtemps cette liste d'exemples. Cette syntaxe non-abrégée permet beaucoup de raffinement. child::*[self::chapitre or self::sstitre][position()=last()] permet ainsi de sélectionner le dernier enfant chapitre ou sstitre du nœud contextuel.

e) Syntaxe abrégéeCette syntaxe recoupe en fait la "syntaxe de base" vue plus haut. Elle permet d'obtenir des expressions du type para[@type="avertissement"][5], qui sélectionne le cinquième enfant de l'élément para, parmi ceux qui ont un attribut type ayant la valeur avertissement.

para[@type="avertissement"]para/@type= "avertissement"

L'abréviation la plus importante est que child:: peut être omis dans un chemin de localisation. En effet, child est l'axe par défaut. Par exemple, un chemin de localisation div/para est un raccourci pour child::div/child::para.Il en est de même pour les attributs : attribute:: peut être abrégé en @. Par exemple, le chemin de localisation para[@type="warning"]est un raccourci pour child::para[attribute::type="warning"] qui sélectionne les enfants para ayant un attribut type dont la valeur est warning.

// est un raccourci pour /descendant-or-self::node()/. Par exemple, //para est une forme raccourcie de /descendant-or-self::node()/child::para qui sélectionne tout élément para du document (même l'élément para qui serait le 1er élément du document sera sélectionné par //para puisque le noeud élément du document lui-même est un enfant du noeud racine); div//para est un raccourci pour div/descendant-or-self::node()/child::para qui sélectionne tous les descendants para des enfants div.

Exemples :

para sélectionne les éléments enfants para du noeud contextuel

* sélectionne tous les enfants du noeud contextuel

text() sélectionne tous les noeuds enfants de type textuels du noeud contextuel

@name sélectionne l'attribut name du noeud contextuel

@* sélectionne tous les attributs du noeud contextuel

para[1] sélectionne le premier enfant para du noeud contextuel


para[last()] sélectionne le dernier enfant para du noeud contextuel

*/para sélectionne tous les petits enfants para du noeud contextuel

/doc/chapter[5]/section[2] sélectionne la 2ième section du 5ième chapter de doc

chapter//para sélectionne les descendants para des enfants chapter du noeud contextuel

//para sélectionne tous les éléments para du document contenant le noeud contextuel

//olist/item sélectionne tous les éléments item ayant pour parent olist dans le document qui contient le noeud contextuel

. sélectionne le noeud contextuel

.//para sélectionne les descendants para du noeud contextuel

//para

.. sélectionne le parent du noeud contextuel

../@lang sélectionne l'attribut lang du parent du noeud contextuel

para[@type="warning"] sélectionne tous les enfants para du noeud contextuel qui ont un attribut type ayant la valeurwarning

para[@type="warning"][5] sélectionne le 5ième enfant para du noeud contextuel qui ont un attribut type ayant la valeurwarning

para[5][@type="warning"] sélectionne le 5ième enfant para du noeud contextuel si celui-là a un attribut type dont la valeur est warning

chapter[title="Introduction"] sélectionne les enfants chapter du noeud contextuel qui ont au moins un enfant title dont le contenu textuel est Introduction

chapter[title] sélectionne les enfants chapter du noeud contextuel qui ont au moins un enfant title

employee[@secretary and @assistant] sélectionne tous les enfants employee du noeud contextuel qui ont simultanément les attributs secretary et assistant