Planète

Par lequipe.tech
L'Équipe.tech

Ajouter un formulaire à une entité existante

Problématique

Dans notre Drupal, nous avons une entité composée de plusieurs champs mais ne souhaitons pas qu'ils soient tous renseignés via le même formulaire ? 2 solutions s'offrent à nous :

La première est de créer notre controller, créer notre formulaire et gérer le chargement et l'enregistrement des données.
La seconde est d'altérer la définition de l'entité pour rajouter notre formulaire.

Nous conviendrons rapidement que la première méthode n'est pas la plus appropriée eu égard aux bonnes pratiques Drupal. De même, l'effort à fournir par le second cas sera moindre par rapport au premier. Pourquoi tout reconstruire alors que l'on peut utiliser les mécanismes existants ?

Voyons comment réaliser cela via un cas pratique : nous avons une entité 'user' pour laquelle nous souhaitons avoir un formulaire d'édition générale (e-mail / mot de passe) et un formulaire pour qu'il renseigne ses informations personnelles (nom / prénom / adresse).

Création du nouvel affichage de formulaire

Dans un premier temps, allons créer un nouvel affichage de formulaire.

Aller sur la page d'administration de l'affichage de notre type d'utilisateur /admin/config/people/accounts/form-display.
Ajouter un affichage de formulaire 'personal'.
N'y placer que les champs (que nous aurons préalablement créés) nom, prénom, adresse.
Dans l'affichage du formulaire par défaut, retirer ces 3 champs de l'affichage.

Nous avons maintenant un nouvel affichage de formulaire, sauf que celui-ci n'est utilisé nulle part.

Nous allons donc créer une nouvelle définition de route pour y accéder.

Accéder au nouvel affichage de formulaire

Dans le fichier de routing de notre module custom (MONMODULE) : MONMODULE.routing.yml, ajouter une nouvelle route :

MONMODULE.user.personal_form:
path: '/user/{user}/personal_form'
defaults:
_entity_form: user.personal
_title: Personal infromations
requirements:
_entity_access: user.update
user: \d+
options:
_admin_route: FALSE

 

Voyons en détail à quoi servent ces lignes :

# Nom de la route.
MONMODULE.user.personal_form:
# Chemin vers la route. On reprend le chemin d'un user, {user} permet de définir que l'on souhaite utiliser un jeton correspondant à notre entité user.
path: '/user/{user}/personal'
defaults:
# Cette route pointe vers un formulaire d'entité de l'entité user avec l'affichage de formulaire que nous venons de créer : personal.
_entity_form: user.personal
_title: Personal infromations
requirements:
# Par mesure de sécurité, l'utilisateur doit avoir les droits d'accès de l'entité user.update (identique à l'édition normale d'une entité user).
_entity_access: user.update
# Définition des règles de validation de notre token user.
user: \d+
options:
# Cette route n'est pas une route admin (FALSE par défaut).
_admin_route: FALSE

 

On vide les caches, et nous pouvons maintenant accéder à notre formulaire qui ne contiendra que les champs voulus.

Modifier le formulaire

Si l'on souhaite modifier le formulaire existant pour par exemple y ajouter le rendu de notre utilisateur avant les champs d'édition et ajouter un message informatif, nous allons modifier la définition de l'entité user pour y ajouter une nouvelle classe de gestion de notre formulaire.

Dans le fichier MONMODULE.module, créer la méthode MONMODULE_entity_type_alter() ou y ajouter la ligne suivante :

/**
* Implements hook_entity_type_alter().
*/
function MONMODULE_entity_type_alter(array &$entity_types) {
$entity_types['user']->setFormClass('personal', 'Drupal\MONMODULE\Form\UserPersonalForm');
}

 

et créons dans src/Form/UserPersonalForm notre nouvelle classe qui hérite de AccountForm.

namespace Drupal\MONMODULE\Form;

use Drupal\Core\Form\FormStateInterface;
use Drupal\user\AccountForm;

/**
* Class UserPersonalForm.
*
* @package Drupal\MONMODULE\Form
*/
class UserPersonalForm extends AccountForm {

/**
* {@inheritdoc}
*/
public function form(array $form, FormStateInterface $form_state) {
// Chargement de l'entité en cours pour pouvoir générer son affichage.
$user = $this->getEntity();

$user_view = $this->entityTypeManager->getViewBuilder('user')->view($user, 'default');
$user_view['#attributes'] = [
'class' => ['user-default-infos'],
];
$form['user_view'] = $user_view;

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

// Nous pouvons ici modifier le formulaire comme bon nous semble.

return $form;
}

/**
* {@inheritdoc}
*/
public function validateForm(array &$form, FormStateInterface $form_state) {
parent::validateForm($form, $form_state);
// Nous pouvons faire ici nos propres validations.
}

/**
* {@inheritdoc}
*/
public function submitForm(array &$form, FormStateInterface $form_state) {
parent::submitForm($form, $form_state);
// Nous pouvons faire ici des actions à la suite de la soumission.
}

/**
* {@inheritdoc}
*/
protected function actions(array $form, FormStateInterface $form_state) {
$element = parent::actions($form, $form_state);

// Nous pouvons ici modifier les éléments d'action (boutons).

return $element;
}

}

 

Ajouter un template de lien

Il y a une définition d'entité très pratique et simple à utiliser pour gérer des liens d'entités, il s'agit des templates de lien. On les retrouve par exemple dans l'annotation de notre entité user :

* links = {
* "canonical" = "/user/{user}",
* "edit-form" = "/user/{user}/edit",
* "cancel-form" = "/user/{user}/cancel",
* "collection" = "/admin/people",
* },

 

L'avantage de ces templates de liens est de pouvoir générer un lien à partir de l'entité plutôt que de devoir instancier le générateur de route, et de devoir lui passer tous les paramètres.

// Via le générateur de route.
$url = \Drupal::service('url_generator')->generateFromRoute('entity.user.edit_form', ['user' => $user]);
// Via le template de lien.
/** @var \Drupal\user\Entity\User $user */
$url = $user->url('edit-form');

 

Vu que nous avons ajouté notre formulaire personal, nous pouvons également définir un template de lien pour celui-ci.

Dans notre fichier MONMODULE.module, ajouter la ligne suivante au hook MONMODULE_entity_type_alter().

/**
* Implements hook_entity_type_build().
*/
function MONMODULE_entity_type_alter(array &$entity_types) {
$entity_types['user']->setFormClass('personal', 'Drupal\MONMODULE\Form\UserPersonalForm');
$entity_types['user']->setLinkTemplate('personal-form', '/user/{user}/personal');
}

 

Ce qui nous permettra également de générer nos liens de la sorte :

/** @var \Drupal\user\Entity\User $user */
$url = $user->url('personal-form');

Par Kgaut
Adhérent
Kevin Gautreau

Drupal 8 - rendre un formulaire dans un template

La form api de drupal est très puissante, mais pour jouer avec le markup html avec les #prefix et #suffix peut s'avérer rapidement complexe en plus d'être un peu sale au niveau du code.

Dans drupal 8 il est possible de facilement utiliser un template pour un formulaire. Pour cela il faut se baser sur le nom machine du formulaire.

Cela fonctionne pour nos formulaires custom, mais aussi pour les formulaires des modules tiers ou du core. Je vais ici utiliser un template pour le formulaire user_form qui correspond au formulaire de modification du compte utilisateur. Le nom machine de ce formulaire est user_form.

Définition du template :

Fichier : mon_module.module

  1. function mon_module_theme() {
  2. $theme = [];
  3. $theme['user_form'] = [
  4. 'render element' => 'form',
  5. ];
  6. return $theme;
  7. }

J'utilise comme clé de thème le nom machine du formulaire.

Je peux ensuite créer dans le dossier templates de mon thème le fichier user_form.html.twig :

  1. Test

  2. {{ form }}
  3. On peut rendre des champs « manuellement », mais il ne faut pas oublier de rendre le formulaire form à la fin : 

    1. Test

    2. {{ form.mon_champ_1 }}
  4. {{ form.mon_champ_2 }}
  • {{ form | without('mon_champ_1', 'mon_champ_2') }}
  •  

  • Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - Créer un Event, le lancer et l'intercepter

    Dans Drupal 8, le principe des hooks a été remplacé par un système d'évènement qui est lancé et peut être intercepté, cela se passe en 3 étapes :

    1. Création de l'évènement (classe étendant la classe Event)
    2. Lancer l'évènement
    3. Interception de l'évènement (Classe étendant l'interface EventSubscriberInterface)

    Pour cette évènement, nous allons prendre le contexte de mon site de pronostics sportifs. Je veux lancer un évènement quand un utilisateur fait ses pronostics

    Création de l'évènement

    Fichier : mon_module/src/Event/UserBetEvent.php

    1.  
    2. namespace Drupal\mon_module\Event;
    3.  
    4. use Drupal\mespronos\Entity\Day;
    5. use Drupal\user\UserInterface;
    6. use Symfony\Component\EventDispatcher\Event;
    7.  
    8. class UserBetEvent extends Event {
    9.  
    10. const EVENT_NAME = 'mespronos_user_bet';
    11.  
    12. /**
    13.   * The user account.
    14.   *
    15.   * @var \Drupal\user\UserInterface
    16.   */
    17. public $account;
    18.  
    19. /**
    20.   * The Day the user has bet on
    21.   *
    22.   * @var Day
    23.   */
    24. public $day;
    25.  
    26. public function __construct(UserInterface $account, Day $day) {
    27. $this->account = $account;
    28. $this->day = $day;
    29. }
    30.  
    31. }

    Cette classe est relativement simple, on défini les attributs que l'on veut rendre disponibles lors de l'interception de cet évènement, ici, l'objet User de l'utilisateur qui aura pronostiqué et la journée ($day) de compétition sur laquelle il aura fait ses pronostics.

    Dispatch de l'évènement

    Le code suivant est à placer là où vous souhaiter lancer l'évènement, dans mon cas il s'agit de la méthode submit de mon formulaire de pronostics :

    1. $event = new UserBetEvent($user, $day);
    2. $event_dispatcher = \Drupal::service('event_dispatcher');
    3. $event_dispatcher->dispatch(UserBetEvent::EVENT_NAME, $event);

    Évidement, il ne faut pas oublier de passer les paramètres que l'on a défini dans le constructeur de notre évènement (ici $user et $day)

    Interception de l'évènement

    Définition du subscriber

    Fichier : mon_autre_module/mon_autre_module.services.yml

    1. mon_autre_module.mespronos_user_bet:
    2.   class: 'Drupal\mon_autre_module\EventSubscriber\UserBetSubscriber'
    3.   tags:
    4.   - { name: 'event_subscriber' }

    Code du subscriber

    Fichier : mon_autre_module/src/EventSubscriber/UserBetSubscriber.php

    1.  
    2. namespace Drupal\mon_autre_module\EventSubscriber;
    3.  
    4. use Drupal\mespronos\Event\UserBetEvent;
    5. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
    6.  
    7. class UserBetSubscriber implements EventSubscriberInterface {
    8.  
    9. public function onBet(UserBetEvent $event) {
    10. // On peut récuperer les attributs de l'évènement
    11. $user = $event->account;
    12. $day = $event->day;
    13.  
    14. // À vous de faire ce que vous voulez ici
    15. }
    16.  
    17. public static function getSubscribedEvents() {
    18. // Définition du ou des évènements que l'on écoute et méthode à executer
    19. return [
    20. UserBetEvent::EVENT_NAME => 'onBet',
    21. ];
    22. }
    23.  
    24. }

     

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - rejouer une fonction d'update

    Drupal tient un registre des versions des modules installés, ces versions correspondent au dernier numéro du hook_update exécuté du module.

    Si par exemple vous venez de lancer le hook 8301 du module field_group et que vous souhaitez le relancer, alors il faudra passer le module en version 8300.

    Voila comment faire avec drush :

    1. drush ev "drupal_set_installed_schema_version('field_group', 8300)"

     

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - Exemple d'utilisation simple du cache

    Drupal 8 propose un système de cache très puissant et à plusieurs niveaux.

    Ici nous allons voir comment stocker simplement le résultat d'une requête en cache afin de ne pas avoir à la lancer la requête SQL à chaque appel.

    Commençons par définir notre « conteneur » de cache dans le fichier mon_module.services.yml :

    1. cache.mon_module:
    2.   class: Drupal\Core\Cache\CacheBackendInterface
    3.   tags:
    4.   - { name: cache.bin }
    5.   factory: cache_factory:get
    6.   arguments: [mon_module]

    mon_module sera le nom de notre conteneur de cache.

    Cela permettra de distinguer les données que nous mettrons dedans et de ne pas écraser d'autres caches d'autres modules. Si vous utilisez le cache en base de données (par défaut) vous verrez qu'une nouvelle table cache_mon_module a été créée.

    Ensuite voici un exemple de lecture du cache, et d'écriture si la donnée n'est pas présente :

    1. public function getVersion() {
    2. // On teste si la clé « database.version » est présente dans le conteneur de cache « mon_module »
    3. if ($results = \Drupal::cache('mon_module')->get('database.version')) {
    4. // Si c'est le cas, les données stockées sont dans l'attribut « data »
    5. return $results->data;
    6. }
    7. // Sinon on effectue la requête désirée
    8. $version = $this->connection->select('version', 'v')->fields('v', ['version'])->execute()->fetch();
    9. // Et on met la valeur en cache
    10. \Drupal::cache('mon_module')->set('database.version', $version->version);
    11.  
    12. return $version->version;
    13. }

    Il est possible aussi de donner date d'expiration afin que cette clé de cache ne soit plus valable une fois cette date passée :

    1. // cache valable 1 h (3600 secondes)
    2. \Drupal::cache('mon_module')->set('database.version', $version->version, date('U') + 3600);

     

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal - Drush - Appeler un script php et lui passer un argument

    Il est possible via drush d’exécuter un script php et de profiter de toute l'API de drupal pour effectuer des traitements (création / suppression de contenu, modification, import de traductions...)

    On utilise pour cela la commande drush php-script en lui passant le chemin vers le script relatif à la racine de drupal :

    1. # Exemple d'appel d'un script
    2. drush @alias php-script ../scripts/process/import-translations.php

    Mais il est aussi possible de passer des arguments à ce script :

    1. #Je passe ici le chemin vers le fichier à importer
    2. drush @alias php-script ../scripts/process/import-translations.php --file=../files/translations/imports/2019-05-14-translations.csv

    Et voici comment le récupérer dans notre script drush :

    1. # Récupération du paramètre file
    2. $file = drush_get_option('file');

    À noter que l'on peut aussi fournir une valeur par défaut :

    1. # ici, si --lang n'est pas passé lors de l'appel du script
    2. # alors $lang prendra la valeur « en »
    3.  
    4. $lang = drush_get_option('lang', 'en');

     

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - Se connecter à une base de données tierce

    Outre la base de données « classique » de drupal, il est aussi possible de se connecter à une autre base de données.

    Pour cela dans le fichier de settings il faut définir les identifiants :

    1. $databases['seconde_db'] = $databases['default'];
    2. $databases['seconde_db']['default']['host'] = 'HOST_SECONDE_DB';
    3. $databases['seconde_db']['default']['database'] = 'SECONDE_DB';
    4. $databases['seconde_db']['default']['username'] = 'USER_SECONDE_DB';
    5. $databases['seconde_db']['default']['password'] = 'PASSWORD_SECONDE_DB';

    Ensuite dans le code de notre drupal on peut sélectionner cette seconde base de données :

    1. # On sélectionne la base secondaire
    2. Database::setActiveConnection('seconde_db');

    Pour ensuite effectuer les requêtes que l'on souhaite, via la database API de drupal.

    Attention à la fin ne pas oublier de rebasculer sur la base de données par défaut afin de ne pas casser tout le drupal :

    1. # On bascule sur la base de données par défaut
    2. Database::setActiveConnection();

     

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Créer des liens de menus dynamiquement

    L'élément, selon moi, le plus important d'un site web est la qualité de ses menus. Comme il est possible d'arriver par n'importe quelle page sur un site, il est donc important que l'internaute puisse y naviguer de façon simple et fluide. Voici comment gérer une partie de vos menus dynamiquement sous Drupal 8.

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Créer des liens de menus dynamiquement

    L'élément, selon moi, le plus important d'un site web est la qualité de ses menus. Comme il est possible d'arriver par n'importe quelle page sur un site, il est donc important que l'internaute puisse y naviguer de façon simple et fluide. Voici comment gérer une partie de vos menus dynamiquement sous Drupal 8.

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Optimiser les tâches lourdes de composer avec Drupal

    Une petite dépendance à ajouter à son composer.json qui permet d'économiser pas mal de ram lors des taches lourdes de composer (update notamment)

    1. composer require zaporylie/composer-drupal-optimizations:^1.1

    Simplement en supprimant des anciens tags des package de symfony, cela peut diviser par deux la mémoire vive nécessaire.

    Plus d'informations : https://github.com/zaporylie/composer-drupal-optimizations

     

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Lors d'une manipulation

    Lors d'une manipulation de formulaire, il est assez fréquent de vouloir la main sur la structure HTML. Par défaut les champs s'affichent les uns en dessous des autres avec uniquement le balisage des éléments du formulaire.

    Pour gérer facilement la structure HTML d'un Form sous Drupal 8, il faut se tourner vers les thèmes ...

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Lors d'une manipulation

    Lors d'une manipulation de formulaire, il est assez fréquent de vouloir la main sur la structure HTML. Par défaut les champs s'affichent les uns en dessous des autres avec uniquement le balisage des éléments du formulaire.

    Pour gérer facilement la structure HTML d'un Form sous Drupal 8, il faut se tourner vers les thèmes ...

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Lors d'une manipulation

    Lors d'une manipulation de formulaire, il est assez fréquent de vouloir la main sur la structure HTML. Par défaut les champs s'affichent les uns en dessous des autres avec uniquement le balisage des éléments du formulaire.

    Pour gérer facilement la structure HTML d'un Form sous Drupal 8, il faut se tourner vers les thèmes ...

    Mettre en place un système de notifications sur Drupal 8

    Pour bon nombre de projets Drupal 8 qui disposent d'un minimum d'interactions avec ses utilisateurs, le besoin de mettre en place un système de notifications arrive rapidement sur le devant de la scène. Etre notifié d'un nouveau commentaire, d'une réponse à un commentaire, d'une nouvelle publication sur tel ou tel sujet, ou de tel utilisateur, sont des besoins récurrents. Découvrons le module Entity Activity dont la vocation est de journaliser tout type d'action effectuée, sur tout type d'entité de contenu, par utilisateur, selon ses abonnements, sur un projet.

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - Migrate - Aide mémoire

    Afficher la liste des destinations de migration :

    drupal debug<span class="sy0">:</span>plugin migrate<span class="sy0">.</span>destination

     

    Par Mixalis44
    Mickael Zafiriou
    Développeur Drupal depuis 2013.

    Personaliser le rendu d'un formulaire sous Drupal 8

    Lors d'une manipulation de formulaire, il est assez fréquent de vouloir la main sur la structure HTML. Par défaut les champs s'affichent les uns en dessous des autres avec uniquement le balisage des éléments du formulaire.

    Pour gérer facilement la structure HTML d'un Form sous Drupal 8, il faut se tourner vers les thèmes ...

    Par Kgaut
    Adhérent
    Kevin Gautreau

    Drupal 8 - Créer un fichier avec le « résultat » d'un template

    Voici comment écrire un fichier dans drupal 8 :

    1. $sitemaps_path = 'public://sitemaps/';
    2. // création du dossier
    3. if(file_prepare_directory($sitemaps_path, FILE_CREATE_DIRECTORY)) {
    4. // écriture du fichier (s'il existe, on le remplace)
    5. file_save_data($content, $sitemaps_path . 'sitemap.xml', FILE_EXISTS_REPLACE);
    6. }
    7. else {
    8. \Drupal::logger('sitemap')->error(t('Problem creating the folder @folder', ['@folder' => $sitemaps_path]));
    9. }

    Imaginons que l'on veuille écrire dans un fichier le contenu d'un renderable array voici comment l'on définit $content :

    1. $datas = [
    2. '#theme' => 'xml_sitemap',
    3. '#urls' => [
    4. ['title' => 'test'],
    5. ['title' => 'test 2'],
    6. ],
    7. ];
    8.  
    9. // Ici si on ne peut pas utiliser l'injection de dépendance, on pourrait remplacer la ligne suivante par :
    10. // \Drupal::service('renderer')->renderPlain($datas);
    11. $content = $this->renderer->renderPlain($datas);

     

    Pages