Importer des flux RSS (MSDN Magazine) avec XMLRAD

Sylvain James

Cet article vous démontre l'incroyable facilité de l'environnement XMLRAD à importer des flux RSS. Vous verrez comment ajouter du code de gestion, cette fois avec SharpDevelop, environnement de développement .NET. Il aurait été possible de le faire avec n'importe quel autre environnement (Eclipse, Delphi Studio, VSStudio etc.). Vous apprendrez également comment se servir des instructions XMLGram : HttpInvoke et Match. ♪

- Titre : Importer des flux RSS (MSDN Magazine) avec XMLRAD

- Auteur : Sylvain James

- Parution : 15 octobre 2005

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2005 Developpez. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Qu'est-ce qu'un flux RSS ?

- II. Le Projet XMLRAD étape par étape

- II-1. Création du projet

- II-2. Création du XMLService FormRSSReader

- II-3. Capturer le flux RSS avec HttpInvoke

- II-4. Fondations du visuel avec XSLStudio

- II-5. Cuisiner le HTML avec XMLRAD

- II-5-1. Modifier les titres

- II-5-2. Supprimer la colonne link puis mixer le titre et le link respectif

- II-5-3. Déplacer la description de l'article sous le titre dans un <DIV> caché

- III. Ajouter du code de gestion

- III-1. Parcourir tous les éléments item

- III-2. Ouvrir SharpDevelop et le fichier source associé au module RSSReaderWM

- III-3. Écrire le code de gestion lié à l'évènement FormRSSReader.AfterInternalInstruction

- IV. Afficher la date formatée en face de chaque article

- V. Conclusion

I - Qu'est-ce qu'un flux RSS ?

À l'origine, RSS signifiait Rich Site Summary.

Dans sa dernière spécification, la 2.0, RSS signifie désormais Really Simple Syndication.

Un flux RSS est une grappe de texte structurée en XML, provenant d'un site web quelconque, et qu'en général on extrait pour le republier sur un autre site web. Cela permet de concevoir son propre site, en syndiquant des informations choisies extraites d'autres sites web. Ces sites facilitent l'exportation de leurs informations sous forme de flux RSS. Sur les sites ou les blogs, les flux RSS sont facilement repérables grâce aux icônes suivantes :

De nombreuses applications, agrégateur de flux RSS, existent déjà. Mais ce qui nous intéresse, c'est de pouvoir intégrer ces flux d'information dans nos propres applications web. Par exemple les actualités du jour, la météo, la bourse, ou encore la liste des derniers articles techniques publiés dans MSDN Magazine…

II - Le Projet XMLRAD étape par étape

II-1 - Création du projet

Vous savez que dans un projet XMLRAD, le code de gestion est totalement découplé de la présentation. Nous écrirons seulement deux lignes de code de gestion uniquement pour une conversion de date, et ce en C#. On utilisera SharpDevelop, outil libre et open source.
Assurez-vous qu'il soit bien installé ainsi que le framework .NET 1.1.

Démarrez l'environnement de développement XMLRAD, et créez un nouveau projet. Sélectionnez Projet Simple.

Dans la fenêtre suivante, indiquez le nom du nouveau projet : RSSReader, l'environnement de développement : SharpDevelop. Cliquez sur le bouton << Options Avancées et décochez la case : [oui, je vais utiliser une base de données pour ce projet]. Cliquez sur Suivant et vous devriez aboutir sur la fenêtre suivante. Si on vous demande de migrer à partir d'une version antérieure de XMLRAD, cliquez sur Annuler.

II-2 - Création du XMLService FormRSSReader

Un Module est un conteneur de XMLServices.

Un XMLService est un processus responsable de la production d'une page web particulière.

Dans le module RSSReaderWM, nous allons créer un nouveau XMLService nommé FormRSSReader.
(L'adresse d'invocation par le navigateur sera : http://stardev/RSSReaderBin/Global.aspx/FormRSSReader).
Cliquez sur le module RSSReaderWM puis sur le bouton Ajout de XMLService :

Un assistant vous propose des modèles de XMLServices. Cliquez sur l'onglet Divers, puis sur Fiche Vide et validez.

Une nouvelle page vous demande le nom du XMLService. Saisissez FormRSSReader dans la zone de saisie Nom et cliquez sur le bouton Terminer.

L'assistant a terminé sa tâche et vous pouvez désormais travailler votre XMLService. Dans un premier temps, nous allons rassembler les données utiles de notre future page web, puis nous nous occuperons de la mise en forme.
Sur l'écran suivant, vous pouvez remarquer qu'un gabarit graphique par défaut (Modèle Divers / Page Vide) a été appliqué, mais ne vous inquiétez pas, vous pouvez tout changer si vous le souhaitez.

II-3 - Capturer le flux RSS avec HttpInvoke

La section XMLGram d'un XMLService permet de décrire les instructions qui vont produire et/ou extraire des données. Parmi ces instructions nous trouvons HttpInvoke.

Nous allons ajouter une instruction HttpInvoke dans le XMLGram. Le rôle de HttpInvoke est d'invoquer une URL, et de récupérer le flux résultat.
Cliquez sur le menu XMLGram et en haut à droite de la fenêtre dans XMLGramExplorer, sélectionnez le composant HttpInvoke . Donnez-lui un nom, par exemple StreamReader.
Effectuez un clic droit sur la première instruction par défaut : Params et sélectionnez le menu Insert After. Ensuite, remplissez les paramètres de l'instruction ainsi :

- Méthode : GET

- URL : http://msdn.microsoft.com/msdnmag/rss/rss.aspx?tech=ASP&x=27&y=9

- Identifiant HTTP :

- Mot de Passe HTTP :

- Asynchrone : non coché

- Récupérer le document et le rajouter dans le document de sortie : True

- Selection (XPath) : /rss

- Type de document de sortie : OutputDoc

- Nom du champ de sortie :

L'URL spécifiée est celle invoquant le flux RSS des articles ASP/ASP.NET chez MSDN Magazine de Microsoft.
On demande à l'instruction d'ajouter le flux résultat dans le document de sortie (OutputDoc), qu'on exploitera plus tard pour la transformation XSL (visualisation des données).
La sélection XPath indique le chemin de la grappe XML à récupérer dans le flux résultat. Il aurait pu être possible que seule une partie du RSS nous intéresse.

Voyons maintenant comment XMLRAD exécutera cette instruction et stockera le flux de données. Cliquez sur le menu XML du XMLService.
La grappe XML (Output) s'est enrichie du flux RSS provenant de MSDN Magazine :

Remarquez l'élément <rss>, qui est la racine de la grappe XML constituant le fil RSS récupéré par HttpInvoke.
Maintenant que le mécanisme de production des données est en place, nous allons passer à la représentation visuelle.
Cliquez sur le menu XSL du XMLService.

II-4 - Fondations du visuel avec XSLStudio

Dans l'éditeur XSLStudio, cliquez sur le texte « Ceci est un formulaire simple ». Choisissez le composant DataTable dans la barre centrale rubrique Data.
Dans la partie basse de XSLStudio, effectuez un clic droit sur l'élément <p>, et sélectionnez Insert Before.

Un assistant va s'ouvrir et demander quel nœud XML va servir de racine d'alimentation (Dataset) de notre table. Sélectionnez le nœud <rss> et cliquez sur Next.
Il vous demande ensuite le chemin d'accès aux « record node » qui représente le nœud racine des informations à afficher sur chaque ligne du tableau. Sélectionnez le nœud <item> (enfant de /rss/channel).

L'assistant vous demande quels sont les champs que vous voulez afficher dans le tableau. Sélectionnez les éléments tels que le screen suivant :

Voilà le résultat obtenu, que nous allons retravailler :

II-5 - Cuisiner le HTML avec XMLRAD

On va maintenant oublier un peu les assistants, car on pourrait faire croire aux débutants XMLRAD que rien n'est possible sans eux.
Au contraire, on peut partir complètement de zéro, mais ce serait revenir quelques années en arrière. En revanche, nous allons maintenant rentrer dans le détail du HTML produit par le XMLService et apporter des modifications de manière à améliorer la présentation de notre flux RSS.

II-5-1 - Modifier les titres

Pour modifier un titre, cliquez dessus dans XSLStudio. Dans la partie basse, le flux produit par le processeur XSL s'affiche.
Ci-dessous, nous avons cliqué sur le titre : title. En bas nous voyons que « title » est un texte inséré dans une balise TD. Nous le modifions et confirmons avec CTRL + S pour sauvegarder.
Répétez cette opération pour chaque colonne.

II-5-2 - Supprimer la colonne link puis mixer le titre et le link respectif

Cliquez sur le titre « Link ». Dans la partie basse de l'éditeur effectuez un clic droit sur la balise TD, et sélectionnez Supprimer.
Vous venez de supprimer la colonne TD de la ligne de titre (TR en HTML). Cette ligne TR a été générée lorsque le template rss a été rencontré par le processeur XSL.
Voyons le template rss, cliquez à droite sur le bouton XSL et sélectionnez le template rss.

Une balise TR est générée ainsi que des TD dans lesquelles on retrouve les titres de notre tableau. À la fin, une instruction xsl : <xsl:apply-templates select=« channel/item »/> indique au processeur xsl de déclencher les templates adaptés pour chaque élément item rencontré, enfant de l'élément channel.
Toujours dans l'exploreur XSL, cliquez sur le template : <xsl:template match=« item »/>

Nous voyons qu'à chaque fois que la balise item est « matchée », une TR est générée, avec des colonnes TD à l'intérieur desquelles on extrait des informations du XML (OutputDoc) qu'on avait prévisualisé précédemment dans ce tutoriel.
D'ailleurs si vous cliquez sur le bouton XML (en bas à droite dans XSLStudio), la structure XML de votre document apparaît, en surbrillance l'élément courant. Si vous cliquez sur un autre élément, le chemin relatif de cet élément par rapport à l'élément courant est affiché. Dans l'image ci-dessous, l'élément item est en surbrillance, car c'est l'élément courant. En effet, nous sommes dans le template qui est chargé de traiter le nœud item, donc lorsque le processeur xsl arrivera sur l'élément item, il déclenchera ce template, item sera l'élément courant.

Comme pour le titre du tableau où nous avons supprimé la colonne Description, nous allons supprimer la colonne Description de la ligne générée pour chaque item.

Nous allons maintenant afficher le titre en tant que lien renvoyant vers l'article respectif. Pour cela cliquez sur la partie blanche juste sous la zone Titre, vous allez visualiser uniquement la partie qui s'occupe d'afficher le contenu de cette colonne. Puis pour découvrir et changer un peu, cliquez sur le bouton Source dans l'explorateur de XSLStudio. Profitez-en pour afficher la structure XML également, positionnez-la vers l'élément item, cela va nous servir de repère.

Nous allons écrire du HTML à la main cette fois (on a toujours le choix), en encapsulant le titre dans un lien <a href=""> dont la référence sera justement le contenu de l'élément link. Voici la modification à apporter :

L'élément link est intégré dans le HTML à l'aide d'accolades {} et non d'une instruction xsl:value-of, car il doit être inséré dans un attribut et non un élément. Remarquez la barre d'état du navigateur, le lien a bien été pris en compte (je survolais le lien avec la souris au moment de la capture d'écran).
Ici nous avons intégré un lien, mais on peut injecter le HTML que l'on souhaite, une image comme une applet flash par exemple.

II-5-3 - Déplacer la description de l'article sous le titre dans un <DIV> caché

Nous allons encore modifier la structure HTML du résultat, cette fois en supprimant la colonne Description. À la place nous ajouterons un lien à la fin de chaque Titre, et le fait de cliquer successivement sur ce lien fera apparaître ou disparaître la description dans un bloc (DIV) situé juste sous le titre.
Supprimez la colonne description, qui prend beaucoup de place, et qu'on ne visualisera que sur commande.
On va ensuite ajouter une image avec lien juste après le contenu le la colonne titre :
Cliquez à nouveau sur la zone blanche juste en dessous du titre de colonne « Titre ». Dans la palette HTML, choisissez le composant ImageLink, puis dans XSLStudio, effectuez un clic droit sur <xsl:value-of select=« title »>, ce qui aura pour effet d'ajouter l'image juste après le contenu du titre de cette ligne.

Puis choisissez une image de votre choix dans l'explorateur d'image. XMLRAD se charge d'insérer le chemin relatif dans la balise <img>. Le résultat obtenu ressemble à celui-ci :

On va passer en mode source, puis ajouter une balise <DIV> nommée sous l'image que l'on vient d'ajouter. Dans le style de ce bloc, on attribuera une couleur de fond (background-color) et de texte (color), et on cachera le bloc (display:none).
On ajoutera aussi une commande JavaScript dans l'évènement onclick du lien dans lequel l'image est placée :

onclick="ShowHide('Desc{position()}');return false"

On supprime aussi le lien href par défaut en le remplaçant par un point (.). Seul le déclenchement du onclick nous intéresse ici lorsque l'on cliquera sur l'image. C'est pour cela que nous avons ajouté le morceau de code js : return false; qui évite au navigateur de chercher à aller sur le lien href après avoir traité le onclick.

ShowHide est une fonction issue de la bibliothèque JavaScript (voir Appendix de la bibliothèque xslc.js) de l'environnement XMLRAD. Elle prend en paramètre l'identifiant d'un élément du DOM, et se charge de cacher ou afficher cet élément selon son état initial, se comportant comme un interrupteur.

position() est une expression xsl qui renvoie la position du nœud XML en cours de traitement par le processeur XSL. Nous nous en servons pour être surs d'attribuer un nom différent à chaque bloc généré.

Lorsque nous voudrons Afficher ou Cacher un bloc, il nous sera possible de localiser un bloc distinctement des autres grâce à son nom unique.

Dans le screen ci-dessous, étudiez le code que nous avons modifié dans XSLStudio. Nous n'avons pas ajouté grand-chose, mais c'est efficace.
Vous voyez le code modifié en surbrillance couleur.

Si on repasse en mode Normal dans XSLStudio, alors voici la vue correspondante :

Cette vue « en grille » est souvent utile et claire pour appréhender la structure HTML. Ne vous étonnez pas si vous ne voyez pas le nouveau bloc DIV dans la fenêtre Preview, c'est normal puisque nous lui avons demandé d'être caché (style = display:none).

Vous pouvez maintenant exécuter le projet et vérifier l'affichage de la description lorsque vous cliquez sur le lien image dans la zone titre.

III - Ajouter du code de gestion

Vous pouvez remarquer que jusqu'à présent, nous n'avons saisi aucune ligne de code conduisant à la production de données, l'instruction HttpInvoke s'en étant chargée.
La date de publication des articles fournie par le flux RSS n'est pas vraiment au format idéal pour un francophone. Cela nous donne une bonne occasion de voir comment on va pouvoir ajouter des informations dans le XML, en convertissant les dates de type Tue, 11 Oct 2005 00:00:00 GMT au format de type 11/10/2005.
* Pour ce faire nous devons trouver un moyen de :

- parcourir tous les éléments item ;

- lire l'élément enfant item/pubDate ;

- convertir sa valeur vers le nouveau format date ;

- réinjecter le résultat dans le XML (Output), qu'on exploitera dans le XSL.

III-1 - Parcourir tous les éléments item

En programmation classique, nous utiliserions une classe XMLReader ou équivalent, de façon à déplacer un curseur XML sur le flux RSS.

XMLRAD nous évite encore une fois de taper des lignes de code, car l'instruction Match réalise ce travail… Une minute pour mettre en place l'instruction et aucun bug possible !

Retournez dans l'éditeur XMLGram, sélectionnez l'instruction Match, donnez-lui le nom Items, effectuez un clic droit sur la dernière instruction HttpInvoke,
et enfin cliquez sur le menu Insert after.

- L'instruction Match devra parcourir le flux RSS : dans la source de données Output.

- Le chemin XPath pour matcher chaque article est : /document/rss/channel/item.

- Enfin nous demandons à l'instruction de remplir le context, car nous nous en servirons pour récupérer la date à formater.

III-2 - Ouvrir SharpDevelop et le fichier source associé au module RSSReaderWM

Si créer des applications .NET avec XMLRAD vous intéresse, vous pouvez lire ce tutoriel écrit par Jean Philippe Bempel (RDM) :

Créer une application .NET avec XMLRAD

Nous allons enfin taper une ligne de code ! Ouf sauvés !
Quel est le moyen de prendre la main à chaque fois que l'instruction Match nommée Items va s'arrêter sur un élément item (se comportant comme un itérateur en quelque sorte) ?
Vous devez connaître le workflow d'exécution d'une instruction XMLGram (Appendix 13), et donc savoir qu'à chaque fois qu'une instruction Match itère sur un élément, les gestionnaires d'évènement BeforeInternalInstruction et AfterInternalInstruction sont exécutés.

Nous allons ouvrir le projet SharpDevelop sous-jacent à l'application et écrire le gestionnaire d'évènement AfterInternalInstruction nécessaire. Démarrez SharpDevelop et ouvrez le projet XMLServer.cmbx situé dans le dossier \Bin de notre application.

Ensuite dans la fenêtre projet de SharpDevelop, effectuez un double clic sur RSSReaderWM.cs qui est le fichier source lié à la prise en charge des traitements en code du module RSSReaderWM.

Décommentez

// private XMLComponent.WebForm Updatepublishers;

et remplacez UpdatePublishers par FormRSSReader (le nom de notre XMLService).

Les projets SharpDevelop ne disposent pas de mode designer pour afficher les modules dans lesquels on place des composants XMLService, à l'instar d'autres environnements comme Delphi Studio ou Visual Studio.

Par conséquent tout le code doit être écrit par vos soins, dont l'instanciation des composants. C'est pour cette raison que les fichiers .cs correspondant à chacun des modules intègres par défaut du code sample, très utile comme guide.

Il suffit de s'appuyer dessus et de personnaliser en rapport avec notre XMLService.

III-3 - Écrire le code de gestion lié à l'évènement FormRSSReader.AfterInternalInstruction

Après avoir déclaré la variable private : private XMLComponent.WebForm FormRSSReader;, nous devons l'instancier dans la méthode InitializeComponent().
Nous ajoutons un delegate pour gérer l'évènement AfterInternalInstruction. Le nom de la méthode qui jouera ce rôle est FormRSSReader_AfterInternalInstruction.

private void InitializeComponent()
{
FormRSSReader = new XMLComponent.WebForm();
FormRSSReader.AfterInternalInstruction += new XMLComponent.TAfterInternalInstructionEventHandler(FormRSSReader_AfterInternalInstruction);
}

Il nous reste à coder cette méthode delegate, dans laquelle nous allons réaliser la conversion de date.

Nous utiliserons les classes .NET : DateTime et Convert. Cette dernière est étonnante, car elle va être capable d'ingurgiter une date au format RFC 1123 (format de date utilisé dans RSS2) sans broncher !

private void FormRSSReader_AfterInternalInstruction(XMLCLX.IXMLInstruction XMLInstruction, XMLComponent.TAfterInternalInstructionEventArgs e)
{
DateTime dt;

if (XMLInstruction.Name == "Items")
{
dt = Convert.ToDateTime(Context.GetValue("pubDate"));
e.Input.SetValue("pubDateFormatted", dt.ToString("dd/MM/yyyy"));
}
}

Vous remarquez que nous ajoutons la date convertie dans le container Input alors que traditionnellement c'est dans Output que nous ajoutons nos données de gestion.

Il s'agit d'une particularité liée à l'instruction Match. Ce n'est pas une instruction qui produit des données, mais qui s'appuie sur des données déjà existantes. C'est la raison pour laquelle l'élément matché à chaque itération est accessible dans le container Input.

Lorsqu'on utilise une instruction DBExtract, cette dernière produit des données dans le XML à chaque fetch de la base de données. C'est donc dans le container Output que l'élément courant est placé, puisqu'il vient d'être créé.

Il reste une dernière chose : Compiler le projet et vous pourrez passer aux tests pour vérifier la qualité de votre travail :-)

IV - Afficher la date formatée en face de chaque article

Vous pouvez quitter SharpDevelop. Revenez à l'environnement XMLRAD, ouvrez le XMLService FormRSSReader et cliquez sur le bouton XML.
Cliquez ensuite sur le bouton Regenerate XMLData pour être sur d'obtenir un fichier XML exemple à jour.
Vous devriez observer la structure XML suivante, en remarquant la présence du nouvel élément enfant de item : pubDateFormatted.

Retournons à présent dans le menu XSL qui va nous permettre de mettre à jour la mise en forme en remplaçant l'élément pubDate par pubDateFormatted.
Cliquez sur une date dans la fenêtre Preview de XMLStudio, et dans la partie basse, remplacez le xsl:value-of select=« pubDate » par xsl:value-of select=« pubDate ».

Vérifiez dans la fenêtre preview, maintenant la date formatée par votre code est affichée :

V - Conclusion

L'aspect fortement détaillé de chacune des étapes de cet article pourrait insidieusement faire croire au lecteur que tout ça est bien compliqué.
J'ai volontairement pris soin de ne pas macher les étapes de construction du projet, afin que les débutants sur XMLRAD, de plus en plus nombreux à s'intéresser à cet environnement, ne soient pas perdus.
La prise en main de XMLRAD peut sembler déconcertante, car cet environnement ne ressemble en rien aux autres, à part peut-être à un Cocoon sous stéroïdes puissance 10 ;-) Il faut retenir que pour réaliser la démo préalable à l'écriture de cet article, il m'a fallu très peu de temps, tout juste quelques minutes. Alors maintenant que vous avez suivi jusqu'au bout cet apprentissage, essayez tout(e) seul(e) comme un(e) grand(e) avec d'autres flux RSS.
Je projette une suite à cet article, dans lequel on ajoutera une liste de plusieurs fils RSS, ce qui nous permettra de voir comme gérer le passage de paramètres, entre autres.

À bientôt, et n'hésitez pas à revenir sur ce tutoriel dans le forum XMLRAD.

Sylvain James