Construire un module Drupal 8: blocs et formulaires

Points de base

• Drupal 8 introduit un nouveau concept de blocs en tant que plugin, ce qui leur permet d'être réutilisé sur tout le site. Les blocs peuvent être créés dans l'interface utilisateur et utilisés plusieurs fois.
• Dans Drupal 8, vous pouvez créer un bloc personnalisé qui renvoie du texte configurable. Cela peut être fait en créant un nouveau type de bloc dans l'interface utilisateur et en le réutilisant sur tout le site.
• Drupal 8 permet d'ajouter des formulaires de configuration aux blocs. Cela permet à l'utilisateur de modifier le bloc, de spécifier un nom dans le champ de texte, et le bloc affichera ensuite une salutation à ce nom.
• Le développement du module Drupal 8 implique la création d'une forme simple. Les fonctions de définition de formulaire sont regroupées dans une classe. Les valeurs de formulaire soumises sont simplement imprimées à l'écran pour montrer comment elles fonctionnent.
• Dans Drupal 8, vous pouvez créer des formulaires personnalisés en définissant des classes de formulaires dans des modules personnalisés. La classe de formulaire doit prolonger la classe "Formbase" et implémenter trois méthodes: "getFormID ()", "buildForm ()" et "soumeForm ()".

Notez que certaines pièces de code peuvent être obsolètes en raison du processus de développement continu de Drupal 8 au moment de la rédaction. Veuillez consulter ce référentiel, j'ai essayé de mettre à jour l'exemple de code et de le faire fonctionner avec la dernière version Drupal 8.

Dans la première partie de cette série, nous commençons par les bases et apprenons le développement du module Drupal 8. Nous avons appris comment Drupal comprend les fichiers requis par notre module, le fonctionnement du processus de routage et la façon de créer des liens de menu par programmation de manière par programme.

Dans ce tutoriel, nous allons en outre regarder les modules de bac à sable trouvés dans ce référentiel et examiner deux fonctionnalités importantes: les blocs et les formulaires. Pour ce faire, nous créerons un bloc personnalisé qui renvoie un texte configurable. Après cela, nous créerons une forme simple pour imprimer les valeurs soumises par l'utilisateur à l'écran.

DRUPAL 8 Bloc

Un nouveau changement sympa de l'API de bloc en D8 est de rendre les blocs plus importants en les faisant de plugins (un tout nouveau concept). Cela signifie que ce sont des fonctionnalités réutilisables (en arrière-plan), car vous pouvez désormais créer un bloc dans l'interface utilisateur et le réutiliser sur tout le site - vous n'êtes plus limité à l'utilisation de blocs une seule fois.

Créons un type de bloc simple qui s'imprimera à l'écran par défaut Bonjour Monde! . Nous devons seulement utiliser un fichier de classe dans le dossier SRC / Plugin / Block situé dans la racine du module. Normons notre nouveau type de bloc Demoblock, bien sûr, il doit être dans un fichier nommé DeMoblock.php. Dans ce fichier, nous pouvons commencer par ce qui suit:

<code class="language-php"><?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}</code>

Comme tous les autres fichiers de classe, nous avons un premier espace de nom de notre classe. Ensuite, nous utilisons la classe Blockbase afin que nous puissions l'étendre et la classe AccountInterface afin que nous puissions accéder à l'utilisateur actuellement connecté. Vient ensuite quelque chose que vous n'avez certainement pas vu dans Drupal 7: Commentaires.

Les annotations sont des outils de découverte PHP situés dans des blocs de commentaires dans des fichiers qui sont les mêmes que les définitions de classe. En utilisant ces annotations, nous faisons savoir Drupal que nous voulons enregistrer un nouveau type de bloc (@block) avec l'ID Demo_Block et l'administration_label avec

Block de démonstration (passé par le système de traduction).

Ensuite, nous étendons la classe de blockbase à notre propre Demoblock, où nous implémentons deux méthodes (les méthodes les plus courantes que vous implémenterez). La méthode build () est la plus importante car elle renvoie le tableau rendu que le bloc imprimera. La méthode Access () contrôle l'accès pour afficher ce bloc. L'argument qui lui est transmis est une instance de la classe AccountInterface, auquel cas il s'agit de l'utilisateur actuel.

Une autre chose intéressante à noter est que nous n'utilisons plus la fonction t () globalement pour la traduction, mais nous référons plutôt à la méthode t () implémentée dans la classe parent de classe.

C'est tout, vous pouvez effacer le cache et accéder à la page de configuration de la disposition des blocs. Ce qui est cool, c'est que vous avez des types de blocs à droite (vous pouvez les filtrer à travers eux) où vous pouvez placer un ou plusieurs de ces types de blocs dans diverses zones du site.

Configuration du bloc Drupal 8

Maintenant que nous avons appris à créer un nouveau type de bloc à utiliser dans l'interface utilisateur, approfondissons l'API et y ajoutons des formulaires de configuration. Nous lui permettons de modifier le bloc, de spécifier un nom dans le champ de texte, et le bloc dira bonjour à ce nom, plutôt que de dire bonjour à

world .

Tout d'abord, nous devons définir un formulaire contenant nos champs de texte. Ainsi, dans notre classe Demoblock, nous pouvons ajouter une nouvelle méthode appelée BlockForm ():

<code class="language-php">/**
 * {@inheritdoc}
 */
public function blockForm($form, &$form_state) {

  $form = parent::blockForm($form, $form_state);

  $config = $this->getConfiguration();

  $form['demo_block_settings'] = array(
    '#type' => 'textfield',
    '#title' => $this->t('Who'),
    '#description' => $this->t('Who do you want to say hello to?'),
    '#default_value' => isset($config['demo_block_settings']) ? $config['demo_block_settings'] : '',
  );

  return $form;
}</code>

Cette implémentation de l'API de formulaire devrait ressembler très à Drupal 7. Cependant, il y a un nouveau contenu ici. Tout d'abord, nous récupérons le tableau de formulaire $ de la classe parent (nous construisons donc un formulaire existant en ajoutant nos propres champs). Des trucs OOP standard. Nous récupérons et stockons ensuite la configuration de ce bloc. La classe Blockbase définit la méthode getConfiguration () qui le fait pour nous. Nous plaçons la valeur Demo_Block_Settings en tant que #default_value au cas où il aurait été défini.

Ensuite, est le gestionnaire de soumission de ce formulaire, qui traitera la valeur de notre champ et le stockera dans la configuration du morceau:

<code class="language-php">/**
* {@inheritdoc}
*/
public function blockSubmit($form, &$form_state) {

 $this->setConfigurationValue('demo_block_settings', $form_state['values']['demo_block_settings']);

}</code>

Cette méthode est également située dans la classe Demoblock, et tout ce qu'il fait est d'enregistrer la valeur du champ Demo_Block_Settings en tant qu'élément dans la configuration de bloc (en utilisant le même nom que la clé pour la cohérence).

Enfin, nous devons ajuster notre méthode build () pour inclure le nom pour demander:

<code class="language-php"><?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}</code>

Jusqu'à présent, cela devrait sembler assez facile. Nous recherchons la configuration du bloc et l'utilisons pour l'instruction imprimée si la valeur de notre champ a été définie. Sinon, une déclaration commune est utilisée. Vous pouvez effacer le cache et le tester en modifiant les blocs que vous avez attribués à la zone et en ajoutant le nom que vous souhaitez demander. Une chose à noter est que vous avez toujours la responsabilité de nettoyer les entrées des utilisateurs lors de l'impression à l'écran. Pour Brivity, je n'ai pas inclus ces étapes.

DRUPAL 8 Form

La dernière chose que nous allons explorer dans ce tutoriel est de savoir comment créer une forme simple. En raison des limitations de l'espace, je ne couvrirai pas son aspect de gestion de la configuration (valeurs de configuration des magasins soumis via des formulaires). Au lieu de cela, je vais illustrer une définition de formulaire simple où la valeur soumise est simplement imprimée à l'écran pour montrer comment elle fonctionne.

Dans Drupal 8, les fonctions de définition de formulaire sont regroupées dans une classe. Définissons donc notre classe de démonstration simple dans SRC / Form / Demoform.php:

<code class="language-php">/**
 * {@inheritdoc}
 */
public function blockForm($form, &$form_state) {

  $form = parent::blockForm($form, $form_state);

  $config = $this->getConfiguration();

  $form['demo_block_settings'] = array(
    '#type' => 'textfield',
    '#title' => $this->t('Who'),
    '#description' => $this->t('Who do you want to say hello to?'),
    '#default_value' => isset($config['demo_block_settings']) ? $config['demo_block_settings'] : '',
  );

  return $form;
}</code>

En dehors de l'aspect OOP, tout devrait être très similaire à Drupal 7. L'API de formulaire a à peine changé (sauf pour ajouter de nouveaux éléments de forme et une telle encapsulation). Alors, que s'est-il passé ci-dessus?

Tout d'abord, nous espérons les noms de la classe et utilisons la classe Core Formbase afin que nous puissions l'étendre avec notre propre classe de démonstration. Ensuite, nous mettons en œuvre 4 méthodes, dont 3 devraient sembler très familières. La méthode getFormID () est nouvelle et obligatoire et n'est utilisée que pour retourner le nom de la machine du formulaire. La méthode buildform () est à nouveau obligatoire, ce qui construit le formulaire. comment ? Tout comme vous êtes habitué à Drupal 7. La méthode ValidateForm () est facultative et son objectif doit également être très clair à partir de D7. Enfin, la méthode Soumisform () effectue le traitement de la validation. Très logique et organisé.

Alors, que voulons-nous réaliser avec cette forme? Nous avons un champ de messagerie (un nouvel élément de formulaire dans Drupal 8) que nous voulons que l'utilisateur remplisse. Par défaut, Drupal vérifie si la valeur saisie est en fait une adresse e-mail. Mais dans notre fonction de vérification, nous nous assurons qu'il s'agit d'une adresse e-mail .com et si ce n'est pas le cas, nous définirons l'erreur de formulaire sur ce champ. Enfin, le gestionnaire de soumission imprime simplement un message sur la page.

La dernière chose que nous devons faire pour utiliser ce formulaire est de lui fournir un itinéraire. Alors modifiez le fichier démo.routing.yml et ajoutez ce qui suit:

<code class="language-php">/**
* {@inheritdoc}
*/
public function blockSubmit($form, &$form_state) {

 $this->setConfigurationValue('demo_block_settings', $form_state['values']['demo_block_settings']);

}</code>

Cela devrait être similaire à ce que nous avons acheminé des pages simples dans le post précédent. La seule différence significative est que par défaut, nous utilisons _form pour spécifier que la cible est la classe de formulaire. Par conséquent, la valeur est le nom de classe que nous venons de créer.

Effacer le cache et accéder à la démo / formulaire pour afficher le formulaire et le tester.

Si vous connaissez drupal_get_form () et que vous souhaitez savoir comment charger des formulaires comme vous l'avez fait dans Drupal 7 auparavant, la réponse est dans la classe Global Drupal. Donc, pour récupérer un formulaire, vous pouvez utiliser sa méthode Formbuilder () et procéder ce qui suit:

<code class="language-php"><?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}</code>

Vous pouvez ensuite retourner $ Form, qui sera un tableau rendu du formulaire.

Conclusion

Dans cet article, nous continuons d'explorer le développement du module Drupal 8 et d'introduire deux nouveaux sujets: les blocs et les formulaires. Nous avons appris à créer notre propre type de bloc, que nous pouvons utiliser pour créer des blocs dans l'interface utilisateur. Nous avons également appris à y ajouter des configurations personnalisées et à stocker des valeurs pour une utilisation ultérieure. En ce qui concerne les formulaires, nous avons vu une simple implémentation de la classe Formbase, que nous utilisons pour imprimer les valeurs soumises par l'utilisateur à l'écran.

Dans le prochain didacticiel, nous découvrirons rapidement le formulaire de configuration. Nous utiliserons le système de configuration Drupal 8 pour enregistrer les valeurs soumises par l'utilisateur. De plus, nous apprendrons les conteneurs de service et les injections de dépendance et comment ils fonctionnent dans Drupal 8. Rendez-vous alors.

Questions fréquemment posées sur la construction de modules Drupal 8: blocs et formulaires (FAQ)

Quelle est la structure de base du module Drupal 8?

Le module Drupal 8 est essentiellement un ensemble de fichiers contenant certaines fonctions et est écrit en PHP. La structure de base du module Drupal 8 comprend le fichier .info.yml, le fichier .module et d'autres fichiers facultatifs, tels que .css, .js, .twig, etc. Le fichier .info.yml est utilisé pour répertorier le nom, la description, le package, le type et la compatibilité du module. Le fichier .module est là où se trouve le code PHP réel.

Comment créer des blocs personnalisés dans Drupal 8?

La création d'un bloc personnalisé dans Drupal 8 implique la création d'un nouveau module personnalisé et la définition d'un plugin de bloc. Le plugin de bloc est un fichier de classe PHP qui définit les propriétés et les méthodes du bloc. Il doit être placé dans le répertoire "SRC / Plugin / Block" du module. La classe de plugin de blocs doit étendre la classe "blockbase" et implémenter la méthode "build ()", qui renvoie un tableau rendu de contenu de bloc.

Comment créer une forme personnalisée dans Drupal 8?

La création d'une forme personnalisée dans Drupal 8 implique la création d'un nouveau module personnalisé et la définition d'une classe de formulaire là-bas. La classe de formulaire est un fichier de classe PHP qui définit les propriétés et les méthodes du formulaire. Il doit être placé dans le répertoire "SRC / Form" du module. La classe de formulaire doit prolonger la classe "Formbase" et implémenter trois méthodes: "getFormID ()", "buildForm ()" et "soumeForm ()". La méthode "BuildForm ()" renvoie le tableau de formulaire et la méthode "soumisForm ()" gère la soumission de formulaire.

Comment afficher des blocs dans des zones spécifiques de mon site Drupal 8?

Pour afficher des blocs dans une zone spécifique du site Drupal 8, vous devez vous rendre sur la page de mise en page des blocs dans l'interface de gestion. Ici, vous pouvez attribuer votre bloc à n'importe quel domaine du sujet. Vous pouvez également configurer les paramètres de visibilité des blocs en fonction des chemins, des types de contenu, des rôles utilisateur, etc.

Comment vérifier l'entrée du formulaire personnalisé Drupal 8?

Pour vérifier l'entrée dans un formulaire personnalisé Drupal 8, vous pouvez remplacer la méthode "valideForm ()" dans la classe de formulaire. Lors de la soumission du formulaire, cette méthode est appelée avant la méthode "soumisForm ()". Dans la méthode "valideform ()", vous pouvez ajouter une logique de validation et appeler la méthode "seterror ()" pour définir le message d'erreur pour l'élément de formulaire (si la validation échoue).

Comment modifier une forme existante dans Drupal 8?

Pour modifier un formulaire existant dans Drupal 8, vous pouvez implémenter la fonction "hook_form_form_id_alter ()" dans le module. Cette fonction est appelée lors de la création d'un formulaire, qui vous permet de modifier le tableau de formulaire. "Form_ID" doit être remplacé par l'ID du formulaire que vous souhaitez modifier.

Comment soumettre par programme un formulaire dans Drupal 8?

Pour soumettre par programme un formulaire dans Drupal 8, vous pouvez créer une instance de la classe de formulaire et appeler la méthode "soumiForm ()". Cependant, avant d'appeler cette méthode, vous devez préparer un objet d'état de formulaire et définir la valeur de l'élément de formulaire.

Comment créer un formulaire de configuration dans Drupal 8?

Pour créer un formulaire de configuration dans Drupal 8, vous pouvez définir une classe de formulaire qui étend la classe "ConfigFormBase" au lieu de la classe "FormBase". La classe "configFormbase" fournit d'autres méthodes de traitement des données de configuration, telles que "getEditableConfignames ()" et "config ()". Les données de configuration sont stockées dans le système de configuration Drupal et sont accessibles à partir de n'importe où dans le code.

Comment créer une forme en plusieurs étapes dans Drupal 8?

Pour créer un formulaire en plusieurs étapes dans Drupal 8, vous pouvez utiliser l'objet FormStateInterface pour stocker les données entre les étapes. Dans la méthode "buildform ()", vous pouvez vérifier l'étape actuelle de l'état de formulaire et renvoyer un tableau de formulaire différent pour chaque étape. Dans la méthode "soumiseForm ()", vous pouvez vérifier l'étape actuelle, puis stocker les données et passer à l'étape suivante, ou traiter le commit final.

Comment créer une forme ajax dans Drupal 8?

Pour créer un formulaire ajax dans Drupal 8, vous pouvez ajouter l'attribut "#ajax" à l'élément de formulaire de la méthode "buildform ()". Cette propriété doit être un tableau qui spécifie la fonction de rappel à appeler lorsque l'élément est déclenché. La fonction de rappel doit renvoyer une partie du formulaire à mettre à jour ou un ensemble de commandes AJAX.

Cette sortie révisée maintient le format d'image d'origine et le placement tout en paraphrasant le contenu de l'originalité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!