Actions personnalisées dans le module Views Bulk Operations dans Drupal

Le module Views Bulk Operations est utilisé pour effectuer des opérations en masse sur des résultats dans des tableaux ou d'autres éléments créés avec Views. Dans cet exemple, je vais vous montrer comment ajouter votre propre action qui changera l'état (Workflows) des entrées sélectionnées.

L'action est effectuée sur toutes les entrées sélectionnées et mise en œuvre automatiquement dans des files d'attente par lots afin de ne pas surcharger le système et de ne pas "crasher" la page lorsque le processus prend trop de temps. Si vous savez ce que vous faites et que vous avez des raisons pour cela, vous pouvez désactiver l'option de mise en file d'attente dans la configuration du champ.

Installation et configuration de VBO

Le module Views Bulk Operations peut être installé en téléchargeant et en décompressant le package dans le répertoire modules/contrib ou en utilisant la commande composer, qui téléchargera la dernière version stable du module.

composer require drupal/views_bulk_operations

Après l'installation, le module n'a pas besoin d'être configuré de quelque manière que ce soit, vous devez simplement ajouter le champ approprié à la page (ou au bloc) créée par le module Views.

• Ajouter une nouvelle vue de contenu qui crée la page.
• Définir le format d'affichage sur Tableau. Ce n'est pas nécessaire, les cases à cocher sur le tableau semblent simplement plus naturelles
• Ajouter le champ de titre
• Ajouter le champ des opérations en masse de Views

Configuration d'action pour un champ VBO

Dans la configuration du champ, vous pouvez indiquer quelles actions de masse peuvent être réalisées sur les résultats. Il existe plus d'une douzaine d'actions prédéfinies, telles que :

• suppression des entrées
• publication
• mise en avant

La liste ci-dessus est compatible lorsque la vue affiche du contenu. Si vous ajoutez la vue qui affiche les utilisateurs, vous remarquerez que la liste a des actions différentes.

Ajouter sa propre action à VBO

Le but est d'ajouter vos propres actions sur les entrées (Contenu) qui changeront l'état (Workflows) des entrées sélectionnées.

Les états des entrées ne sont pas disponibles immédiatement après l'installation de Drupal. Pour ce faire, vous devez activer deux modules supplémentaires directement dans Drupal, vous n'avez pas besoin de télécharger autre chose.

Allez à la page des modules - admin/modules

Activez les modules : Workflows et Content moderation

Configuration des Workflows

Pour les besoins de cet article, j'utiliserai les états définis automatiquement pour le type Éditorial, qui est disponible immédiatement après l'activation du module Content moderation.

Vous devez simplement activer un type de transition d'état donné pour les types de contenu sélectionnés.

• Sur la page admin/config/workflow/workflows, modifiez le type Éditorial
• Définissez le type de contenu Article

Cette opération ajoutera un nouveau champ à chaque formulaire d'ajout/édition d'article.

Pour la vue où se trouve le champ VBO, ajoutez

• un champ affichant l'état d'une entrée donnée - Contenu : État de modération
• un filtre qui limitera l'affichage des entrées du type Article

Si un filtre restrictif limitant les entrées aux seules publiées Contenu : Publié (= Oui) est ajouté, alors enlevez-le. Il bloquera l'affichage des entrées qui ont un état, par exemple, Brouillon ou Archivé, qui ne sont pas publiées par définition.

Code de votre propre action

Créez votre propre module et activez-le. Dans mon cas, le module s'appelle d_workflows

Dans le répertoire du module, créez une structure de répertoiressrc/Plugin/Action

Créez-y un nouveau fichier de classe pour l'action de changer l'état de l'entrée en Publié.

Nom de fichier : PublishNodeAction.php

/**
 * Modération de contenu : publier le nœud.
 *
 * @Action(
 *   id = "d_workflows_publish_node_action",
 *   label = @Translation("Publier le nœud (moderation_state)"),
 *   type = "node",
 *   confirm = TRUE
 * )
 */

class PublishNodeAction extends ViewsBulkOperationsActionBase {

L'annotation de classe est importante ici.

Vous définissez un id pour l'action – cela peut être n'importe quelle valeur unique. Il est utile d'inclure dans son nom le nom du module et ce que fait l'action donnée.

Label est la valeur qui apparaîtra dans la configuration du champ VBO

Type est le type d'entité pour lequel la nouvelle action sera disponible. Dans ce cas, il s'agit de node, mais cela peut être, par exemple, user, taxonomy_term, ou tout autre.

Cette classe hérite de ViewsBulkOperationsActionBase

Elle nécessite la déclaration de deux méthodes :

• execute() - ce qui doit être exécuté pour chaque enregistrement
• access() - qui peut effectuer l'action

Exemple de code pour la méthode execute()

/**
 * {@inheritdoc}
 */
public function execute(ContentEntityInterface $entity = NULL) {
  if (!$state = $entity->get('moderation_state')->getString()) {
    return $this->t(':title  - impossible de changer l'état',
      [
        ':title' => $entity->getTitle(),
      ]
    );
  }

  switch ($state) {
    case 'archived':
    case 'draft':
      $entity->set('moderation_state', 'published');
      $entity->save();
      break;
  }

  return $this->t(':title état changé en :state',
    [
      ':title' => $entity->getTitle(),
      ':state' => $entity->get('moderation_state')->getString(),
    ]
  );
}

La première condition vérifie si l'entité donnée a l'option de réglage de l'état activée.

Dans ce cas, il ne s'agit que de Article. Lorsque l'action est initiée sur des entrées sans états activés (vide $entity->get('moderation_state')->getString()), elle sera interrompue et une information à propos de cela sera affichée.

La condition peut être facilement étendue par exemple en vérifiant le type de contenu pour l'entité

$entity->bundle()

Plus loin dans le code, le statut actuel de l'entrée est vérifié et si la condition est remplie, le code change son statut en Publié.

$entity->set('moderation_state', 'published');

Exemple de code pour la méthode access()

  /**
   * {@inheritdoc}
   */
  public function access($object, AccountInterface $account = NULL, $return_as_object = FALSE) {
    if ($object instanceof Node) {
      $can_update = $object->access('update', $account, TRUE);
      $can_edit = $object->access('edit', $account, TRUE);

      return $can_edit->andIf($can_update)->isAllowed();
    }

    return FALSE;
  }

Dans cette simple condition, il est vérifié si vous opérez sur des objets de type Node et si l'utilisateur exécutant l'action a l'autorisation de les éditer et de les mettre à jour. Sinon, le code retournera FALSE et l'action ne sera pas exécutée.

Le fichier entier PublishNodeAction.php ressemble à ceci :

<?php

namespace Drupal\d_workflows\Plugin\Action;

use Drupal\node\Entity\Node;
use Drupal\views_bulk_operations\Action\ViewsBulkOperationsActionBase;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\Core\Entity\ContentEntityInterface;

/**
 * Modération de contenu : publier le nœud.
 *
 * @Action(
 *   id = "d_workflows_publish_node_action",
 *   label = @Translation("Publier le nœud (moderation_state)"),
 *   type = "node",
 *   confirm = TRUE
 * )
 */

class PublishNodeAction extends ViewsBulkOperationsActionBase {

  use StringTranslationTrait;

  /**
   * {@inheritdoc}
   */
  public function execute(ContentEntityInterface $entity = NULL) {
    if (!$state = $entity->get('moderation_state')->getString()) {
      return $this->t(':title  - impossible de changer l'état',
        [
          ':title' => $entity->getTitle(),
        ]
      );
    }

    switch ($state) {
      case 'archived':
      case 'draft':
        $entity->set('moderation_state', 'published');
        $entity->save();
        break;
    }

    return $this->t(':title état changé en :state',
      [
        ':title' => $entity->getTitle(),
        ':state' => $entity->get('moderation_state')->getString(),
      ]
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access($object, AccountInterface $account = NULL, $return_as_object = FALSE) {
    if ($object instanceof Node) {
      $can_update = $object->access('update', $account, TRUE);
      $can_edit = $object->access('edit', $account, TRUE);

      return $can_edit->andIf($can_update)->isAllowed();
    }

    return FALSE;
  }
}

Une nouvelle action sera disponible dans l'édition du champ VBO

Résumé

Les développeurs Drupal expérimentés Drupal ainsi que les consultants Drupal s'assurent que l'ajout de nouvelles actions à Views Bulk Operations est simple et se résume à créer une classe supplémentaire avec deux méthodes. Basé sur cet exemple simple, vous pouvez créer des actions en masse plus complexes sur des entités de différents types.