Créer un module Drupal

Drupal est un CMS fabuleux qui permet beaucoup de choses en grande partie grâce à la communauté d'utilisateurs qui développent des modules permettant d'accroitre ses possibilités. Nous allons voir ici comment créer un module assez simple.
Pour rédiger ce tutoriel, je me suis inspiré de l'excellent livre Pro Drupal Development.

Pour préserver l'arborescence de notre site Drupal et ne pas mélanger les modules que l'on télécharge avec ceux qui appartiennent au coeur de Drupal, nous allons placer les fichiers de notre module dans un endroit bien précis:

 

  • /sites/all/modules

 

Si le répertoire modules n'existe pas dans /sites/all sur votre installation, créez le. Dans ce répertoire, vous allez pouvoir stocker tous les modules que vous téléchargez sur le site de Drupal. A l'intérieur de ce répertoire "modules", créez un nouveau répertoire, et donnez-lui le nom qu'il vous plaît, par exemple "perso", ou "mes_modules". Ce répertoire vous permettra de stocker vos propres modules, et de ne pas les mélanger avec les autres modules que vous aurez téléchargés. Drupal reconnaitra automatiquement les modules, peu importe les sous-répertoires, à partir du moment ou ils sont stockés dans /sites/all/modules. Le module que nous allons créer va permettre aux utilisateurs de notre site d'annoter les pages web qu'ils consultent. Cette annotation ne sera visible que par eux-mêmes. Nous allons donner un nom simple et descriptif à notre module, par exemple "annoter". Nous allons créer, dans notre répertoire /sites/all/modules/perso/annoter, plusieurs fichiers:

  • annoter.info
  • annoter.install
  • annoter.module
  • annoter.admin.inc

Les fichiers .info

Pour que Drupal puisse savoir qu'un module existe, il faut lui donner quelques informations concernant ce module. Il a besoin d'un fichier nomdefichier.info. L'extension .info est obligatoire, c'est sur elle que Drupal se base pour comprendre les fichiers. Les fichiers .info sont de simples fichiers textes qui sont constitués de clés et de valeurs. Contenu du fichier annoter.info :

 
; $Id$ 
name = Annoter 
description = "Permet aux utilisateurs de rédiger des annotations sur le contenu." 
core = 6.x 
package = Actualinet 

La première ligne du fichier(; $Id$) est un tag d'identification qui sert au système de contrôle de versions (CVS). Ce tag sera automatiquement mis à jour par le système de contrôle lorsque vous aurez partagé votre super module avec la communauté des développeurs de Drupal. Ce tag n'a pas vraiment d'importance pour notre exemple.

 
name = Annoter 

Nous donnons un nom à notre module: c'est le nom qui sera visible dans la liste des modules, à l'adresse /admin/build/modules
 
description = "Permet aux utilisateurs..." 

Nous donnons également une description, qui elle aussi sera visible dans la liste des modules.
 
core = 6.x 

Nous indiquons ensuite la version majeure de Drupal avec laquelle notre module est compatible. Cela signifie que si quelqu'un tente d'installer votre module dans une autre version de Drupal, ce dernier refusera tout simplement de l'installer.
 
package = Actualinet 

Lorsque vous parcourez la liste des modules dans Drupal, vous remarquez qu'ils sont regroupés par thèmes. La clé "package" permet donc soit d'intégrer un groupe existant, soit d'en créer s'il n'existe pas. Si vous avez plusieurs modules qui ont le package Actualinet dans leur fichier .info, ils s'afficheront tous dans ce même groupe. Il existe d'autres options que l'on peut insérer dans un fichier .info. Voici un exemple qui nécessite php 5.2 et les modules "forum" et "taxonomy" pour fonctionner:
 
; $Id$ 
name = Forum insolite 
description = "Réassigne au hasard les réponses à d'autres fils de discussions." 
core = 6.x 
dependencies[] = forum 
dependencies[] = taxonomy 
package = "Modules qui font peur" 
php = 5.2 

Les fichiers .module

Les fichiers portant l'extension .module sont reconnus par Drupal. Ils contiennent du code php, exactement comme n'importe quel fichier php, à la différence qu'ils utilisent principalement les hooks de Drupal. Les hooks ressemblent à des fonctions php, mais ils font en réalité appel à l'API de Drupal. Exemple :

function hook_menu() {
  $items = array();
  $items['menu'] = array(
    'title' = 'Mon premier menu', 
    'description' = 'Mon premier menu drupal', 
    'page callback' = 'premier_menu', 
    'access arguments' = array('access content'), 
    'type' = MENU_NORMAL_ITEM, ); 
 
  $items['menu/chemin'] = array( 
    'title' = 'Page de contenu', 
    'page callback' = 'menu_chemin', 
    'access arguments' = array('access content'), 
    'type' = MENU_CALLBACK, 
  ); 
  return $items; 
} 

L'exemple ci-dessus permet de créer un menu intitulé Mon premier menu. Lorsqu'on clique sur ce menu, on appelle la fonction premier_menu. Ce menu est identifié comme tel grâce à la constante MENU_NORMAL_ITEM. Cette constante signifie que l'on rajoute cette entrée de menu. La deuxième portion de code permet d'indiquer un chemin. Cela ressemble à un menu, mais il faut plutôt le voir comme un chemin créé grâce à la constante MENU_CALLBACK. Cela signifie que le lien créé ne figurera pas dans le menu, mais pourra être utilisé en tant que chemin: Drupal reconnaitra ce chemin si l'on tape menu/chemin dans la barre d'adresse du navigateur.
Lorsque ce chemin sera tapé (ou cliqué), la fonction menu_chemin sera appelée. Si vous avez compris le principe ci-dessus, vous êtes en bonne voie pour comprendre le développement de modules sous Drupal!

Lorsqu'on écrit un module, on se sert de hooks. Il faut toujours remplacer les mots-clés hook_ par le nom de votre module, sans quoi rien ne fonctionnerait. Donc, si l'on veut créer un menu pour notre module, nous devons écrire créer une fonction annoter_menu:

/**
* Implementation de hook_menu().
*/
function annoter_menu() {
  $items['admin/settings/annoter'] = array(
    'title' => 'Annotations',
    'description' => 'Modifie le comportement des annotations.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('annoter_admin_settings'),
    'access arguments' => array('administer site configuration'),
    'type' => MENU_NORMAL_ITEM,
    'file' => 'annoter.admin.inc',
    );
  return $items;
}

Regardons le code ci-dessus en détail, pour essayer de comprendre ce qu'il fait, et à quoi il sert.

 
function annoter_menu() { 

annoter_menu, c'est notre implémentation de hook_menu. Prenez bien soin de toujours mettre des nom de hooks équivalents au nom de vos modules, cela permettra qu'il n'y ai pas télescopage avec un autre module: si vous avez deux modules avec le même nom de fonction, vous aurez le problème de fonction déclarée deux fois.

 
'title' = 'Annotations', 

C'est le titre de notre menu (dans l'administration), tel qu'il sera affiché dans la liste des menus.

 
'description' = 'Modifie le comportement des annotations.', 

C'est la description du menu, qui apparait lorsque la souris passe au-dessus du texte de menu.

 
'page callback' = 'drupal_get_form',

On indique à Drupal que le clic sur le menu va créer un formulaire.

'page arguments' = array('annoter_admin_settings'), 

On indique à Drupal quelle fonction sera appelée pour créer le formulaire.

'access arguments' = array('administer site configuration'),

Cela permet d'indiquer qui à le droit d'accéder à ce menu. Ici, seuls les utilisateurs ayant le droit d'administrer le site pourront utiliser et voir ce menu. Si l'on avait voulu donner le droit à tous les utilisateurs d'accéder à ce menu, il aurait fallu écrire array('access content'). Vous pouvez accéder à la liste des permissions de votre site Drupal en allant à ?q=admin/user/permissions

 
'type' = MENU_NORMAL_ITEM, 

Cette ligne permet d'indiquer à Drupal que l'on crée un menu "normal", c'est-à-dire une entrée de menu standard qui sera visible dans la liste des éléments de menu, par opposition à MENU_CALLBACK qui indique non pas un menu, mais un chemin d'url.

 
'file' = 'annoter.admin.inc' 

Vu que l'on est dans la partie admin de notre module, on indique à Drupal d'aller chercher le fichier annoter.admin.inc qui contient les instructions de configuration. Cela permet d'alléger notre module en évitant d'y charger à chaque fois qu'il est appelé des fonctions dont il n'a pas besoin.

Fichier annoter.admin.inc

Lorsque nous seront dans la configuration de notre module, nous auront la possibilité de lister tous les types de contenus disponibles dans Drupal, et sélectionner ceux pour lesquels nous permettront aux utilisateurs d'apposer des notes personnelles.

// $Id$
/**
  * @file
  * Fichier de configuration du module annoter.
  */
 
/**
  * Configuration des annotations.
  *
  * @ingroup forms
  * @see system_settings_form().
  */
function annoter_admin_settings() {
  // Récupère un tableau contenant des noms
  // parlants tels que
  // array('page' => 'Page', 'story' => 'Story')
  $options = node_get_types('names');
 
  $form['annoter_node_types'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Les utilisateurs peuvent annoter ces types de contenu'),
    '#options' => $options,
    '#default_value' => variable_get('annoter_node_types', array('page')),
    '#description' => t('Une zone de texte s\'affichera pour ces types de contenu, permettant aux utilisateurs de les annoter.'),
);
 
return system_settings_form($form);
 
}

Ces quelques lignes démontrent la grande puissance de Drupal, et la facilité déconcertante avec laquelle il gère les formulaires. La fonction node_get_types('names') ramène la liste de tous les types de contenus disponible dans notre installation! Pas besoin d'effectuer de requête SQL et autre code php, c'est Drupal qui se charge de tout cela à notre place.

 
'#default_value' = variable_get('annoter_node_types', array('page')) 

La ligne de code ci-dessus crée une variable persistante qui va contenir la liste des types de contenus qui seront autorisés à être annotés par nos utilisateurs. array('page') sera le type de contenu sélectionné par défaut. Cette variable persistante est stockée dans la table variables de notre base de données. A ce stade de notre développement, nous pouvons commencer à tester notre module, car nous avons créé une page de configuration entièrement fonctionnelle. Vous pouvez essayer le module en l'activant dans admin/build/modules/list, puis en allant dans Configuration du site / annoter (admin/settings/annoter)

Le formulaire d'annotation

Pour que nos utilisateurs puissent annoter le contenu, nous devons définir un formulaire spécifique. Nous allons placer ce code dans notre fichier annoter.module:

/**
  * Implementation de hook_nodeapi().
  */
function annoter_nodeapi(&$node, $op, $teaser, $page) {
  global $user;
  switch ($op) {
  // L'opération 'view' signifie que le noeud est sur le point d'être affiché
  case 'view':
    // L'opération est annulée si l'utilisateur est anonyme (non connecté) ou
    // si le contenu n'est pas affiché en pleine page
    // (par exemple il peut être affiché dans une page de résultats de recherche).
    if ($user->uid == 0 || !$page) {
      break;
    }
  // Quels types de contenu pouvons-nous annoter?
  $types_a_annoter = variable_get('annoter_node_types', array('page'));
  // on annule l'opération si le type de contenu ne fait pas partie des types autorisés à être annotés.
  if (!in_array($node->type, $types_a_annoter)) {
    break;
  }
 
// Récupère l'annotation courante du noeud
// et la stocke dans l'objet noeud.
  $result = db_query('SELECT note FROM {annotations} WHERE nid = %d
    AND uid = %d', $node->nid, $user->uid);
  $node->annotation = db_result($result);
 
  // Appel du formulaire.
  $node->content['annotation_form'] = array(
    '#value' => drupal_get_form('annoter_form', $node),
    '#weight' => 10
  );
  break;
 
  case 'delete':
    db_query('DELETE FROM {annotations} WHERE nid = %d', $node->nid);
    break;
 
  }
}

Le hook utilisé ici (hook_nodeapi) nous permet de modifier l'affichage du contenu à la volée: lorsque le contenu s'affiche sur l'écran de l'utilisateur, si ce contenu figure dans la liste des contenu autorisés, on affiche le formulaire de saisie d'annotation. Pour créer le formulaire proprement dit, nous aurons recours au hook_form, qui permet l'affichage des formulaires dans Drupal:

/**
  * Définition du formulaire d'annotation.
  */
function annoter_form($form_state, $node) {
  // Definition d'une zone de regroupement.
  $form['annoter'] = array(
    '#type' => 'fieldset',
    '#title' => t('Annotations'),
  );
  // On définit une textarea dans le fieldset.
  $form['annoter']['note'] = array(
    '#type' => 'textarea',
    '#title' => t('Notes'),
    '#default_value' => isset($node->annotation) ? $node->annotation : '',
    '#description' => t('Inscrivez ici vos notes personnelles.
        Seuls vous (et l\'administrateur du site) pourront les consulter.')
    );
  // Enregistrement de l'ID de noeud.
  $form['annoter']['nid'] = array(
    '#type' => 'value',
    '#value' => $node->nid,
  );
  // Bouton de soumission du formulaire.
  $form['annoter']['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Enregistrer'),
    );
  return $form;
}

Maintenant, notre module commence à prendre forme! Le formulaire d'annotation s'affiche désormais sur les types de contenu autorisés. Ce qu'il nous manque, c'est le moyen de stocker dans la base de données les annotations de nos utilisateurs, car à ce stade de notre développement, si nous entrons une note dans notre formulaire puis que nous le validons, il ne se passera rien... La façon la plus répandue pour stocker des données dans Drupal, c'est de créer une table spécifique dans notre base pour enregistrer les données. La question que l'on doit se poser, c'est "Que dois-je stocker dans ma table ?" Ce dont nous avons besoin, c'est du texte de la note, l'identifiant du noeud qui reçoit la note, et l'identifiant de l'utilisateur qui rédige la note. Nous pouvons également stocker la date et l'heure de la note (sous forme de timestamp), histoire d'être en mesure de récupérer la liste des notes les plus récentes, classées par date. Voici le code SQL que nous pourrions utiliser pour créer notre table:
 
CREATE TABLE annoter (uid int(10) NOT NULL, nid int(10) NOT NULL, note longtext NOT NULL,
when int(11) NOT NULL default '0', PRIMARY KEY (uid, nid)); 

Cela fonctionnerait, mais cela obligerait les personnes qui installent notre module à exécuter manuellement cette requête SQL. Or, Drupal nous permet d'exécuter des requêtes SQL au moment de l'activation des modules! Ainsi, tout sera transparent pour celui qui installe le module. Pour cela, nous avons besoin de créer un nouveau fichier qui portera l'extension .install. Notre fichier d'installation s'appellera donc annoter.install. Contenu du fichier annoter.install:

<?php
// $Id$
/**
  * Implementation de hook_install().
  */
function annoter_install() {
  // Creation de la table grâce à l'API schema.
  drupal_install_schema('annoter');
  }
 
/**
  * Implementation de hook_uninstall().
  */
function annoter_uninstall() {
  // Supression de la table lors de la désinstallation du module.
  drupal_uninstall_schema('annoter');
  // Suppression de nos variables de la table variables.
  variable_del('annoter_node_types');
}
 
/**
  * Implementation de hook_schema().
  */
function annoter_schema() {
  $schema['annotations'] = array(
    'description' => t('Stocke les annotations rédigées par les utilisateurs.'),
    'fields' => array(
    'nid' => array('type' => 'int',
    'unsigned' => TRUE,
    'not null' => TRUE,
    'default' => 0,
    'description' => t('Le {node}.nid sur lequel s\'applique l\'annotation.'),
  ),
  'uid' => array(
    'type' => 'int',
    'unsigned' => TRUE,
    'not null' => TRUE,
    'default' => 0,
    'description' => t('Le {user}.uid de l\'utilisateur qui a créé l\'annotation.')
  ),
  'note' => array(
    'description' => t('Texte de l\'annotation.'),
    'type' => 'text',
    'not null' => TRUE,
    'size' => 'big'
  ),
  'created' => array(
    'description' => t('Timestamp Unix indiquant la date et l\'heure de prise de note.'),
    'type' => 'int',
    'not null' => TRUE,
    'default' => 0
    ),
  ),
  'primary key' => array(
    'nid', 'uid'
   ),
  );
  return $schema;
}

Vu que l'on autorise une seule annotation par noeud et par utilisateur, on commence par supprimer toute annotation précédente pour le noeud et l'utilisateur courant. Notez le global $user: il nous permet de récupérer l'identifiant de l'utilisateur courant sous la forme de $user->uid. Notez également la façon dont sont écrites les requêtes SQL:

 
"INSERT INTO {annotations} (nid, uid, note, created) VALUES (%d, %d, '%s', %d)", $nid,
$user->uid, $note, time()

Cela sécurise votre module en évitant les attaques de type injection SQL. le %d signifie que l'on entre des chiffres (d = digital), et le %s indique qu'on entre une chaîne de caractères (s = string). Quant aux accolades entourant le nom de la table, elles permettent de prendre en compte les tables préfixées. Par exemple, si lors de l'installation de sa base drupal l'administrateur a décidé de faire préfixer ses tables par le mot "drupal_", notre requête ci-dessus prendra en compte ce préfixe en exécutant INSERT INTO drupal_annotations... Ici, nous n'avons pas besoin de créer de script de connexion à la base, puisque c'est déjà fait par Drupal. Nos requêtes sont donc immédiatement prises en compte. Nous devons maintenant modifier notre fonction (hook) annoter_nodeapi afin d'afficher automatiquement une annotation dans la zone de texte, lorsqu'elle existe:

/**
  * Implementation de hook_nodeapi().
  */
function annoter_nodeapi(&$node, $op, $teaser, $page) {
  global $user;
  switch ($op) {
  // L'opération 'view' signifie que le noeud est sur le point d'être affiché
  case 'view':
    // L'opération est annulée si l'utilisateur est anonyme (non connecté) ou
    // si le contenu n'est pas affiché en pleine page
    // (par exemple il peut être affiché dans une page de résultats de recherche).
    if ($user->uid == 0 || !$page) {
      break;
    }
  // Quels types de contenu pouvons-nous annoter?
  $types_a_annoter = variable_get('annoter_node_types', array('page'));
  // on annule l'opération si le type de contenu ne fait pas partie des types autorisés à être annotés.
  if (!in_array($node->type, $types_a_annoter)) {
    break;
  }
 
// Récupère l'annotation courante du noeud
// et la stocke dans l'objet noeud.
  $result = db_query('SELECT note FROM {annotations} WHERE nid = %d
    AND uid = %d', $node->nid, $user->uid);
  $node->annotation = db_result($result);
 
  // Appel du formulaire.
  $node->content['annotation_form'] = array(
    '#value' => drupal_get_form('annoter_form', $node),
    '#weight' => 10
  );
  break;
 
  case 'delete':
    db_query('DELETE FROM {annotations} WHERE nid = %d', $node->nid);
    break;
 
  }
}

Ici, nous avons ajouté la possibilité de récupérer l'annotation courante (si elle existe) pour le noeud affiché. Nous utilisons la fonction drupal db_result, qui permet de récupérer une seule ligne dans une table, ce qui est forcément le cas puisque nous autorisons la saisie d'une seule annotation par noeud et par utilisateur. Nous avons également ajouté un case 'delete' qui nous permet de supprimer de notre table "annotations" les notes éventuelles d'un noeud qui viendrait à être supprimé.
Voilà, je pense que nous avons fait le tour de la création d'un module complet sous drupal! Voici ci-dessous un zip contenant les fichiers du module que nous venons de créer:

Fichier attachéTaille
annoter.zip2.79 Ko

Bonjour, Je suis en train de

Bonjour,
Je suis en train de créer un un nouveau module en utilisant Drupal 7X. Pour ce fait j'utilise deux base de données à savoir: la base de données de drupal et ma une autre base de données extérieure. J'ai voulu récupérer les données d'une table de la base de données extérieure en utilisant l'indentifiant uid de la base de données de Drupal. Quand je fais une requête, une erreur s'affiche sur ma page me disant que ma table n'est pas dans la base de données de Drupal. Comment faire pour me connecter à ma deuxième base de données?

Merci beaucoup pour cet

Merci beaucoup pour cet article il ma baucoup aider pour comprendre le devlleoppement des modules

Bonjour. J'ai suivi votre

Bonjour.
J'ai suivi votre guide. J'ai essayé d'intégrer le module dans drupal 7. Le module est bien ajouté. Pourtant, je ne trouve null part le lieu ou se trouve le module :( dans tous les onglets . Dans le fichier .module, l'items indique admin/settings/annoter, mais je vois pas du tout.
J'ai ajouté le module Webform pour créer des formulaires automatiquement, quand je vais dans admin\content, je vois tout de suite Webform pour utiliser.

Pourriez m'expliquer un peu là dessus? Merci mille fois.

Bonjour! Je pense que vous ne

Bonjour!

Je pense que vous ne voyez pas le module car malheureusement il a été développé pour la version 6 de Drupal, et n'est donc pas compatible avec Drupal 7. Si vous regardez le fichier .info, vous constaterez que la compatibilité est pour la version 6 (core = 6.x)

Bonjour. J'avoue que je suis

Bonjour.
J'avoue que je suis un vrai vrai débutant de Drupal (seulement 2 jours de découvrir Drupal). :) . J'ai oublié de préciser que j'ai aussi changé 6.x par 7.x. Mais il me semble que le problème n'est pas là. Et vous me rassurez. :) . Pourriez vous faire une mise à jours pour ce module perso? Pour la version 7.X :)

Pour Drupal 7, Utiliser

Pour Drupal 7, Utiliser node_type_get_types() au lieu de node_get_types('names');
comme ça:
$options= array();
foreach(node_type_get_types() as $element)
{

$options [$element->type] = $element->name;
}

J'ai aussi une question

J'ai aussi une question vraiment bête pour les pros, mais semble nécessaire pour moi. Quand on, disons, a ajouté un module(peso/prédéfini), comment on l'utilise? Je veux dire, voilà, je sais que ce module est ajouté ( en regardant dans la liste des modules) et activé. Mais après, comment l'utiliser? :(

Cela dépend des modules.

Cela dépend des modules. souvent, il suffit d'aller sur l'index de la page d'administration pour retrouver le module et le configurer. Mais le plus important, c'est de lire le fichier readme.txt livré avec le module: en principe tout son fonctionnement est expliqué.

Concernant, la mise à jour de mon petit module vers D7, j'y songe, mais je ne vous promet rien dans l'immédiat!

J'ai débuté, il y a quelques

J'ai débuté, il y a quelques mois, une formation en informatique. Je suis libraire. L'informatique était pour moi un monde plutôt magique et incompréhensible. J'effectue actuellement un stage pendant lequel je dois prendre en main Drupal. Cela fait trois semaines que je m'y frotte. C'est dur ! Merci pour ce tutoriel qui m'éclaire sur la fabrication de module. J'espère pouvoir construire mon propre module d'ici la fin de mon stage.

Bonjour Jérôme. Je suis bien

Bonjour Jérôme.
Je suis bien content d'être "tombé" sur ton site car je constate que tu es tombé, tout petit déjà, dans l'informatique, ce qui n'est pas mon cas (j'ai connu l'arrivé des calculatrice programmable à l'école mais ne m'y suis pas intéressé) ce que je regrette aujourd'hui car son état actuel (semble) permettre des "choses" il y a peu encore inimaginables.
Bref, je me suis mis en disponibilité pour me lancer avec enthousiasme dans la création d'un "portail d'assistance à la réflexion, la rencontre et le partage pour porteurs de projets", ais jeté mon dévolu sur Drupal, car il me semblait permettre cette réalisation sans connaitre le PHP et ai entamé (sans le savoir à l'époque) une auto-formation drupalienne.
Évidement, au bout de 5 mois d'apprentissage, je cerne mieux les contours et m'aperçois devoir créer un (ou plusieurs) modules pour parvenir aux fonctions recherchées.
Le but de ce message est donc, outre de te proposé un partenariat sur ce projet et si (ce qui est certainement le cas) tu n'y voit pas d'intérêt ou ne dispose pas de temps, de te demander un petit conseil pour un module qui ressemble un peu à celui que tu propose, mais malheureusement pas complétement.
Je cherche en effet à permettre aux utilisateurs du portail de lier n'importe quel nœud de type "point" à un de leur projet (nœud de type "projet") en lui affectant un "avancement" (5 choix possibles).
J'ai créé et installé le module que tu décrit, puis j'ai commencé a le modifier pour l'adapter a mon besoin, cela fonctionne mais uniquement sur des nœud de type "page", malgré une configuration du module pour affecter cette fonction au type "Point".

Aurait tu la gentillesse de m'indiquer mon erreur, voir de me donner quelques conseils pour répondre à ce besoin ( remplacer la zone de texte par 5 cases a cocher uniques, lier le choix résultant au nœud "point" et à l'utilisateur, mais aussi à son nœud "projet" remplacer la fonction "node_get_types" par un type défini, etc ...)

Merci d'avance

Thierry

Bonjour Thierry, Merci pour

Bonjour Thierry,

Merci pour ton commentaire: il pointe une coquille que j'ai involontairement placé dans le code du fichier annoter.module. L'erreur vient donc de moi!

A la ligne 33 du fichier, il y avait une erreur sur la variable récupérée. Il s'agit de annoter_node_types au lieu de annoter_nodetypes.

Et à cause de cette erreur, le fait de sélectionner un type de noeud dans la configuration du module n'avait aucun effet (la variable n'était pas reconnue); c'est pour cela que le module ne fonctionnait que pour le type page puisqu'il s'agit du type de noeud par défaut déclaré dans le module.

Désormais c'est corrigé, le module devrait fonctionner correctement si tu sélectionnes le type "point" :)

Pour ce qui est de remplacer le textarea par des checkboxes, je t'invite à aller consulter l'api de drupal ici : http://api.drupal.org/api/drupal/developer--topics--forms_api_reference.html#checkboxes

Bien amicalement,

Jerome

Bonjour Jérôme, Merci pour

Bonjour Jérôme,

Merci pour cet article qui me permet de voir un peu plus clair...

Je commence tout juste le dév drupal. Venant du monde .net, la philosophie Drupalienne est encore un peu ardue à saisir.

Dans le cas où je souhaite créer une page qui vérifie un code saisi dans un formulaire par l'utilisateur avant de fonner l'accès à l'inscription, dois-je également passer par un module ou bien y'a-t-il une autre façon de faire (en surchargeant la page d'inscription peut-être) ? De fait la page d'inscription n'est accessible que si un code valide a été saisi.

Pour mieux comprendre, voilà ce que je souhaite réaliser : http://www.faitsmaison.com/module.jpg

Saurais-tu me m'indiquer la marche à suivre ?

Merci d'avance

Guillaume

Bonjour Guillaume, Je ne suis

Bonjour Guillaume,

Je ne suis pas sûr d'avoir bien compris, peut-être que ce que tu souhaite est d'éviter les inscriptions automatiques par des robots spammeurs? Dans ce cas il te faut installer le module mollom, il est parfait pour générer des Captchas sur tous les types de formulaires.

Explication de ce que je veux

Explication de ce que je veux faire : réaliser un accès filtré à la page d'inscription.

En cliquant sur le lien « Inscription », l'utilisateur sera redirigé vers une première page.
Celle-ci est très simple :

un champ de saisie, un bouton valider.

L'utilisateur doit saisir un code qu'il aura reçu par mail ( genre un code à 4 ou 5 lettres par exemple)

En cliquant sur valider, on va vérifier en base que le code saisi existe dans la table « codes ». Si c'est le cas alors il est correct. Sinon, on affiche un message d'erreur.

Si le code est correct, alors on mémorise l'état :
- soit on set une variable de session avec le code saisi
- soit je me disais qu'on pouvait attribuer à l'utilisateur un rôle spécifique qui permet d'accéder à la page d'inscription. C'est possible ça ?

Puis on redirige vers la page d'inscription.

Là, l'utilisateur s'inscrit et on le redirige ensuite vers une page donnée.

Oups, j'ai été trop

Oups, j'ai été trop vite.
Déjà il manque "Bonjour Jérôme, et merci pour la réponse :)"

Ensuite, à la fin il manque :
Voilà mon dilemme ! J'imagine que c'est super simple à faire mais je n'ai pas encore les moyens de l'imaginer en termes "Drupal"...

Comment réaliser cet enchaînement ? Est-ce que tout passe par un module ? ou bien faut-il créer des templates ?

Guillaume

Hello, C'est assez peu banal

Hello,

C'est assez peu banal comme fonctionnement je trouve: avant de s'inscrire, tes utilisateurs doivent indiquer un code qu'ils ont reçu par mail; donc avant de recevoir ce mail, ils doivent renseigner ce dernier sur ton site, ce qui fait pas mal d'étapes avant l'inscription définitive.

En tous cas, pour ce que tu veux faire, je pense effectivement qu'il faut que tu développe un module spécifique. Je pense qu'il faut que tu regarde les possibilités offertes par l'api drupal.

Sinon, il doit être possible d'utiliser conjointement plusieurs modules pour arriver a tes fins, notamment avec le module CCK pour la création du champ de saisie (quoique dans drupal 7 le module cck existe désormais en natif), ainsi que le module Rules pour gérer les conditions.

Mais je te conseille quand même d'essayer de développer toi-même le module, et pas besoin de template, tout l’enchaînement peut se passer par un module.

Alors je vais creuser dans ce

Alors je vais creuser dans ce sens.
Merci pour les conseils
Guillaume

Merci pour ces informations

Très bon article, c'est intéressant. Cela va beaucoup m'aider pour commencer dans le dev de modules drupal!
Bonne continuation

Merci :)

Merci pour vos compliments roger, je suis ravi que cela vous aide!

Poster un nouveau commentaire

Le contenu de ce champ sera maintenu privé et ne sera pas affiché publiquement.
  • Les adresses de pages web et de messagerie électronique sont transformées en liens automatiquement.
  • Tags HTML autorisés : <a> <em> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>
  • Les lignes et les paragraphes vont à la ligne automatiquement.