Créer un module Drupal 8

Pré-requis techniques :

  • Avoir installé une version de Drupal 8 en locale

Connaissances pré-requises :

  • Savoir programmer en PHP
  • Connaître la programmation objet
  • Connaître les bases du patron MVC

Le dossier modules de Drupal 8 se trouve à la racine de votre installation Drupal. N’oubliez pas d’entrer le nom d’un répertoire pour votre module à la fin de ce chemin. Par convention, le nom de ce répertoire est le nom dit “machine” de votre moduleC’est un nom unique, en minuscules et sans espaces.

Le nom machine de votre module doit être unique et sans espaces. Afin d’éviter les soucis de compatibilité entre deux modules de même nom, la convention est d’utiliser comme nom machine pour votre module le nom utilisé dans l’URL du module sur Drupal.org. En d’autres termes, avant de créer un nouveau module, vérifiez que nom_du_module choisi n’existe pas déjà en vérifiant que la page https://drupal.org/project/le_nom_choisi n’existe pas encore.

Votre module doit être placé dans le dossier modules de votre installation Drupal. Tous les fichiers de ce module seront contenus dans un dossier dont le nom sera le “nom machine” du module. Ce nom machine doit être unique et sans espaces.

Avant de créer un nouveau module, vérifiez que nom_du_module choisi n’existe pas déjà en vérifiant que la page https://drupal.org/project/le_nom_choisi n’existe pas encore.

La première étape pour la création d’un module est l’écriture d’un fichier nom_du_module.info.yml. Autrefois appelé “le .info”, ce fichier est désormais dit “.info.yml” ou encore “le YML” et son extension est .info.yml. Le nom du fichier est celui que Drupal considérera être le nom machine de votre module. Choisissez le avec attention, sans espaces ni caractères spéciaux et en minuscules, comme indiqué précédemment.

  • Nommez votre fichier, par exemple File name : hello_world.info.yml.
  • Entrez le code suivant :

name: Hello World
core: 8.x
type: module
package: Tutos cci
description: Mini module test pour Drupal 8.

La propriété name définis le nom du module, core la version de Drupal nécessaire pour le faire fonctionner et enfin type indique que nous faisons ici un module. J’ai ajouté un champ description , mais celui-ci n’est pas obligatoire ainsi que le champ package qui permet de regrouper ensemble divers modules.
A ce stade, votre module ne fait rien. Le fichier .info.yml définit ce module qui apparaît désormais dans la liste des modules de votre site à l’adresse : <yoursite.com>/admin/modules.

drupal1

Le nouveau module apparaît désormais dans la liste des modules.

 

En résumé…

Un module Drupal doit avoir un “nom machine” unique, en minuscule et sans espace. Il doit être crée dans un dossier ayant pour nom le nom machine du module et placé dans le dossier modules de Drupal. Il doit contenir au minimum un fichier $module.info.yml décrivant dans la syntaxe YAML au moins :

– le titre

– la version de Drupal Core du module

– un type indiquant qu’il s’agit d’un module.

 

 Création d’une nouvelle route

Nous allons maintenant créer une nouvelle page sur notre site Drupal, à l’adresse <mon_site.com>/hello_world. Pour cela, nous devons créer une nouvelle route (via les nouveaux mécanismes Symphony 2 inclus dans Drupal 8). Une route est un concept Symphony associé au composant routing (routage). Il permet de créer des “URL créatives”, c’est à dire des URLs comme /blog/mon-article ou encore /hello_world et de leur associer un contrôleur qui va permettre de construire le contenu de cette page. Là encore nous verrons tout en détail dans un prochain article. Le but ici est de simplement présenter les principes de bases de la création de modules Drupal. Dans ce paragraphe nous allons voir les points suivants :

  • nous devons créer des configurations via des fichiers YML dont les noms sont des conventions à retenir.
  • nous devons utiliser des concepts de POO (Programmation Orientée Objet) et parfois étendre des classes de Drupal Core.
  • nous devons utiliser un modèle MVC (Modèle / Vue / Controller) pour gérer nos pages (nous verrons ici lecontroller).

Commençons par créer notre nouvelle route. Celle-ci définiera une page dont l’URL sera /hello_world et appelant un controleur que nous définierons ensuite et dont le nom sera HelloWorldController. Symphony 2 permet de définir notre route de diverses manières : YML, XML ou PHP. La convention Drupal quant à elle, impose de créer la route dans un fichier $module.routing.yml et placé à la racine de l’arborescence de notre module (donc directement dans le dossier $module). Vous remarquerez l’usage de $module pour désigner le nom machine du module dans la documentation.

  • De la même manière que pour le fichier.info.yml, créez un fichier routing.yml :
    • Créez un nouveau fichierrouting.yml.
  • Entrez le code suivant :

hello_world.hello_world:
path: ‘/hello_world’
defaults:
_controller: ‘Drupal\hello_world\Controller\HelloWorldController::helloWorld’
_title: ‘Hello World’
requirements:
_permission: ‘access content’

  • La première ligne définit la clef de la route. Nous verrons par la suite que nous pourrons créer des liens dans les menus de Drupal et que ces liens devront se référer à une route. C’est ce nom qui définit notre route. Ici, j’ai choisi le nom hello_world. Cela peut paraître bizarre, mais il faut retenir une chose : le nom de la route doit être unique. Autrement dit, il faut être sûr que ni Drupal, ni aucun autre module développé par n’importe quel développeur n’aura de route du même nom. Pour éviter un maximum les conflits, la convention est de choisir le nom de votre route comme ceci : nom_du_module.nom_de_la_page, où le nom_de_la_page représente ce que la page va faire. Par exemple, pour créer les formulaires d’enregistrement d’un nouvel utilisateur ou encore celui permettant à l’utilisateur de se loguer, le module user créera les routes : user.register et user.login dans son fichier user.routing.yml.
  • La lignepath permet de définir l’URL de la page que nous souhaitons créer. Ici, /hello_world. Ce chemin doit commencer par un slash et ne pas dépasser neuf niveaux.
  • La lignedefaults définit les données par défaut de cette route. Nous développerons les différentes possibilités dans un prochain article. Ici, nous avons utilisé les clefs suivantes :
    • _controller: pour définir le contrôleur chargé de créer le contenu de cette page.
    • _title: pour donner un titre à notre page.

D’autres données peuvent être utilisées. Par exemple la route user.login (définie par le module user) utilise la clef _form pour définir non pas une route se référant à une page avec un contenu, mais plutôt à un formulaire. Celui-ci s’affichera sur la page d’URL définie via la ligne path juste au-dessus, mais pourra aussi être réutilisé par la suite dans un block.

  • La lignerequirements définit les pré-requis que l’utilisateur de votre site doit avoir pour utiliser votre route. Dans notre cas, le pré-requis est d’avoir la permission “access content” (définie par le module core node), c’est à dire le droit d’accès au contenu de notre site (qui pourrait être refusé aux utilisateurs non enregistrés). C’est le sens de la ligne dont la clef est _permission.

Nous venons de déclarer une nouvelle route pour créer une page dont l’URL est /hello_world et son contrôleur est HelloWorldControlleur. Pour l’instant, ce contrôleur n’existe pas. Si vous vous rendez sur la page /hello_world de votre site, vous n’aurez plus désormais une belle erreur “Cette page n’existe pas” car nous venons de la créer. A la place, vous aurez l’erreur suivante :

drupal2

Création du contrôleur de la page

Durant la déclaration de la route précédente, nous avons délégué la création du contenu de la page à la méthode helloWorld du contrôleur HelloWorldController. C’est ce que nous retrouvions à la ligne :

_controller: ‘Drupal\hello_world\Controller\HelloWorldController::helloWorld’

Les utilisateurs de Symphony reconnaîtront ici cette ligne mais noterons quelques différences : la convention Symphony de nommage du contrôleur Bundle:Class:Method est quelque peu différente. Dans Drupal, la convention est la suivante : la clef utilisée sera la plupart du temps _controller lorsque le contrôleur de la page renverra un contenu destiné à être rendu simplement dans un layout HTML. Nous verrons d’autres clefs dans un prochain article.

Le nom du contrôleur pointé par la clef _controller doit suivre la convention suivante :

_controller: \Drupal\nom_du_module\Controller\MaClasseController::maMethode

Notez que le chemin du contrôleur doit commencer par un slash. Notez également que le contrôleur sera placé dans un fichier nommé MaClasseController.php placée dans les répertoires src > Controller

Eux-mêmes placés à la racine de votre module.

Dans le cadre d’un module, le namespace Drupal\nom_du_module est mappé par convention sur un dossier nommé src placé à la racine de votre module. Votre fichier MaClassController.php sera donc dans :    modules/nom_du_module/src/Controller/MaClasseController.php

Le contrôleur est une classe de nom MaClasseController (remarquez que la première lettre de chaque mot est en majuscule, y compris la première et que le nom se termine par Controller). Enfin la fonction lancée par la route est la méthode maMethode présente dans la classe de mon contrôleur. On notera cette fois la présence d’une majuscule à chaque mot, sauf la première lettre.

Un module nommé myModule est donc placé dans un dossier nommé également myModule dans le répertoire modules de l’installation Drupal. Un de ses contrôleurs appelé FooBarController sera dans un fichier php stocké ici (relativement à la racine de Drupal) :

modules/myModule/src/Controller/FooBarController.php

Cette convention de nommage du chemin est appelé PSR-4.

Commençons par créer l’ensemble des sous-dossiers src/Controller dans notre module. Pour cela :

  • Entrez le nom des différents fichiers de la structure à créer :
    • Folder name : src/Controller
  • Créez un fichier HelloWorldController.php.

 

Le fichier du nouveau contrôleur est désormais crée.

  • Entrez désormais le code suivant :
L’important dans ce code est de remarquer que nous définissons bien notre contrôleur : la classe HelloWorldController. Celle-ci implémente la classe abstraite ControllerBase. Cette interface définit un petit contrôleur basique ainsi que quelques méthodes utiles. Par exemple :

  • l() :pour créer un lien vers une route existante.
  • t() :pour traduire une chaîne de caractère dans la langue de l’utilisateur.
  • currentUser() :pour récupérer un objet représentant l’utilisateur visitant la page.

Il est conseillé de réserver l’usage de ce contrôleur basique ControllerBase à des pages triviales, c’est à dire à des pages dont le contenu ne change pas selon l’utilisateur, par exemple un formulaire, la page de configuration de votre module, etc.. Les pages à la logique plus complexe où il sera intéressant d’adjoindre des tests unitaires préféreront l’interface : ContainerInjectionInterface.

Un peu de technique :

Bien que cela fonctionne techniquement, ce serait une erreur de ne pas hériter d’un contrôleur fourni par Drupal, comme par exemple ControllerBase. L’une des raisons est que l’usage de la fonction t() référencerait la fonction globale t() définie dans bootstrap.inc rendant difficile les unit tests de votre classe (à cause de dépendances globales). En utilisant $this->t(), nous faisons référence ici à l’implémentation de t() fournie par ControllerBase, elle-même basé sur l’usage d’un TranslationManager local.

Rappelez-vous la ligne suivante du fichier hello_world.routing.yml :

_controller: ‘Drupal\hello_world\Controller\HelloWorldController::helloWorld’

Nous avons vu que cette ligne définit la cible de la route dans le contrôleur. En l’occurrence la méthode helloWorld(). C’est cette méthode publique que l’on retrouve définie dans notre contrôleur. A l’intérieur de cette méthode, l’objet $output est appelé “Render Array” ou “Renderable Array“. Il s’agit d’une structure définissant un objet destiné à être rendu (affiché sur le site) en HTML. La clef #markup définit le plus simple élément pouvant être affiché : une chaîne de caractères simple, rendue dans une <div> ou un <p>. Les propriétés à utiliser sont spécifiques à chaque type d’éléments pouvant être rendus (champ de texte, image, case à cocher, etc…) et chaque module peut ajouter éléments et propriétés. Créer une liste exhaustive est donc une tâche ardue voir impossible. A ma connaissance il n’y a pas de documentation complète des propriétés des Render Array. Toutefois, il est à noter que les formulaires sont rendus (transformés en code HTML affichable) par le même mécanisme. Vous pouvez donc utiliser la documentation Form API Reference pour trouver un maximum d’éléments et propriétés utiles. Enfin, vous pouvez lire la documentation sur les Renderable Arrays qui définit un certain nombre de propriétés supplémentaires, notamment pour l’usage des caches, thèmes et autres.

  • Activez à présent votre module ou videz le cache de votre site (si le module est déjà activé).

Rendez-vous à la page /hello_world de votre site. Une page apparaît, avec votre titre et votre texte.

En résumé…

Basiquement, une route est un lien logique entre l’URL entrée dans le navigateur et la page (ou l’élément) devant s’afficher à l’écran. Cette route est définie dans un fichier $module.routing.yml placée à la racine du module.

Le Controller est la classe en charge de la création de l’élément en destination de route. Nous verrons plus tard pourquoi nous l’appelons Controller. Cette classe est placée dans un fichier nommé FooBarController.php, lui même inséré dans la structure de répertoire suivante :

/src/Controller.

Nous avons créé notre premier module Hello World et disposons à présent d’une page à l’adresse /hello_world. C’est bien ! Mais à moins que vos visiteurs puissent deviner l’URL de vos pages, il faudra créer un lien vers cette page dans le menu.

Nous allons ajouter un lien dans le menu du site pour accéder à notre nouvelle page hello_world.

Pour ajouter un lien dans un des menus de Drupal 8, nous allons utiliser le nouveau Menu API de Drupal 8 et créer un fichier nommé module_name.links.menu.yml placé à la racine de notre module.

Les anciens développeurs Drupal auront pour réflexe d’utiliser hook_menu(). Ceux ayant suivis les premières étapes de Drupal 8 voudront utiliser hook_menu_link_defaults(). Ces deux approches ont désormais changé. Plus besoin de code procédural, seule la configuration YAML est désormais nécessaire pour créer notre nouveau lien de menu.

  • Comme pour les tutoriaux précédents, commencez par créer un fichier nommé links.menu.ymlà la racine de votre module.
  • Insérez le code suivant :

hello_world.hello_world:
title: Hello World
description: ‘Access the hello world page.’
route_name: hello_world.hello_world

Dans ce fichier YML, vous pouvez définir l’ensemble des liens de menu de votre module les uns à la suite des autres. Chacun d’entre eux doit être dans une structure définie par plusieurs paramètres :

  • une clef unique pour le lien. Par convention et pour garantir l’unicité de cette clef, nous pourrons la choisir de la forme : action_du_lienoù “action du lien” représente quelque chose de logique par rapport à ce lien. Dans notre cas, le lien mène vers la page hello_world, c’est donc le nom logique de notre action.
    • title (obligatoire) :définit le titre du lien dans le menu.
    • description (optionnel) :permet d’ajouter une description au lien (dans la balise title).
    • route_name (obligatoire) :indique quelle route appeler lors du clic sur ce lien.

La convention de choix de nom pour notre lien est la même que celle pour le choix du nom de notre route. En toute logique nous retrouvons donc dans notre exemple un nom de route identique à celui de notre lien. C’est logique mais pas obligatoire.

 

Par cette configuration, notre lien sera automatiquement ajouté au menu Tools de Drupal 8 en tant qu’élément classique de menu. Ceci car :

  • la clef optionnelle menu_namen’ayant pas été précisée, elle est automatiquement assignée au menu Tools.
  • la clef optionnelle parentn’ayant pas été précisée, le lien est automatiquement affecté à la racine du menu et non comme enfant d’un autre lien.
  • la clef optionnelle weightn’ayant pas été précisée, le lien sera placé parmi les autres par ordre alphabétique.

Si vous aviez déjà activé le module dans les articles précédents, n’oubliez pas de vider les caches (à l’adresse : /admin/config/development/performance).

Le résultat est l’ajout de notre lien dans le menu Tools de Drupal 8.

 

drupal3

Notre lien est ajouté dans le menu Tools de Drupal 8.

 

En résumé…

Un lien se crée via l’usage du Menu API de Drupal 8. Grâce à cette API votre lien se définit simplement via une configuration YAML dans un fichier nommé $module.links.menu.yml placé à la racine du module.

Drupal est un CMS modulaire : il permet à des modules d’étendre les fonctionnalités de Drupal afin de créer des sites et des fonctionnalités toujours plus complexes. Un module se présente sous la forme d’un simple dossier, regroupant différents fichiers contenant son code informatique. Si vous lisez cet article, c’est que vous avez certainement déjà utilisé Drupal 8 et vous savez donc que le dossier du module doit se placer dans un répertoire modules de Drupal : à la racine ou dans sites/monsite.url pour les installations multi-sites.

Pour qu’un tel dossier soit reconnu comme un module compatible par Drupal 8, un certain nombre de conventions doivent être respectées :

  • Le nom donné au dossier contenant le module doit être lenom_machine_du_module.
  • Le dossier doit contenir un fichiermodule : un fichier contenant du code PHP (qui peut être vide si votre module ne fait rien).
  • Le dossier doit contenir un fichierinfo.yml : un fichier respectant la syntaxe YAML et definissant le module.

La présence de ce fichier descriptif .info.yml permet :

  • De notifier à Drupal l’exitence de votre module.
  • De fournir à Drupal les informations essentielles de votre module, en vue de son administration via l’interface de gestion des modules de votre site Drupal.
  • De fournir les conditions d’activation / désactivation de votre module (en terme de dépendances par exemple).

Choisir le nom du module

Le nom_machine du module est un nom unique – et propre à chaque module – qui permettra à Drupal de disciminer les modules les uns des autres. Ce nom doit être écrit en minuscule et ne doit pas comporter d’espaces, de ponctuations ou de caractères spéciaux à l’exception de l’underscore (le symbole “_”). De plus, ce nom doit être unique et propre à chaque module, c’est à dire que vous devez être certain qu’aucun autre module Drupal ne possède déjà ce nom là : ceci est important pour assurer la compatibilité entre les modules.

Astuce pour choisir un nom de module :

  • Choisissez un nom significatif pour votre module, en rapport avec ce qu’il fait.
  • Transformez ce nom ennom_machine en l’écrivant en minuscule, en remplaçant les espaces par des “_” et en enlevant les accents.
  • Pour vérifier que ce nom n’existe pas déjà, rendez-vous à l’URL:http://drupal.org/project/le_nom_choisi. Si cette page existe, c’est que le_nom_choisi existe déjà. Sinon, vous pouvez le prendre !

Décrire le module

Les informations de base du module doivent être placées à la racine du module dans un fichier dont l’extension est .info.yml, et dont le nom sera le nom machine choisi pour le module. Si votre module a pour nom machine mon_super_module, ce fichier de description se nommera donc mon_super_module.info.yml. Il utilisera la syntaxe dite YAML pour décrire les informations pertinentes à Drupal à propos du module. Dans cette syntaxe, les informations sont représentées par le couple clef : valeur.

Ci-dessous se trouve la liste des informations prises en compte par Drupal pour un module :

  • name(obligatoire)
  • description(recommandé)
  • core(obligatoire)
  • type(obligatoire)
  • dependencies
  • package
  • php
  • configure
  • required
  • hidden
  • project status url (à éviter : seulement pour les modules contributeurs non proposés via Drupal.org)

Voici une description détaillée de chacun de ces champs :

name (obligatoire)

Ce champ définit le nom du module tel qu’il apparaîtra sur la page d’administration des modules de votre site Drupal. Il s’agit d’un nom pour les humains et non d’un nom machine (donc pas mon_super_module). En tant que nom, la convention Drupal est d’utiliser des majuscules à chaque mot (Mon Super Module au lieu de Mon super module). Evidemment, si le titre de votre module contient des acronymes (CSS, XML, WYSIWYG) ou des références à des librairies ou technologies existantes (JQuery, JavaScript) celles-ci seront écrites selon leur convention habituelle.

name: Mon Super Module

description (recommandé)

Une courte description – de préférence d’une ligne – indique à l’administrateur d’un site Drupal ce que ce module permet. Ce champ est limité à 255 caractères, mais rappelez-vous : plus les descriptions sont longues, plus la page d’administration des modules est surchargée. Gardez donc cette description concise. Notez aussi que cette description peut contenir des liens, par exemple vers une documentation en ligne plus complète.

description: Ce module affiche l’heure sur chaque page de votre site (<a href=”http://mon-super-module.com”>plus d’infos</a>).

core (obligatoire)

Ce champ définit le numéro de version de Drupal pour laquelle est fait ce module. Par exemple pour Drupal 8, la valeur de ce champ sera 8.x. Le numéro mineur de version n’est pas à préciser ; 8.1 n’est donc pas une valeur correcte.

core: 8.x

type (obligatoire)

Ce champ est nouveau dans Drupal 8. Il définit le type d’extension décrite par le fichier actuel : les trois valeurs possibles sont donc moduletheme ou profile. Vous l’avez compris : dans le cadre d’un module, ce sera la valeur module qu’il faudra choisir !

type: module

dependencies (optionnel)

Ce champ facultatif liste les modules dont dépend éventuellement ce module. Si ces dépendances ne sont pas présentes, le module ne pourra pas être activé. Dans le cas où les dépendances sont présentes mais non activées, l’administrateur sera notifié de la liste des dépendances qui seront automatiquement activées durant l’installation de ce module et pourra choisir d’annuler son installation s’il le souhaite.

Chaque nouvelle dépendance doit être notée à la ligne derrière un tiret indenté, conformément à la syntaxe YAML. Chaque dépendance doit être un nom machine de module : les accents, espaces et ponctuations sont donc interdits.

dependencies:
– taxonomy
– comment

Il est possible d’indiquer des dépendances vers une version particulière d’un module. Ces numéros de versions sont optionnels et ont pour syntaxe (majeur.mineur). La lettre x peut être utilisée pour remplacer n’importe quelle version mineure. Voici quelques exemples :

dependencies:
– module_1 (1.x)
– module_2 (>8.x-2.15)

Notez que les numéros de versions peuvent être précédés d’un symbole de test parmi les suivants :

  • = ou == : pour imposer un version particulière. Ce symbole optionnel est la valeur par défaut du test.
  • > : plus grand que
  • >= : plus grand ou égal à
  • < : inférieur à
  • <= : inférieur ou égal à
  • != : différent de

Plusieurs tests peuvent être précisés en les séparant par des espaces. Dans l’exemple ci-dessous, notre module dépendra du module exampleapi de n’importe quelle version après la 1.0 et jusqu’à la version 3.2 incluse, à l’exception de la 3.0 :

dependencies:
– exampleapi (>1.0, <=3.2, !=3.0)

Enfin, notons qu’il est possible pour un module de dépendre d’une version particulière de Drupal Core. Dans ce cas, le mot-clef system est utilisé pour symboliser Drupal. Dans l’exemple ci-dessous, le module dépend d’une fonctionnalité apparue dans la version 8.2 de Drupal :

dependencies:
– system (>=8.2)

package (optionnel)

Si votre module fait partie d’un ensemble de plusieurs modules ou s’il étend un ensemble cohérent de modules, le mot clef package peut être utilisé pour les rassembler au sein d’un même groupe. Si l’option n’est pas utilisée, le module sera placé dans la catégorie Other (Autre) sur la page d’administration des modules. Cette option n’est à utiliser que par des ensembles importants de modules, ou par des modules étendant les fonctionnalités de groupes existants tels que FieldsViewsCommerceOrganic GroupsVoting, etc… Dans les autres cas, cette option ne doit pas être utilisée. A titre indicatif, un groupement de quatre modules (ou plus) est un bon début pour songer à créer un package.

Notez que la casse est importante : le package fields n’est pas le même que Fields. A ce titre il convient d’utiliser les conventions de nommage Drupal en ajoutant une majuscule à chaque mot comme par exemple Organic Group. N’utilisez pas de signe de ponctuation.

package: Organic Group

Voici quelques exemples de groupes existants :

  • Administration
  • Commerce
  • Development
  • Fields
  • Media
  • User interface
  • Views
  • Voting(si votre module requière VotingAPI)

Un listing (non officiel) tentant de référencer les packages existants est disponible sur cette page : https://groups.drupal.org/node/97054.

php (optionnel)

Pour un module donné, il est possible de spécifier la version minimale de PHP requise pour son fonctionnement. Cela s’explique par certains modules nécessitant des capacités de PHP apparues dans des versions ultérieures à celle officiellement compatible avec Drupal. Cette option ne doit être utilisée que si votre module à besoin d’une version PHP plus récente que la version officiellement supportée par Drupal. Dans les autres cas, cette option ne doit pas être présente.

php: 5.4

configure (optionnel)

Cette option indique la route vers la page de configuration principale de votre module. Lorsqu’un module est activé, des liens contextuels lui sont automatiquement crées sur la page d’administration des modules. Ces liens sont : “droits” dans le cas où le module utilise le système de permission de Drupal pour son fonctionnement, “configuration” dans le cas où le module définie via cet option un lien vers sa page de configuration. En ne remplissant pas cette option, le lien “configuration” ne sera pas crée pour ce module.

Notez que depuis Drupal 8, ce n’est plus le lien en terme d’url mais le nom de la route – telle qu’elle apparaît dans le fichier .routing.yml du module – qui doit être utilisé.

configure: action.admin

required (optionnel)

Cette option définit que ce module ne devrait jamais être désactivé. Une fois installé, il ne peut donc plus être désinstallé. Cette option est généralement utilisée pour des modules Core de Drupal.

Notez que vous devez utilisez cette option uniquement pour la passer à TRUE. Dans ce cas inverse, vous n’en avez tout simplement pas besoin.

required: TRUE

hidden (optionnel)

Cette option permet de cacher son module aux yeux de Drupal. En passant cette option à TRUE, le module ne s’affichera pas sur la page de configuration des modules de Drupal. Par conséquent, un utilisateur lambda ne pourra pas l’installer. N’utilisez cette option que pour la passer à TRUE et ainsi cacher le module : elle n’est pas nécessaire dans le cas inverse. De manière générale, cette option peut permettre de cacher des sous-modules de tests éventuels afin de ne pas encombrer et embrouiller l’affichage d’administration des modules.

hidden: TRUE

project status url (seulement pour les modules non contribués)

Cette option permet de définir une URL personnalisée pour la vérification de mises à jour du module, par le mécanisme du module core Update Status. Ceci est automatiquement ajouté pour tous les modules proposés sur drupal.org. Cette option n’est donc à utiliser que si vous maintenez votre propre dépôt de mises à jour. Dans ce cas, l’URL que vous définissez doit pointer vers un domaine acceptant les requêtes de la forme : http://my.domain.com/projects/{project}/{core}. Avec cet exemple, l’URL à définir serait : http://my.domain.com/projects.

project status url: http://my.domain.com/projects

 

 

Categories: Non classé