Drupal 7 : Développement de modules

L’API de Drupal est certainement la plus complète comparée aux autres CMS concurrents. Drupal a toujours eu la réputation d’être le chouchou des développeurs notamment grâce à une construction bien pensée et une API robuste et puissante.

Afin de vous renseigner sur l’API de Drupal, je ne citerai qu’un seul site qui rassemble à lui tout seul tout ce dont vous avez besoin pour prendre en main l’API de Drupal : http://api.drupal.org/api/drupal et c’est tout!

 

En guise d’introduction

Au travers de cet article, nous allons parcourir rapidement les points essentiels pour créer un module sur Drupal. Cependant, cela ne vous fournira qu’une base et il faudra bien évidemment approfondir pour devenir autonome dans la création de modules.

Drupal a une particularité intéressante dans sa manière d’être codé. Au contraire de Joomla qui est codé en MVC, Drupal est codé en programmation procédurale. Les principaux avantages sont les suivants :

• La possibilité de réutiliser le code à différents emplacements. On retrouve donc des notions de complémentarités et de dépendances entre les modules.
• La création d’un code plus structuré et modulable.

Pour en savoir plus : http://fr.wikipedia.org/wiki/Programmation_proc%C3%A9durale

Je trouve la comparaison entre Joomla et Drupal assez significative. Joomla 1.7 pèse 30,9 Mo (non zippé) pour un total de 5 328 fichiers. Drupal 7 pèse 13,8 Mo pour un total de 1 121 fichiers. Je vous laisse le soin d’en tirer une conclusion!

Nous allons donc maintenant rentrer au coeur de la création de modules. Mais d’abord, nous allons faire un bref détour par le FTP...

Un petit tour du coté des fichiers

Nous allons donc voir dans cette partie l’ensemble des fichiers de Drupal 7. Après l’installation de Drupal 7, on se retrouve donc avec les fichiers suivants :

Figure 1 : le répertoire root de Drupal

Nous allons reprendre les dossiers principaux de Drupal. Tout d’abord, le dossier includes est le coeur de Drupal, il ne faut surtout pas toucher aux fichiers se trouvant dans ce répertoire. Le répertoire misc contient des fichiers images ainsi que des fichiers javascript servant à faire fonctionner Drupal 7. Le répertoire modules contient les modules qui ont été migré dans le core de Drupal 7. Le répertoire profiles répertorie les différents profils d’installation qui existent. Il est bien sur possible d’en créer d’autres par la suite. Le répertoire scripts regroupe des actions de Drupal pouvant être exécutées par des commandes shell. Le répertoire themes regroupe les thèmes installés de base sur Drupal 7.

Il reste un répertoire que nous n’avons pas parcouru : le répertoire sites. Il contient l’ensemble des ajouts que nous allons apporter au core de Drupal 7. Il est composé de 2 répertoires :

Figure 2 : Le répertoire sites

Dans le répertoire default, nous allons retrouver le settings.php qui crée le lien avec la base de données. Nous allons aussi retrouver le dossier all où nous allons créer notre module helloworld.

Dans ce répertoire sites, il va aussi être possible de créer des profils de sites. En effet, il va être possible de faire tourner plusieurs sites avec le même noyau Drupal. Cependant, cela n’est pas le sujet de cet article.

Pour bien commencer

Nous allons ainsi créer pas à pas un classique module helloworld qui aura pour premier objectif l’affichage de la chaîne de caractère Hello World. Nous allons bien sur complexifier le module après.

Nous allons nous placer dans le répertoire suivant : site/all/modules.

Figure 3 : Le module helloworld

 

Dans un premier temps, nous allons créer un fichier helloworld.info. Comme son nom l’indique, ce fichier va nous permettre de donner des informations sur notre module. On va ainsi pouvoir définir son nom, sa version, les fichiers associés... mais aussi sa dépendance avec d’autres modules si nécessaire.

Voici notre fichier helloworld.info :

name = helloworld
description = test for module creation
package = public-action
version = VERSION
core = 7.x
files[] = helloworld.module

; Information added by drupal.org packaging script on 2010-03-21
version = "1.0"
project = "drupal"
datestamp = "1269192313"

Nous allons, ensuite, créer un fichier helloworld.module qui sera le coeur de notre module. L’ensemble des fonctions pour le faire fonctionner se trouveront dedans. Nous allons donc poursuivre avec les notions de Hook et de permission.

Grâce à la création de ces 2 fichiers, nous allons donc pouvoir activer notre nouveau module dans la partie administration.

Figure 4 : Activation de notre module helloworld dans la partie administration

La notion de Hook et de permission

Ces notions sont la base pour la création de module sur Drupal.

Un hook est une fonction qui va nous permettre de modifier le comportement de Drupal sans modifier son core. Afin d’utiliser un hook, on suit toujours la synthaxe suivante :

nomdumodule_nomduhook()

Nous allons prendre l’exemple des permissions afin d’illustrer cette notion de hook. Nous allons implanter un hook_permission dans notre fichier helloworld.module.

/**
* Implementation of hook_permission().
*/
function helloworld_permission() {
return array(
'access helloworld' => array('title' => t('Access helloworld'))
);
}

 

Grâce à ces quelques lignes de codes, nous avons implanter une nouvelle permission permettant l’accès à notre module.

Figure 5 : Apparition de notre nouvelle permission Access helloworld

Intégrer un hook_menu dans son module

De la même manière, nous allons implanter un nouveau lien pour pointer vers notre module helloworld. Nous allons donc naturellement faire un hook_menu qui va pointer vers une fonction qui aura simplement pour but l’affichage de la chaîne de caractère Hello World.

/**

* Implementation of hook_menu().
*/
function helloworld_menu() {
$items = array();

$items['helloworld/sayhelloworld'] = array(
'title' => 'Hello World Test',
'page callback' => 'say_hello_world',
'access arguments' => array('access content'),
'type' => MENU_CALLBACK,
);

return $items;
}

Au travers de ce hook, nous avons implanter un nouveau menu helloworld/sayhelloworld qui pointe vers une fonction say_hello_world. Il est à noter que l’accès à ce menu est lié à la permission access content.

Enfin, voici notre fonction qui va afficher notre célèbre Hello World.

function say_hello_world() {
$vars = 'Hello World!';

return $vars;
}

A cette étape, il est normal de ne pas encore avoir de résultat. En effet, le cache doit être vidé afin de prendre en compte ce nouveau lien. Il faut se rendre dans le menu Configuration puis Performance.

Figure 6 : Vider le cache de Drupal

 

Ainsi, lorsque l’on appelle le lien http://localhost/drupal-7/helloworld/sayhelloworld, on obtient le résultat suivant :

Figure 7 : Résultat de notre module helloworld

 

Envoyer des requêtes à une base de données

Drupal 7 a largement étoffé son API concernant les bases de données. On se retrouve avec une API complète pour générer tout type de requête SQL.

Par exemple prenons un requête assez simple :

SELECT uid, name, status, created, access FROM {users} u WHERE uid <> 0 LIMIT 50 OFFSET 0

 

Avec Drupal 6, on se retrouve avec la fonction suivante :

<?php
$result = db_query("SELECT uid, name, status, created, access FROM {users} u WHERE uid <> 0 LIMIT 50 OFFSET 0");
?>

Et avec Drupal 7 :

<?php
$query = db_select('users', 'u');

$query
->condition('u.uid', 0, '<>')
->fields('u', array('uid', 'name', 'status', 'created', 'access'))
->range(0, 50);

$result = $query->execute();
?>

On remarque que l’API de Drupal 7 est beaucoup plus évolué et va vraiment nous permettre d’aller plus loin. Ainsi sur Drupal 7, il est aussi possible de réaliser des hook directement sur les requêtes SQL.

En modifiant la fonction de notre module helloworld avec une requête vers la base de donnée, on obtiendra donc le résultat suivant.

function say_hello_world() {
$query = db_select('users', 'u');

$query
->condition('u.uid', 0, '<>')
->fields('u', array('uid', 'name', 'status', 'created', 'access'))
->range(0, 50);

$result = $query->execute();
foreach ($result as $record) {
dpm($record);
}
}

Figure 8 : Résultat suite à l’envoi de la requête SQL

 

Pour en savoir plus : http://drupal.org/developing/api/database

Créer des formulaires

La majeure partie des failles de sécurité sur un site Internet provient des formulaires. On appelle cela des injections SQL. Drupal dispose donc de sa propre API pour générer des formulaires et, ainsi, ajouter une couche de sécurité fondamentale.

Nous allons ainsi créer toujours de la même manière un hook_form dans notre module helloworld. Nous allons créer un simple formulaire avec soumission.

Tout d’abord, nous allons créer un hook_menu pour créer un deuxième lien dans notre menu pointant vers notre formulaire :

function helloworld_menu() {
$items = array();

$items['helloworld/sayhelloworld'] = array(
'title' => 'Hello World Test',
'page callback' => 'say_hello_world',
'access arguments' => array('access content'),
'type' => MENU_CALLBACK,
);

$items['helloworld/formulaire'] = array(
'title' => 'Hello World Formulaire',
'page callback' => 'hello_world_myform',
'access arguments' => array('access content'),
'type' => MENU_CALLBACK,
);

return $items;
}

 

Ensuite, nous allons créer notre formulaire à l’aide de l’API de Drupal directement au sein de notre fonction hello_world_form.

function hello_world_myform(){
$content = drupal_get_form('hello_world_form');
return $content;
}

function hello_world_form(){
$form['votretexte'] = array(
'#title' => 'Votre texte',
'#type' => 'textfield',
);

$form['valider'] = array(
'#type' => 'submit',
'#value' => t('Soumettre'),
);

return $form;
}

 

Lorsque l’on va sur la page http://localhost/drupal-7/helloworld/formulaire, on a donc le résultat suivant :

Figure 9 : Affichage du formulaire généré par l’API Drupal

 

Ensuite, nous allons pouvoir travailler les informations au travers d’un hook_submit. Il existe de nombreux autres hook permettant, par exemple, de valider les informations rentrées par l’utilisateur avant de les traiter.

function hello_world_form_submit($form, &$form_state){
dpm($form_state['values']['votretexte']);
}

 

La soumission du formulaire donne ainsi le résultat suivant :

Figure 10 : Résultat du formulaire

Pour aller plus loin

http://drupal.org/project/devel

Pour le développement de modules, je recommande grandement l’installation du module Devel. Ce module, orienté pour les développeurs, permet d’avoir des raccourcis simples pour des actions récurrentes sur Drupal. Par exemple, après l’installation du module, un menu développement va être créé avec des raccourcis indispensable comme le fait de vider le cache …

Figure 11 : Affichage du menu Development du module Devel

 

Il va aussi permettre l'exécution directe de code PHP au travers d’un petit bloc bien pratique. Par exemple, voici le résultat de l’exécution du code suivant :

<?php
global $user;
dpm($user);
?>

Figure 12 : On dit adieu au var_dump !

 

Pour aller plus loin dans la création de module, je recommande 2 ouvrages :

• Learning Drupal 6 Module Development de Matt Butcher
• Pro Drupal 7 Development de John Van Dyke

Ces 2 ouvrages reprennent les points importants de la création de modules à l’aide d’exemples. Ils sont bien évidemment en anglais mais il va falloir s’y faire car beaucoup de ressources Drupal sont dans la langue de Shakespeare !

Conclusion

Nous avons donc parcouru de manière très brève et rapide l’ensemble des points importants concernant la création de modules sur Drupal 7. Nous avons insisté sur la puissance de l’API de Drupal qui nous permet de créer plus rapidement et de manière plus sécuritaire des modules.

Cet article se veut comme une introduction et, pour maitriser le développement de modules sur Drupal, il faut bien sûr plus approfondir. L’API de Drupal est certainement la plus complète actuellement et la maîtriser fait gagner un temps considérable. J’espère donc que cet article vous a donné envie d’en savoir plus !