Apprendre à Créer un composant sous Joomla 1.0

(1)

ALTERVISIONS

Créer un composant sous

Joomla 1.0

Guide d’accompagnement dans la creation d’un

composant Joomla

Lior CHAMLA

5/15/2008

(2)

SOMMAI RE

Avant propos ... 3

Connaissances nécessaires ... 3

But du document ... 3

Le composant Joomla... 4

Le modèle MVC ... 4

Créer son propre composant ... 5

L’articulation ... 5

Base de données ... 5

La table #__ARTISTES ... 5

La table #__CHANSONS ... 6

Créer le fichier de configuration ... 6

Créer le contrôleur ... 7

Créer les modèles ... 8

Créer les vues ... 9

Créer le fichier d’installation XML ... 11

Et voilà, c’est fini ! ... 12

Annexes ... 13

Fichier d’installation music.xml : ... 13

Fichier controleur music.php ... 14

Fichier de vues music.html.php ... 16

Fichier de modèles music.class.php ... 19

(3)

AVANT PROPOS

Avant de commencer le tutoriel…

CONNAISSANCES NECESSAIRES

Avant de vous attaquer à la création de composants sous Joomla, il vous faudrait commencer

par étudier ce CMS. De nombreux tutoriels se trouvent sur Internet à ce sujet :



Joomla Facile :

http://joomlafacile.com/



Joomla Help :

http://help.joomla.org/



…

Il vous faudra aussi maitriser totalement le langage SQL, qui vous permettra d’attaquer une base

de données (en l’occurrence, celle de Joomla).

Et le plus important : Il vous faut des connaissances solides du PHP et du HTML.

BUT DU DOCUMENT

Ce document a pour but de vous expliquer facilement comment créer un composant sous

Joomla 1.0. Vous saurez à la fin de la lecture :



Ce qu’est le modèle MVC



Créer le contrôleur (controller)



Créer les vues (view)



Créer les modèles (model)



Créer le gestionnaire d’installation XML

(4)

LE COMPOSANT JOOMLA

Joomla est un CMS (Content Management System) qui permet à des utilisateurs

non-expérimentés de gérer eux-mêmes leurs sites. Pour rendre ce système utilisable pour tout le

monde et pour toutes les problématiques, Joomla permet aux développeurs de créer des

composants, des thèmes, des modules etc.

Le but du composant est de créer une application au sein du système.

Il permet d’aller très vite dans la réalisation d’un site web. En effet, pour tout ce qui est gestion

des actualités, des utilisateurs etc., on peut se reposer sur l’architecture joomla qui est très

solide, pour mieux se concentrer sur la logique applicative à mettre en place.

De plus ! De nombreux développeurs partagent leurs ouvrages avec la communauté, ce qui

permet à n’importe qui de profiter d’une application développée pour Joomla, et de l’intégrer à

son site.

LE MODELE MVC

Le modèle MVC (Model, View, Controller) correspond à un besoin de séparation entre les

différentes facettes d’une application. J’en profite pour dire que MVC n’est pas N-Tiers,

autrement-dit, N-Tiers est une architecture applicative, MVC est un modèle, ainsi une

application peut être N-Tiers et ne pas implémenter ce modèle et inversement.

Le model correspond à la partie « données » du système. Il correspond donc à toute la couche

qui fournit les données aux autres. Le controller, lui, est chargé d’interroger ces models de

manière à extraire les données utiles à la requête de l’utilisateur. Enfin le view correspond à la

partie de présentation du système.

Un utilisateur voit une vue (view), envoie une requête qui est gérée par le contrôleur qui va

s’occuper d’extraire les bonnes données (model) et de les allier à la bonne vue pour renvoyer

le tout vers l’utilisateur. Et ainsi de suite.

Les composants Joomla peuvent très bien être développés en suivant ce modèle et c’est cela que

nous allons voir dans ce document.

(5)

CREER SON PROPRE COMPOSANT

Nous allons maintenant voir comment peut-on créer un composant Joomla spécifique à une

certaine problématique.

Imaginons que nous ayons besoin d’un composant qui servira à gérer une collection d’artistes et

de chansons (bien sur, il faudra lier les deux).

Notre composant va s’appeler com_music (par convention, les composants se nomment

« com_nomchoisi ».

L’ARTICULATION

Un composant s’articule d’une manière particulière, il contient des fichiers précis :



com_music

o

music.php (controller)

o

music.html.php (view)

o

music.class.php (model)

o

music.xml (fichier d’installation)

o

music.configuration.php (fichier de configuration)

Le fichier de configuration n’est pas forcément nécessaire. Il permet cependant de vraiment

clarifier des informations telles que les constantes d’application.

BASE DE DONNEES

Nous allons créer deux tables, l’une contiendra les données des artistes, l’autre, les données des

chansons.

LA TABLE #__ARTISTES

Script SQL :

CREATE TABLE `#__artistes` (

`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,

`nom` VARCHAR( 255 ) NOT NULL ,

`prenom` VARCHAR( 255 ) NOT NULL

);

On voit qu’elle contient un id, qui sera l’identifiant unique de chaque artiste, un nom et un

prénom. Attention, si vous exécutez ce script directement vers MySQL (sans passer par le

connecteur de Joomla), vous devrez remplacer #__ par le préfixe que vous avez donné aux tables

de la base de données de Joomla. Quand on passe par le connecteur de Joomla, #__ est remplacé

par ce même préfixe, ainsi, en notant le préfixe de cette manière, quelque soit le préfixe utilisé, la

requête passera !

(6)

LA TABLE #__CHANSONS

Script SQL :

CREATE TABLE `#__chansons` (

`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,

`nom` VARCHAR( 255 ) NOT NULL ,

`album` VARCHAR( 255 ) NOT NULL ,

`idArtiste` INT NOT NULL

);

Celle-ci contient un identifiant id, un nom, un album (ce sera le nom de l’album) et l’identifiant

de l’auteur de la chanson, idArtiste. N’oubliez pas ! Si vous exécutez ces requêtes maintenant

remplacez #__ par le préfixe des tables de votre base Joomla (le préfixe le plus répandu est

« jos_ ».

Maintenant que la base de données est mise en place. On va pouvoir commencer les choses

sérieuses.

CREER LE FICHIER DE CONFIGURATION

Le fichier de configuration va contenir

différentes informations applicatives

comme les actions à mener.

Lorsque l’on créé un composant, il faut

se poser la question « Quelles actions

pourront-être menées par

l’utilisateur ? » et y répondre point par

point.

L’utilisateur pourra :

 Ajouter / Modifier / Voir /

Lister / Supprimer les artistes

 Ajouter / Modifier / Lister /

Supprimer les chansons

On va donc traduire ces actions dans

des constantes applicatives qui

(7)

CREER LE CONTROLEUR

On va créer dans le dossier com_music un fichier music.php qui sera le centre de contrôle de

l’application. Selon l’information qu’il va récupérer dans la requête, il va créer la bonne réponse.

Voici le fichier :

On commence par

importer les pages dont

on a besoin, comme la

page de configuration,

la page de modèle

(class.php) grâce à

l’objet $mainframe.

Ensuite, en se servant

de la fonction

mosGetParam() avec

l’objet $_REQUEST,

on peut trouver dans la

requête l’information

correspondant à l’action

à lancer sous le nom de

« task ».

On peut maintenant

agir selon la valeur de

$task.

Ici, si la valeur est la

même que la constante

d’action

_M_TASK_C_ARTIST,

on va proposer le

formulaire de création

d’artiste. Celui-ci

correspond à une vue

que peut nous remettre

HTML_MUSIC

(classe contenant les

VUES).

(8)

CREER LES MODELES

On va créer un fichier music.class.php qui contiendra une série de classes. Ce système marche

sur le principe du pattern ActiveRecord. Chaque table connait son équivalent sous forme de

classe. Un objet issu d’une classe doit représenter trait pour trait une ligne d’une table précise.

On arrive ainsi à atteindre un niveau de persistance très souple et simple à utiliser.

Le but étant de pouvoir piocher un objet a partir de la base, le modifier et le re-stocker derrière,

ainsi, on peut travailler nettement et sainement sur les données de la base en tant qu’objets.

On remarque sur la classe mosArtiste par exemple qu’elle dérive de la classe mosDBTable

proposée par Joomla. Cette classe gère les transactions entre les objets et la base de données. On

voit que la classe mosArtiste contient les même champs que la table #__ARTISTES et ceux-ci

doivent porter exactement les mêmes noms.

On pourra maintenant instancier un objet mosArtiste, lui donner un nom, un prénom ou

encore un id, puis utiliser la méthode store() pour le sauver dans le système, la méthode

delete() pour le supprimer etc. On fait de même pour les chansons.

(9)

CREER LES VUES

On va créer dans le dossier com_music un fichier music.html.php qui va gérer toutes les vues de

notre composant.

On voit ici la première fonction getFormArtiste() qui renvoie un formulaire bien formé

permettant de créer un artiste au sein du système. On voit que l’on se sert une fois de plus de la

constante d’action dans la cible du form. On voit aussi la fonction sefRelToAbs() qui formate

la chaine donnée de manière à avoir le chemin absolu. $option contient le nom du composant à

utiliser (donc pour nous : com_music).

(10)

On voit la fonction getFormChanson() qui va renvoyer le formulaire d’ajout de chanson. On

voit apparaitre des fonctions comme makeOption() ou selectList() qui appartiennent à

l’objet mosHTML proposé par Joomla.

(11)

CREER LE FICHIER D’INSTALLATION XML

On va maintenant créer le fichier d’installation XML du composant. On l’appel music.xml et on

y tape :

On n’oublie surtout

pas l’entête (Source

de beaucoup de

problèmes).

On voit un certain

nombre de champs,

mais les plus

importants sont

<files> et <install>.

L’un va contenir les

différents fichiers à

extraire.

L’autre va contenir

les options

d’installation. Ici

par exemple, on dit

qu’à l’installation,

deux requêtes

doivent être

exécutées.

Lorsque le

composant est

installé, ou plutôt,

pour installer le

composant, Joomla

va parser ce fichier

XML et lire les

informations qui lui importe. Il va créer un dossier du nom du composant (com_music) dans le

dossier components, et y importer les fichiers (balises filename). Il va ensuite exécuter les

requêtes, et une fois toutes les informations lues et exécutées, le composant sera près à l’emploi !

(12)

ET VOILA, C’EST FI NI !

Alors ! Le composant est terminé.

On a créé les fichiers qui vont lui permettre de fonctionner. On a développé ce composant en

suivant le modèle MVC (et en utilisant le pattern ActiveRecord). On a créé le contrôleur qui

va gérer les entrées et les sorties, on a créé les vues qui seront les interfaces auxquelles sera

confronté l’utilisateur, et enfin, on a créé les modèles qui lient l’applicatif à la base de données

via un système de mapping relationnel. On a aussi créé un fichier facultatif que l’on a appelé

« configuration » et qui contient toutes sortes d’informations.

Tout ce petit monde doit maintenant être packé ensemble. On va donc finir par créer le véritable

package com_music ! Il faut simplement créer un fichier com_music.zip contenant le dossier

com_music et les fichiers qui y sont inclus.

Il suffit maintenant de se servir du gestionnaire d’installation de composants de Joomla pour

installer le package com_music !

(13)

ANNEXES

FICHIER D’INSTALLATION MUSIC.XML :

<?xml version="1.0" ?> <mosinstall type="component"> <name>MuSiC</name> <creationDate></creationDate> <author>Lior CHAMLA</author> <copyright>Altervisions</copyright> <authorEmail>[email protected]</authorEmail> <authorUrl>http://www.altervisions.com</authorUrl> <version>1.0.1</version> <description>Composant MuSiC</description> <files> <filename>music.class.php</filename> <filename>music.html.php</filename> <filename>music.php</filename> <filename>music.configuration.php</filename> </files> <install> <queries> <query>

CREATE TABLE `#__artistes` (

`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nom` VARCHAR( 255 ) NOT NULL ,

`prenom` VARCHAR( 255 ) NOT NULL );

</query> <query>

CREATE TABLE `#__chansons` (

`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nom` VARCHAR( 255 ) NOT NULL ,

`album` VARCHAR( 255 ) NOT NULL , `idArtiste` INT NOT NULL

);

</query> </queries> </install>

(14)

FICHIER CONTROLEUR MUSIC.PHP

die( "L'accès directe à cette page n'est pas autorisé." ); //Inclus la classe html (frontend)

//C'est le fichier qui contient les VUES //du composant (On en reparle apres ;))

require_once( $mainframe->getPath( 'front_html' ) ); //Inclus la classe métier

//C'est le fichier qui contient les MODELES

//du composant (Ca aussi, on en reparle apres ;)) require_once( $mainframe->getPath( 'class' ) ); //Inclus la page de configuration

require_once("$mosConfig_absolute_path/components/$option/music.configuration .php");

//On récupere l'action à mener :

$task = mosGetParam($_REQUEST,"task"); //Et on avise ! switch ($task){ default: HTML_MUSIC::getFormArtiste(); HTML_MUSIC::getFormChanson(); HTML_MUSIC::getListArtistes(); break; case _M_TASK_C_ARTIST:

//Si on demande à créer un artiste HTML_MUSIC::getFormArtist();

break;

case _M_TASK_C_CHANSON:

//Création d'une chanson? HTML_MUSIC::getFormChanson(); break; case _M_TASK_S_ARTISTE: saveArtiste(); break; case _M_TASK_S_CHANSON: saveChanson(); break; //ETC ETC } function saveArtiste(){ global $database,$option,$my,$task; //On récupere les informations

$nom = mosGetParam($_REQUEST,"nom"); $prenom = mosGetParam($_REQUEST,"prenom");

(15)

$objArtiste->nom = $nom; $objArtiste->prenom = $prenom; //On sauvegarde $objArtiste->store(); //On redirige mosRedirect(sefRelToAbs("index.php?option=$option"),"Ajout de l'artiste $nom $prenom"); } function saveChanson(){ global $database,$option,$my,$task; //On récupere les informations

$nom = mosGetParam($_REQUEST,"nom");

$album = mosGetParam($_REQUEST,"album"); $idArtiste = mosGetParam($_REQUEST,"idArtiste"); $objChanson = new mosChanson($database);

$objChanson->nom = $nom; $objChanson->album = $album; $objChanson->idArtiste = $idArtiste; //On sauvegarde $objChanson->store(); //On redirige mosRedirect(sefRelToAbs("index.php?option=$option"),"Ajout de la chanson $nom"); } ?>

(16)

FICHIER DE VUES MUSIC.HTML.PHP

die( 'Direct Access to this location is not allowed.' ); require_once( $mainframe->getPath( 'class' ) );

require_once("$mosConfig_absolute_path/components/$option/music.configuration .php");

//On récupère en global la base de données global $database,$option,$my,$task;

/**

* @name HTML_MUSIC

* Classe de Frontend HTML du composant com_music

* Elle permet la génération de l'interface (vue) du composant * @package Music * */ class HTML_MUSIC { function getFormArtiste(){ global $database,$option,$my,$task; ?> <h2>Créons un artiste !</h2> <form action="<?php echo sefRelToAbs("index.php?option=$option&task="._M_TASK_S_ARTISTE); ?>" method="POST"> <table>

<tr><th>Prénom : </th><td><input type="text" name="prenom"/></td></tr> <tr><th colspan="2"><input type="submit"/></th></tr> </table> </form> <?php } function getFormChanson(){ global $database,$option,$my,$task; ?>

<h2>Créons une chanson !</h2> <form

action="<?php echo

sefRelToAbs("index.php?option=$option&task="._M_TASK_S_CHANSON); ?>" method="post">

<table>

(17)

<tr><th>Album : </th><td><input type="text" name="album"/></td></tr>

<tr><th>Artiste : </th><td> <?php

//On créé un tableau qui va contenir les options d'un SELECT

$optionsArtistes = array();

$optionsArtistes[] = mosHTML::makeOption("0","Aucun"); //On créé l'objet qui va servir à trouver les artistes $findArtiste = new mosArtiste($database);

//On récupère la liste

$list = $findArtiste->getList(); foreach ($list as $objArtiste) {

//Pour chaque artiste, on créé une option et on //la stoque dans le tableau

$optionsArtistes[] = mosHTML::makeOption($objArtiste->id

,$objArtiste->nom." ".$objArtiste->prenom); //On donne a makeOption la valeur et le texte }

//On créé un selectList grâce à l'objet //mosHTML proposé par Joomla :

echo

mosHTML::selectList($optionsArtistes,"idArtiste","","value","text",null); //On lui donne la liste des options, le nom du select, les options HTML

//on lui indique aussi que le clé sera la valeur de l'option

//le texte sera aussi le text

//On pourrait aussi lui donné la valeur à selectionner par défaut ?></td></tr> <tr><th colspan="2"><input type="submit"/></th></tr> </table> </form> <?php }

function getListChansons($idArtiste = null){ global $database,$option,$my,$task;

$findChanson = new mosChanson($database);

$list = $findChanson->getList($idArtiste); ?>

<table> <?php

foreach ($list as $objChanson) { ?> <tr> <th><?php echo $objChanson->nom; ?></th> <td><?php echo $objChanson->album; ?></td> <td><?php echo $objChanson->idArtiste; ?></td> </tr> <?php } ?> </table> <?php

(18)

function getListArtistes(){

global $database,$option,$my,$task;

$findArtiste = new mosArtiste($database); $list = $findArtiste->getList(); ?>

<h2>Les artistes !</h2> <table>

<?php

foreach ($list as $objArtiste) { ?> <tr> <th><?php echo $objArtiste->nom; ?></th> <td><?php echo $objArtiste->prenom; ?></td> </tr> <tr><td colspan="2"> <?php HTML_MUSIC::getListChansons($objArtiste->id); //On demande à afficher la liste des chansons //de cet artiste

?></tr> <?php } ?> </table> <?php } }

(19)

FICHIER DE MODELES MUSIC.CLASS.PHP

<?php /**

* @version 1.0.0 * @package Music

*/

defined( '_VALID_MOS' ) or die( 'Interdit !!' );

//Classe représentant un artiste (dans la base de données) class mosArtiste extends mosDBTable {

var $id = null; var $nom = null; var $prenom = null; //Constructeur

function mosArtiste(&$db){

//Constructeur de la superclasse mosDBTable $this->mosDBTable("#__artistes","id",$db);

//Il prend en parametre la table qui correspond à l'objet, le champs qui

//identifie l'objet, et le connecteur de base }

function getList(){

//Récupère la liste des artistes

$sql = "select * from #__artistes order by nom ASC"; //On donne la requête au connecteur de l'objet

$this->_db->setQuery($sql); //On récupère les résultats

$result = $this->_db->loadObjectList(); //On les retourne !

return $result; }

}

//Classe représentant une chanson (dans la base de données) class mosChanson extends mosDBTable {

var $id = null; var $nom = null; var $idArtiste = null; var $album = null; //Constructeur

function mosChanson(&$db){

$this->mosDBTable("#__chansons","id",$db); }

function getList($idArtiste = null){ $sql = "select * from #__chansons";

if($idArtiste) $sql .= " where idArtiste = $idArtiste"; $sql .= " order by nom ASC";

$this->_db->setQuery($sql);

(20)

} ?>

FICHIER DE CONFIGURATION MUSIC.CONFIGURATION.PHP

* Actions se rapportant aux artistes : * Ajout d'un artiste

* Modification d'un artiste * Vue d'un artiste

* Liste des artistes

* Suppression d'un artiste * */ define("_M_TASK_C_ARTISTE","CREERARTISTE"); define("_M_TASK_M_ARTISTE","MODIFIERARTISTE"); define("_M_TASK_V_ARTISTE","VOIRARTISTE"); define("_M_TASK_L_ARTISTE","LISTERARTISTE"); define("_M_TASK_D_ARTISTE","SUPPRIMERARTISTE"); define("_M_TASK_S_ARTISTE","SAUVERARTISTE"); /**

* Actions se rapportant aux chansons : * Ajout d'une chanson

* Modification d'une chanson * Liste des chansons

* On considère qu'on n'a pas besoin d'avoir une * vue à proprement parler d'une chanson.

* */ define("_M_TASK_C_CHANSON","CREERCHANSON"); define("_M_TASK_M_CHANSON","MODIFIERCHANSON"); define("_M_TASK_L_CHANSON","LISTERCHANSON"); define("_M_TASK_D_CHANSON","SUPPRIMERCHANSON"); define("_M_TASK_S_CHANSON","SAUVERCHANSON"); ?>