Gestionnaire de soumission de formulaire Web personnalisé | AU NOUVEAU BLOG

Aperçu

Dans Drupal, un gestionnaire Webform est un composant du module Webform qui traite les soumissions de formulaires. Les gestionnaires de formulaires Web permettent aux développeurs d’étendre les fonctionnalités des formulaires Web en effectuant diverses actions ou intégrations lors de la soumission du formulaire.

Traitement des soumissions de formulaires

Lorsqu’un utilisateur soumet un formulaire Web, les données du formulaire sont transmises via une série de gestionnaires, qui peuvent effectuer diverses actions telles que l’envoi d’e-mails, le stockage de données, l’intégration avec des services externes, etc.

Exécution d’une logique personnalisée

Les gestionnaires peuvent exécuter une logique PHP personnalisée pour traiter les soumissions de formulaires d’une manière spécifique. Cela peut impliquer la validation des données, la manipulation ou tout autre traitement personnalisé nécessaire pour les données du formulaire.

Intégration avec des services tiers

Les gestionnaires peuvent intégrer des formulaires Web à des services externes tels que des systèmes CRM, des listes de diffusion, des plateformes d’analyse, etc. Cela permet aux développeurs d’automatiser les tâches et de rationaliser les flux de travail.

Implémentation de la logique métier

Les gestionnaires peuvent appliquer les règles métier et la logique liées aux soumissions de formulaires. Par exemple, un gestionnaire peut vérifier si certaines conditions sont remplies avant de poursuivre le traitement des données du formulaire.

Personnalisation et extensibilité

Les gestionnaires de formulaires Web fournissent un cadre flexible et extensible pour personnaliser le comportement des formulaires Web. Les développeurs peuvent créer des gestionnaires personnalisés pour implémenter des fonctionnalités spécifiques adaptées aux exigences de leur projet.

Création d’un gestionnaire de formulaire Web personnalisé

Vous devrez d’abord créer un nouveau module personnalisé ou disposer d’un module existant dans lequel vous souhaitez intégrer le gestionnaire.

Nous décrirons ici ce qui est nécessaire pour un module autonome.

Vous aurez besoin de la structure de dossiers suivante :

  ▾ modules/
    ▾ custom/
      ▾ ttn_custom_webform_handler/
        ▾ src/
          ▾ Plugin/
            ▾ WebformHandler/

Vous devrez ensuite ajouter le fichier du gestionnaire dans le répertoire WebformHandler. Dans ce cas, il s’appelle TothenewWebformHandler.php et a ce contenu :

<?php 
namespace Drupal\ttn_custom_webform_handler\Plugin\WebformHandler; 
use Drupal\Component\Utility\Xss; 
use Drupal\Core\Form\FormStateInterface; 
use Drupal\Core\Render\Markup; 
use Drupal\webform\Plugin\WebformHandlerBase; 
use Drupal\webform\WebformInterface; 
use Drupal\webform\WebformSubmissionInterface; 
use Symfony\Component\DependencyInjection\ContainerInterface; 

/** 
 * TTN Custom Webform Handler. 
 * 
 * @WebformHandler( 
 *   id = "ttn_webform_handler", 
 *   label = @Translation("TTN Webform Handler"), 
 *   category = @Translation("TTN Webform Handler"), 
 *   description = @Translation("TTN custom webform submission handler."), 
 *   cardinality = \Drupal\webform\Plugin\WebformHandlerInterface::CARDINALITY_SINGLE, 
 *   results = \Drupal\webform\Plugin\WebformHandlerInterface::RESULTS_IGNORED, 
 *   submission = \Drupal\webform\Plugin\WebformHandlerInterface::SUBMISSION_REQUIRED, 
 * ) 
 */ 
class TtnCustomWebformHandler extends WebformHandlerBase { 
  /** 
   * The token manager. 
   * 
   * @var \Drupal\webform\WebformTokenManagerInterface 
   */ 
  protected $tokenManager; 

  /** 
   * {@inheritdoc} 
   */ 
  public static function create(
    ContainerInterface $container, 
    array $configuration, 
    $plugin_id, 
    $plugin_definition) { 
    $instance = parent::create($container, $configuration, $plugin_id, $plugin_definition); 
    $instance->tokenManager = $container->get('webform.token_manager');
    return $instance;
  }

  /**
   * {@inheritdoc}
   */
  public function defaultConfiguration() {
    return [
      'message' => 'This is a custom message.',
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
    $form['message'] = [
      '#type' => 'fieldset',
      '#title' => $this->t('Message settings'),
    ];
    $form['message']['message'] = [
      '#type' => 'textfield',
      '#title' => $this->t('Message to be displayed when form is completed'),
      '#default_value' => $this->configuration['message'],
      '#required' => TRUE,
    ];
    return $this->setSettingsParents($form);
  }

  /**
   * {@inheritdoc}
   */
  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
    parent::submitConfigurationForm($form, $form_state);
    $this->configuration['message'] = $form_state->getValue('message');
  }

  /**
   * {@inheritdoc}
   */
  public function alterElements(array &$elements, WebformInterface $webform) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function overrideSettings(array &$settings, WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function alterForm(array &$form, FormStateInterface $form_state, WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function validateForm(array &$form, FormStateInterface $form_state, WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
    if ($value = $form_state->getValue('element')) {
      $form_state->setErrorByName('element', $this->t('The element must be empty. You entered %value.', ['%value' => $value]));
    }
  }

  /**
   * {@inheritdoc}
   */
  public function submitForm(array &$form, FormStateInterface $form_state, WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function confirmForm(array &$form, FormStateInterface $form_state, WebformSubmissionInterface $webform_submission) {
    $message = $this->configuration['message'];
    $message = $this->replaceTokens($message, $this->getWebformSubmission());
    $this->messenger()->addStatus(Markup::create(Xss::filter($message)), FALSE);
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function preCreate(array &$values) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function postCreate(WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function postLoad(WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function preDelete(WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function post $this->configuration['debug'] = (bool) $form_state->getValue('debug');Delete(WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function preSave(WebformSubmissionInterface $webform_submission) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function postSave(WebformSubmissionInterface $webform_submission, $update = TRUE) {
    $this->debug(__FUNCTION__, $update ? 'update' : 'insert');
  }

  /**
   * {@inheritdoc}
   */
  public function preprocessConfirmation(array &$variables) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function createHandler() {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function updateHandler() {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteHandler() {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function createElement($key, array $element) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function updateElement($key, array $element, array $original_element) {
    $this->debug(__FUNCTION__);
  }

  /**
   * {@inheritdoc}
   */
  public function deleteElement($key, array $element) {
    $this->debug(__FUNCTION__);
  }

  /**
   * Display the invoked plugin method to end user.
   *
   * @param string $method_name
   *   The invoked method name.
   * @param string $context1
   *   Additional parameter passed to the invoked method name.
   */
  protected function debug($method_name, $context1 = NULL) {
    if (!empty($this->configuration['debug'])) {
      $t_args = [
        '@id' => $this->getHandlerId(),
        '@class_name' => get_class($this),
        '@method_name' => $method_name,
        '@context1' => $context1,
      ];
      $this->messenger()->addWarning($this->t('Invoked @id: @class_name:@method_name @context1', $t_args), TRUE);
    }
  }

}

Activez le module et videz le cache. Maintenant, dans le back-end de votre formulaire Web, accédez aux paramètres, puis aux e-mails/gestionnaires. (/admin/structure/webform/manage//handlers). Ajoutez votre gestionnaire ici.

Conclusion

Dans l’ensemble, les gestionnaires de formulaires Web constituent une fonctionnalité puissante du module Drupal Webform, permettant aux développeurs de créer des formulaires sophistiqués et personnalisés avec un large éventail de fonctionnalités et d’intégrations.

Consultez nos autres articles de blog pour plus d’informations. Bonne lecture!

VOUS TROUVEZ CECI UTILE ? PARTAGEZ-LE