You are here

Home » API reference » Views Bulk Operations (VBO) 8 » ViewsBulkOperationsBulkForm.php

class ViewsBulkOperationsBulkForm in Views Bulk Operations (VBO) 8

Same name and namespace in other branches
  1. 8.3 src/Plugin/views/field/ViewsBulkOperationsBulkForm.php \Drupal\views_bulk_operations\Plugin\views\field\ViewsBulkOperationsBulkForm
  2. 8.2 src/Plugin/views/field/ViewsBulkOperationsBulkForm.php \Drupal\views_bulk_operations\Plugin\views\field\ViewsBulkOperationsBulkForm
  3. 4.0.x src/Plugin/views/field/ViewsBulkOperationsBulkForm.php \Drupal\views_bulk_operations\Plugin\views\field\ViewsBulkOperationsBulkForm

Defines the Views Bulk Operations field plugin.

Plugin annotation

@ViewsField("views_bulk_operations_bulk_form");

Hierarchy

Expanded class hierarchy of ViewsBulkOperationsBulkForm

File

src/Plugin/views/field/ViewsBulkOperationsBulkForm.php, line 32

Namespace

Drupal\views_bulk_operations\Plugin\views\field
View source 
class ViewsBulkOperationsBulkForm extends FieldPluginBase implements CacheableDependencyInterface, ContainerFactoryPluginInterface {
  use RedirectDestinationTrait;
  use UncacheableFieldHandlerTrait;

  /**
   * Object that gets the current view data.
   *
   * @var \Drupal\views_bulk_operations\ViewsbulkOperationsViewDataInterface
   */
  protected $viewData;

  /**
   * Views Bulk Operations action manager.
   *
   * @var \Drupal\views_bulk_operations\Service\ViewsBulkOperationsActionManager
   */
  protected $actionManager;

  /**
   * Views Bulk Operations action processor.
   *
   * @var \Drupal\views_bulk_operations\Service\ViewsBulkOperationsActionProcessorInterface
   */
  protected $actionProcessor;

  /**
   * User private temporary storage factory.
   *
   * @var \Drupal\user\PrivateTempStoreFactory
   */
  protected $tempStoreFactory;

  /**
   * The current user object.
   *
   * @var \Drupal\Core\Session\AccountInterface
   */
  protected $currentUser;

  /**
   * An array of actions that can be executed.
   *
   * @var array
   */
  protected $actions = [];

  /**
   * An array of bulk form options.
   *
   * @var array
   */
  protected $bulkOptions;

  /**
   * The current user temporary storage.
   *
   * @var \Drupal\user\PrivateTempStore
   */
  protected $userTempStore;

  /**
   * Tempstore data.
   *
   * This gets passed to next requests if needed
   * or used in the views form submit handler directly.
   *
   * @var array
   */
  protected $tempStoreData = [];

  /**
   * Constructs a new BulkForm object.
   *
   * @param array $configuration
   *   A configuration array containing information about the plugin instance.
   * @param string $plugin_id
   *   The plugin ID for the plugin instance.
   * @param mixed $plugin_definition
   *   The plugin implementation definition.
   * @param \Drupal\views_bulk_operations\Service\ViewsbulkOperationsViewDataInterface $viewData
   *   The VBO View Data provider service.
   * @param \Drupal\views_bulk_operations\Service\ViewsBulkOperationsActionManager $actionManager
   *   Extended action manager object.
   * @param \Drupal\views_bulk_operations\Service\ViewsBulkOperationsActionProcessorInterface $actionProcessor
   *   Views Bulk Operations action processor.
   * @param \Drupal\user\PrivateTempStoreFactory $tempStoreFactory
   *   User private temporary storage factory.
   * @param \Drupal\Core\Session\AccountInterface $currentUser
   *   The current user object.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, ViewsbulkOperationsViewDataInterface $viewData, ViewsBulkOperationsActionManager $actionManager, ViewsBulkOperationsActionProcessorInterface $actionProcessor, PrivateTempStoreFactory $tempStoreFactory, AccountInterface $currentUser) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->viewData = $viewData;
    $this->actionManager = $actionManager;
    $this->actionProcessor = $actionProcessor;
    $this->tempStoreFactory = $tempStoreFactory;
    $this->currentUser = $currentUser;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('views_bulk_operations.data'), $container
      ->get('plugin.manager.views_bulk_operations_action'), $container
      ->get('views_bulk_operations.processor'), $container
      ->get('user.private_tempstore'), $container
      ->get('current_user'));
  }

  /**
   * {@inheritdoc}
   */
  public function init(ViewExecutable $view, DisplayPluginBase $display, array &$options = NULL) {
    parent::init($view, $display, $options);

    // Initialize VBO View Data object.
    $this->viewData
      ->init($view, $display, $this->options['relationship']);

    // Fetch actions.
    $this->actions = [];
    $entity_types = $this->viewData
      ->getEntityTypeIds();

    // Get actions only if there are any entity types set for the view.
    if (!empty($entity_types)) {
      foreach ($this->actionManager
        ->getDefinitions() as $id => $definition) {
        if (empty($definition['type']) || in_array($definition['type'], $entity_types, TRUE)) {
          $this->actions[$id] = $definition;
        }
      }
    }

    // Initialize tempstore object.
    $tempstore_name = 'views_bulk_operations_' . $view
      ->id() . '_' . $view->current_display;
    $this->userTempStore = $this->tempStoreFactory
      ->get($tempstore_name);

    // Force form_step setting to TRUE due to #2879310.
    $this->options['form_step'] = TRUE;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheMaxAge() {

    // @todo Consider making the bulk operation form cacheable. See
    //   https://www.drupal.org/node/2503009.
    return 0;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheContexts() {
    return [];
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheTags() {
    return [];
  }

  /**
   * {@inheritdoc}
   */
  public function getEntity(ResultRow $row) {
    return $this->viewData
      ->getEntity($row);
  }

  /**
   * {@inheritdoc}
   */
  public function query() {
  }

  /**
   * {@inheritdoc}
   */
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['batch'] = [
      'default' => TRUE,
    ];
    $options['batch_size'] = [
      'default' => 10,
    ];
    $options['form_step'] = [
      'default' => TRUE,
    ];
    $options['buttons'] = [
      'default' => FALSE,
    ];
    $options['action_title'] = [
      'default' => $this
        ->t('Action'),
    ];
    $options['selected_actions'] = [
      'default' => [],
    ];
    $options['preconfiguration'] = [
      'default' => [],
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {

    // If the view type is not supported, suppress form display.
    // Also display information note to the user.
    if (empty($this->actions)) {
      $form = [
        '#type' => 'item',
        '#title' => $this
          ->t('NOTE'),
        '#markup' => $this
          ->t('Views Bulk Operations will work only with normal entity views and contrib module views that are integrated. See /Drupal\\views_bulk_operations\\EventSubscriber\\ViewsBulkOperationsEventSubscriber class for integration best practice.'),
        '#prefix' => '<div class="scroll">',
        '#suffix' => '</div>',
      ];
      return;
    }
    $form['#attributes']['class'][] = 'views-bulk-operations-ui';
    $form['#attached']['library'][] = 'views_bulk_operations/adminUi';
    $form['batch'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Process in a batch operation'),
      '#default_value' => $this->options['batch'],
    ];
    $form['batch_size'] = [
      '#title' => $this
        ->t('Batch size'),
      '#type' => 'number',
      '#min' => 1,
      '#step' => 1,
      '#description' => $this
        ->t('Only applicable if results are processed in a batch operation.'),
      '#default_value' => $this->options['batch_size'],
    ];
    $form['form_step'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Configuration form on new page (configurable actions)'),
      '#default_value' => $this->options['form_step'],
      // Due to #2879310 this setting must always be at TRUE.
      '#access' => FALSE,
    ];
    $form['buttons'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Display selectable actions as buttons.'),
      '#default_value' => $this->options['buttons'],
    ];
    $form['action_title'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Action title'),
      '#default_value' => $this->options['action_title'],
      '#description' => $this
        ->t('The title shown above the actions dropdown.'),
    ];
    $form['selected_actions'] = [
      '#tree' => TRUE,
      '#type' => 'details',
      '#open' => TRUE,
      '#title' => $this
        ->t('Selected actions'),
      '#attributes' => [
        'class' => [
          'vbo-actions-widget',
        ],
      ],
    ];

    // Load values for display.
    $form_values = $form_state
      ->getValue([
      'options',
      'selected_actions',
    ]);
    if (is_null($form_values)) {
      $selected_actions = $this->options['selected_actions'];
      $preconfiguration = $this->options['preconfiguration'];
    }
    else {
      $selected_actions = [];
      $preconfiguration = [];
      foreach ($form_values as $id => $value) {
        $selected_actions[$id] = $value['state'] ? $id : 0;
        $preconfiguration[$id] = isset($value['preconfiguration']) ? $value['preconfiguration'] : [];
      }
    }
    foreach ($this->actions as $id => $action) {
      $form['selected_actions'][$id]['state'] = [
        '#type' => 'checkbox',
        '#title' => $action['label'],
        '#default_value' => empty($selected_actions[$id]) ? 0 : 1,
        '#attributes' => [
          'class' => [
            'vbo-action-state',
          ],
        ],
      ];

      // There are problems with AJAX on this form when adding
      // new elements (Views issue), a workaround is to render
      // all elements and show/hide them when needed.
      $form['selected_actions'][$id]['preconfiguration'] = [
        '#type' => 'fieldset',
        '#title' => $this
          ->t('Preconfiguration for "@action"', [
          '@action' => $action['label'],
        ]),
        '#attributes' => [
          'data-for' => $id,
          'style' => empty($selected_actions[$id]) ? 'display: none' : NULL,
        ],
      ];

      // Default label_override element.
      $form['selected_actions'][$id]['preconfiguration']['label_override'] = [
        '#type' => 'textfield',
        '#title' => $this
          ->t('Override label'),
        '#description' => $this
          ->t('Leave empty for the default label.'),
        '#default_value' => isset($preconfiguration[$id]['label_override']) ? $preconfiguration[$id]['label_override'] : '',
      ];

      // Load preconfiguration form if available.
      if (method_exists($action['class'], 'buildPreConfigurationForm')) {
        if (!isset($preconfiguration[$id])) {
          $preconfiguration[$id] = [];
        }
        $actionObject = $this->actionManager
          ->createInstance($id);
        $form['selected_actions'][$id]['preconfiguration'] = $actionObject
          ->buildPreConfigurationForm($form['selected_actions'][$id]['preconfiguration'], $preconfiguration[$id], $form_state);
      }
    }
    parent::buildOptionsForm($form, $form_state);
  }

  /**
   * {@inheritdoc}
   */
  public function submitOptionsForm(&$form, FormStateInterface $form_state) {
    $options =& $form_state
      ->getValue('options');
    foreach ($options['selected_actions'] as $id => $action) {
      if (!empty($action['state'])) {
        if (isset($action['preconfiguration'])) {
          $options['preconfiguration'][$id] = $action['preconfiguration'];
          unset($options['selected_actions'][$id]['preconfiguration']);
        }
        $options['selected_actions'][$id] = $id;
      }
      else {
        unset($options['preconfiguration'][$id]);
        $options['selected_actions'][$id] = 0;
      }
    }
    parent::submitOptionsForm($form, $form_state);
  }

  /**
   * {@inheritdoc}
   */
  public function preRender(&$values) {
    parent::preRender($values);

    // Add empty classes if there are no actions available.
    if (empty($this
      ->getBulkOptions())) {
      $this->options['element_label_class'] .= 'empty';
      $this->options['element_class'] .= 'empty';
      $this->options['element_wrapper_class'] .= 'empty';
      $this->options['label'] = '';
    }
    elseif (!empty($this->view->style_plugin) && $this->view->style_plugin instanceof Table) {

      // Add the tableselect css classes.
      $this->options['element_label_class'] .= 'select-all';

      // Hide the actual label of the field on the table header.
      $this->options['label'] = '';
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getValue(ResultRow $row, $field = NULL) {
    return '<!--form-item-' . $this->options['id'] . '--' . $row->index . '-->';
  }

  /**
   * Form constructor for the bulk form.
   *
   * @param array $form
   *   An associative array containing the structure of the form.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the form.
   */
  public function viewsForm(array &$form, FormStateInterface $form_state) {

    // Make sure we do not accidentally cache this form.
    // @todo Evaluate this again in https://www.drupal.org/node/2503009.
    $form['#cache']['max-age'] = 0;
    $use_revision = array_key_exists('revision', $this->view
      ->getQuery()
      ->getEntityTableInfo());

    // Add select all and tableselect libraries for table display style.
    if ($this->view->style_plugin instanceof Table) {
      $form['#attached']['library'][] = 'core/drupal.tableselect';
      $form['#attached']['library'][] = 'views_bulk_operations/selectAll';
    }

    // Only add the bulk form options and buttons if
    // there are results and any actions are available.
    $action_options = $this
      ->getBulkOptions();
    if (!empty($this->view->result) && !empty($action_options)) {

      // Prepare entity labels data so the view will not
      // need to be executed again on possible confirmation
      // or configuration forms.
      $this->tempStoreData['entity_labels'] = [];

      // Render checkboxes for all rows.
      $form[$this->options['id']]['#tree'] = TRUE;
      foreach ($this->view->result as $row_index => $row) {
        $entity = $this
          ->getEntity($row);
        $this->tempStoreData['entity_labels'][$row_index] = $entity
          ->label();
        $form[$this->options['id']][$row_index] = [
          '#type' => 'checkbox',
          // We are not able to determine a main "title" for each row, so we can
          // only output a generic label.
          '#title' => $this
            ->t('Update this item'),
          '#title_display' => 'invisible',
          '#default_value' => !empty($form_state
            ->getValue($this->options['id'])[$row_index]) ? 1 : NULL,
          '#return_value' => self::calculateEntityBulkFormKey($entity, $use_revision, $row_index),
        ];
      }

      // Ensure a consistent container for filters/operations
      // in the view header.
      $form['header'] = [
        '#type' => 'container',
        '#weight' => -100,
      ];

      // Build the bulk operations action widget for the header.
      // Allow themes to apply .container-inline on this separate container.
      $form['header'][$this->options['id']] = [
        '#type' => 'container',
        '#attributes' => [
          'id' => 'vbo-action-form-wrapper',
        ],
      ];

      // Display actions buttons or selector.
      if ($this->options['buttons']) {
        unset($form['actions']['submit']);
        foreach ($action_options as $id => $label) {
          $form['actions'][$id] = [
            '#type' => 'submit',
            '#value' => $label,
          ];
        }
      }
      else {

        // Replace the form submit button label.
        $form['actions']['submit']['#value'] = $this
          ->t('Apply to selected items');
        $form['header'][$this->options['id']]['action'] = [
          '#type' => 'select',
          '#title' => $this->options['action_title'],
          '#options' => [
            '' => $this
              ->t('-- Select action --'),
          ] + $action_options,
        ];
      }

      // Add AJAX functionality if actions are configurable through this form.
      if (empty($this->options['form_step'])) {
        $form['header'][$this->options['id']]['action']['#ajax'] = [
          'callback' => [
            __CLASS__,
            'viewsFormAjax',
          ],
          'wrapper' => 'vbo-action-configuration-wrapper',
        ];
        $form['header'][$this->options['id']]['configuration'] = [
          '#type' => 'container',
          '#attributes' => [
            'id' => 'vbo-action-configuration-wrapper',
          ],
        ];
        $action_id = $form_state
          ->getValue('action');
        if (!empty($action_id)) {
          $action = $this->actions[$action_id];
          if ($this
            ->isConfigurable($action)) {
            $actionObject = $this->actionManager
              ->createInstance($action_id);
            $form['header'][$this->options['id']]['configuration'] += $actionObject
              ->buildConfigurationForm($form['header'][$this->options['id']]['configuration'], $form_state);
            $form['header'][$this->options['id']]['configuration']['#config_included'] = TRUE;
          }
        }
      }

      // Select all results checkbox.
      $show_all_selector = FALSE;
      if (!empty($this->view->pager) && method_exists($this->view->pager, 'hasMoreRecords')) {
        $show_all_selector = $this->view->pager
          ->getCurrentPage() > 0 || $this->view->pager
          ->hasMoreRecords();
      }
      $this->tempStoreData['total_results'] = $this->viewData
        ->getTotalResults();
      if ($show_all_selector) {
        $form['header'][$this->options['id']]['select_all'] = [
          '#type' => 'checkbox',
          '#title' => $this
            ->t('Select all@count results in this view', [
            '@count' => $this->tempStoreData['total_results'] ? ' ' . $this->tempStoreData['total_results'] : '',
          ]),
          '#attributes' => [
            'class' => [
              'vbo-select-all',
            ],
          ],
        ];
      }

      // Duplicate the form actions into the action container in the header.
      $form['header'][$this->options['id']]['actions'] = $form['actions'];
    }
    else {

      // Remove the default actions build array.
      unset($form['actions']);
    }
  }

  /**
   * AJAX callback for the views form.
   *
   * Currently not used due to #2879310.
   */
  public static function viewsFormAjax(array $form, FormStateInterface $form_state) {
    $trigger = $form_state
      ->getTriggeringElement();
    $plugin_id = $trigger['#array_parents'][1];
    return $form['header'][$plugin_id]['configuration'];
  }

  /**
   * Returns the available operations for this form.
   *
   * @return array
   *   An associative array of operations, suitable for a select element.
   */
  protected function getBulkOptions() {
    if (!isset($this->bulkOptions)) {
      $this->bulkOptions = [];
      foreach ($this->actions as $id => $definition) {

        // Filter out actions that weren't selected.
        if (!in_array($id, $this->options['selected_actions'], TRUE)) {
          continue;
        }

        // Check access permission, if defined.
        if (!empty($definition['requirements']['_permission']) && !$this->currentUser
          ->hasPermission($definition['requirements']['_permission'])) {
          continue;
        }

        // Override label if applicable.
        if (!empty($this->options['preconfiguration'][$id]['label_override'])) {
          $this->bulkOptions[$id] = $this->options['preconfiguration'][$id]['label_override'];
        }
        else {
          $this->bulkOptions[$id] = $definition['label'];
        }
      }
    }
    return $this->bulkOptions;
  }

  /**
   * Submit handler for the bulk form.
   *
   * @param array $form
   *   An associative array containing the structure of the form.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the form.
   *
   * @throws \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException
   *   Thrown when the user tried to access an action without access to it.
   */
  public function viewsFormSubmit(array &$form, FormStateInterface $form_state) {
    if ($form_state
      ->get('step') == 'views_form_views_form') {
      $action_id = $form_state
        ->getValue('action');
      $action = $this->actions[$action_id];
      $this->tempStoreData += [
        'action_id' => $action_id,
        'action_label' => empty($this->options['preconfiguration'][$action_id]['label_override']) ? (string) $action['label'] : $this->options['preconfiguration'][$action_id]['label_override'],
        'relationship_id' => $this->options['relationship'],
        'preconfiguration' => isset($this->options['preconfiguration'][$action_id]) ? $this->options['preconfiguration'][$action_id] : [],
        'list' => [],
        'view_id' => $this->view
          ->id(),
        'display_id' => $this->view->current_display,
        'batch' => $this->options['batch'],
        'arguments' => $this->view->args,
        'exposed_input' => $this->view
          ->getExposedInput(),
      ];

      // Get the current page for the "pass_view" functionality.
      if (!empty($action['pass_view'])) {
        $this->tempStoreData['current_page'] = 0;
        if (!empty($this->view->pager) && method_exists($this->view->pager, 'getCurrentPage')) {
          $this->tempStoreData['current_page'] = $this->view->pager
            ->getCurrentPage();
        }
      }
      if (!$form_state
        ->getValue('select_all')) {
        $selected = array_filter($form_state
          ->getValue($this->options['id']));
        $selected_indexes = [];
        foreach ($selected as $bulk_form_key) {
          $item = json_decode(base64_decode($bulk_form_key));
          $this->tempStoreData['list'][] = $item;
          $selected_indexes[] = $item[0];
        }

        // Filter selected entity labels.
        $this->tempStoreData['entity_labels'] = array_filter($this->tempStoreData['entity_labels'], function ($key) use ($selected_indexes) {
          return in_array($key, $selected_indexes, TRUE);
        }, ARRAY_FILTER_USE_KEY);
      }
      else {
        $this->tempStoreData['entity_labels'] = [];
      }
      $configurable = $this
        ->isConfigurable($action);

      // Get configuration if using AJAX.
      if ($configurable && empty($this->options['form_step'])) {
        $actionObject = $this->actionManager
          ->createInstance($action_id);
        if (method_exists($actionObject, 'submitConfigurationForm')) {
          $actionObject
            ->submitConfigurationForm($form, $form_state);
          $this->tempStoreData['configuration'] = $actionObject
            ->getConfiguration();
        }
        else {
          $form_state
            ->cleanValues();
          $this->tempStoreData['configuration'] = $form_state
            ->getValues();
        }
      }

      // Routing - determine redirect route.
      if ($this->options['form_step'] && $configurable) {
        $redirect_route = 'views_bulk_operations.execute_configurable';
      }
      elseif ($this->options['batch']) {
        if (!empty($action['confirm_form_route_name'])) {
          $redirect_route = $action['confirm_form_route_name'];
        }
        else {
          $redirect_route = 'views_bulk_operations.execute_batch';
        }
      }
      elseif (!empty($action['confirm_form_route_name'])) {
        $redirect_route = $action['confirm_form_route_name'];
      }

      // Redirect if needed.
      if (!empty($redirect_route)) {
        $this->tempStoreData['batch_size'] = $this->options['batch_size'];
        $this->tempStoreData['redirect_url'] = Url::createFromRequest(\Drupal::request());
        $this->userTempStore
          ->set($this->currentUser
          ->id(), $this->tempStoreData);
        $form_state
          ->setRedirect($redirect_route, [
          'view_id' => $this->view
            ->id(),
          'display_id' => $this->view->current_display,
        ]);
      }
      else {
        $this->actionProcessor
          ->executeProcessing($this->tempStoreData, $this->view);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function viewsFormValidate(&$form, FormStateInterface $form_state) {
    if ($this->options['buttons']) {
      $trigger = $form_state
        ->getTriggeringElement();
      $action_id = end($trigger['#parents']);
      $form_state
        ->setValue('action', $action_id);
    }
    if (empty($form_state
      ->getValue('action'))) {
      $form_state
        ->setErrorByName('action', $this
        ->t('Please select an action to perform.'));
    }

    // This happened once, can't reproduce but here's a safety switch.
    if (!isset($this->actions[$form_state
      ->getValue('action')])) {
      $form_state
        ->setErrorByName('action', $this
        ->t('Form error occurred, please try again.'));
    }
    if (!$form_state
      ->getValue('select_all')) {
      $selected = array_filter($form_state
        ->getValue($this->options['id']));
      if (empty($selected)) {
        $form_state
          ->setErrorByName('', $this
          ->t('No items selected.'));
      }
    }

    // Action config validation (if implemented).
    if (empty($this->options['form_step']) && !empty($form['header'][$this->options['id']]['configuration']['#config_included'])) {
      $action_id = $form_state
        ->getValue('action');
      $action = $this->actions[$action_id];
      if (method_exists($action['class'], 'validateConfigurationForm')) {
        $actionObject = $this->actionManager
          ->createInstance($action_id);
        $actionObject
          ->validateConfigurationForm($form['header'][$this->options['id']]['configuration'], $form_state);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function clickSortable() {
    return FALSE;
  }

  /**
   * Wraps drupal_set_message().
   */
  protected function drupalSetMessage($message = NULL, $type = 'status', $repeat = FALSE) {
    drupal_set_message($message, $type, $repeat);
  }

  /**
   * Calculates a bulk form key.
   *
   * This generates a key that is used as the checkbox return value when
   * submitting a bulk form. This key allows the entity for the row to be loaded
   * totally independently of the executed view row.
   *
   * @param \Drupal\Core\Entity\EntityInterface $entity
   *   The entity to calculate a bulk form key for.
   * @param bool $use_revision
   *   Whether the revision id should be added to the bulk form key. This should
   *   be set to TRUE only if the view is listing entity revisions.
   * @param int $row_index
   *   Index of the views row that contains the entity.
   *
   * @return string
   *   The bulk form key representing the entity's id, language and revision (if
   *   applicable) as one string.
   *
   * @see self::loadEntityFromBulkFormKey()
   */
  public static function calculateEntityBulkFormKey(EntityInterface $entity, $use_revision, $row_index) {
    $key_parts = [
      $row_index,
      $entity
        ->language()
        ->getId(),
      $entity
        ->getEntityTypeId(),
      $entity
        ->id(),
    ];
    if ($entity instanceof RevisionableInterface && $use_revision) {
      $key_parts[] = $entity
        ->getRevisionId();
    }

    // An entity ID could be an arbitrary string (although they are typically
    // numeric). JSON then Base64 encoding ensures the bulk_form_key is
    // safe to use in HTML, and that the key parts can be retrieved.
    $key = json_encode($key_parts);
    return base64_encode($key);
  }

  /**
   * Check if an action is configurable.
   */
  protected function isConfigurable($action) {
    return in_array('Drupal\\Core\\Plugin\\PluginFormInterface', class_implements($action['class']), TRUE) || method_exists($action['class'], 'buildConfigurationForm');
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
FieldPluginBase::$additional_fields public property Stores additional fields which get added to the query.
FieldPluginBase::$aliases public property
FieldPluginBase::$field_alias public property
FieldPluginBase::$lastRenderIndex protected property Keeps track of the last render index.
FieldPluginBase::$linkGenerator protected property The link generator.
FieldPluginBase::$original_value public property The field value prior to any rewriting.
FieldPluginBase::$renderer protected property Stores the render API renderer. Overrides PluginBase::$renderer 1
FieldPluginBase::addAdditionalFields protected function Add 'additional' fields to the query.
FieldPluginBase::addSelfTokens protected function Add any special tokens this field might use for itself. 4
FieldPluginBase::adminLabel public function Return a string representing this handler's name in the UI. Overrides HandlerBase::adminLabel
FieldPluginBase::adminSummary public function Provide extra data to the administration form Overrides HandlerBase::adminSummary
FieldPluginBase::advancedRender public function Renders a field using advanced settings. Overrides FieldHandlerInterface::advancedRender
FieldPluginBase::allowAdvancedRender protected function Determine if this field can allow advanced rendering.
FieldPluginBase::clickSort public function Adds an ORDER BY clause to the query for click sort columns. Overrides FieldHandlerInterface::clickSort 1
FieldPluginBase::documentSelfTokens protected function Document any special tokens this field might use for itself. 3
FieldPluginBase::elementClasses public function Returns the class of the field. Overrides FieldHandlerInterface::elementClasses
FieldPluginBase::elementLabelClasses public function Returns the class of the field's label. Overrides FieldHandlerInterface::elementLabelClasses
FieldPluginBase::elementLabelType public function Returns an HTML element for the label based upon the field's element type. Overrides FieldHandlerInterface::elementLabelType
FieldPluginBase::elementType public function Returns an HTML element based upon the field's element type. Overrides FieldHandlerInterface::elementType 1
FieldPluginBase::elementWrapperClasses public function Returns the class of the field's wrapper. Overrides FieldHandlerInterface::elementWrapperClasses
FieldPluginBase::elementWrapperType public function Returns an HTML element for the wrapper based upon the field's element type. Overrides FieldHandlerInterface::elementWrapperType
FieldPluginBase::getElements public function Provides a list of elements valid for field HTML. Overrides FieldHandlerInterface::getElements
FieldPluginBase::getPreviousFieldLabels protected function Returns all field labels of fields before this field.
FieldPluginBase::getRenderer protected function Returns the render API renderer. Overrides PluginBase::getRenderer
FieldPluginBase::getRenderTokens public function Gets the 'render' tokens to use for advanced rendering. Overrides FieldHandlerInterface::getRenderTokens
FieldPluginBase::getTokenValuesRecursive protected function Recursive function to add replacements for nested query string parameters.
FieldPluginBase::isValueEmpty public function Checks if a field value is empty. Overrides FieldHandlerInterface::isValueEmpty
FieldPluginBase::label public function Gets this field's label. Overrides FieldHandlerInterface::label
FieldPluginBase::linkGenerator protected function Gets the link generator.
FieldPluginBase::renderAltered protected function Render this field as user-defined altered text.
FieldPluginBase::renderAsLink protected function Render this field as a link, with the info from a fieldset set by the user.
FieldPluginBase::renderText public function Performs an advanced text render for the item. Overrides FieldHandlerInterface::renderText
FieldPluginBase::renderTrimText protected function Trims the field down to the specified length.
FieldPluginBase::RENDER_TEXT_PHASE_COMPLETELY constant Indicator of the renderText() method for rendering the whole element. (if no render_item() method is available).
FieldPluginBase::RENDER_TEXT_PHASE_EMPTY constant Indicator of the renderText() method for rendering the empty text.
FieldPluginBase::RENDER_TEXT_PHASE_SINGLE_ITEM constant Indicator of the renderText() method for rendering a single item. (If no render_item() is present).
FieldPluginBase::theme public function Passes values to drupal_render() using $this->themeFunctions() as #theme. Overrides FieldHandlerInterface::theme
FieldPluginBase::themeFunctions public function Provide a full list of possible theme templates used by this style. Overrides PluginBase::themeFunctions
FieldPluginBase::tokenizeValue public function Replaces a value with tokens from the last field. Overrides FieldHandlerInterface::tokenizeValue
FieldPluginBase::trimText public static function Trims the field down to the specified length.
FieldPluginBase::useStringGroupBy public function Determines if this field will be available as an option to group the result by in the style settings. Overrides FieldHandlerInterface::useStringGroupBy
HandlerBase::$field public property With field you can override the realField if the real field is not set.
HandlerBase::$moduleHandler protected property The module handler. 3
HandlerBase::$query public property Where the $query object will reside: 7
HandlerBase::$realField public property The actual field in the database table, maybe different on other kind of query plugins/special handlers.
HandlerBase::$relationship public property The relationship used for this field.
HandlerBase::$table public property The table this handler is attached to.
HandlerBase::$tableAlias public property The alias of the table of this handler which is used in the query.
HandlerBase::$viewsData protected property The views data service.
HandlerBase::acceptExposedInput public function Take input from exposed handlers and assign to this handler, if necessary. 1
HandlerBase::access public function Check whether given user has access to this handler. Overrides ViewsHandlerInterface::access 4
HandlerBase::breakString public static function Breaks x,y,z and x+y+z into an array. Overrides ViewsHandlerInterface::breakString
HandlerBase::broken public function Determines if the handler is considered 'broken', meaning it's a placeholder used when a handler can't be found. Overrides ViewsHandlerInterface::broken
HandlerBase::buildExposedForm public function Render our chunk of the exposed handler form when selecting 1
HandlerBase::buildExposeForm public function Form for exposed handler options. 2
HandlerBase::buildExtraOptionsForm public function Provide a form for setting options. 1
HandlerBase::buildGroupByForm public function Provide a form for aggregation settings. 1
HandlerBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides PluginBase::calculateDependencies 10
HandlerBase::canExpose public function Determine if a handler can be exposed. 2
HandlerBase::caseTransform protected function Transform a string by a certain method.
HandlerBase::defaultExposeOptions public function Set new exposed option defaults when exposed setting is flipped on. 2
HandlerBase::defineExtraOptions public function Provide defaults for the handler.
HandlerBase::displayExposedForm public function Displays the Expose form.
HandlerBase::ensureMyTable public function Ensure the main table for this handler is in the query. This is used a lot. Overrides ViewsHandlerInterface::ensureMyTable 2
HandlerBase::exposedInfo public function Get information about the exposed form for the form renderer. 1
HandlerBase::getDateField public function Creates cross-database SQL dates. 2
HandlerBase::getDateFormat public function Creates cross-database SQL date formatting. 2
HandlerBase::getEntityType public function Determines the entity type used by this handler. Overrides ViewsHandlerInterface::getEntityType
HandlerBase::getField public function Shortcut to get a handler's raw field value. Overrides ViewsHandlerInterface::getField
HandlerBase::getJoin public function Get the join object that should be used for this handler. Overrides ViewsHandlerInterface::getJoin
HandlerBase::getModuleHandler protected function Gets the module handler.
HandlerBase::getTableJoin public static function Fetches a handler to join one table to a primary table from the data cache. Overrides ViewsHandlerInterface::getTableJoin
HandlerBase::getViewsData protected function Gets views data service.
HandlerBase::hasExtraOptions public function If a handler has 'extra options' it will get a little settings widget and another form called extra_options. 1
HandlerBase::isAGroup public function Returns TRUE if the exposed filter works like a grouped filter. 1
HandlerBase::isExposed public function Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.
HandlerBase::multipleExposedInput public function Define if the exposed input has to be submitted multiple times. This is TRUE when exposed filters grouped are using checkboxes as widgets. 1
HandlerBase::placeholder protected function Provides a unique placeholders for handlers.
HandlerBase::postExecute public function Run after the view is executed, before the result is cached. Overrides ViewsHandlerInterface::postExecute
HandlerBase::preQuery public function Run before the view is built. Overrides ViewsHandlerInterface::preQuery 2
HandlerBase::sanitizeValue public function Sanitize the value for output. Overrides ViewsHandlerInterface::sanitizeValue
HandlerBase::setModuleHandler public function Sets the module handler.
HandlerBase::setRelationship public function Called just prior to query(), this lets a handler set up any relationship it needs. Overrides ViewsHandlerInterface::setRelationship
HandlerBase::setViewsData public function
HandlerBase::showExposeButton public function Shortcut to display the expose/hide button. 2
HandlerBase::showExposeForm public function Shortcut to display the exposed options form. Overrides ViewsHandlerInterface::showExposeForm
HandlerBase::storeExposedInput public function If set to remember exposed input in the session, store it there. 1
HandlerBase::submitExposed public function Submit the exposed handler form
HandlerBase::submitExposeForm public function Perform any necessary changes to the form exposes prior to storage. There is no need for this function to actually store the data.
HandlerBase::submitExtraOptionsForm public function Perform any necessary changes to the form values prior to storage. There is no need for this function to actually store the data.
HandlerBase::submitFormCalculateOptions public function Calculates options stored on the handler 1
HandlerBase::submitGroupByForm public function Perform any necessary changes to the form values prior to storage. There is no need for this function to actually store the data. 1
HandlerBase::submitTemporaryForm public function A submit handler that is used for storing temporary items when using multi-step changes, such as ajax requests.
HandlerBase::usesGroupBy public function Provides the handler some groupby. 13
HandlerBase::validate public function Validate that the plugin is correct and can be saved. Overrides PluginBase::validate 2
HandlerBase::validateExposed public function Validate the exposed handler form 4
HandlerBase::validateExposeForm public function Validate the options form. 1
HandlerBase::validateExtraOptionsForm public function Validate the options form.
MessengerTrait::$messenger protected property The messenger. 29
MessengerTrait::messenger public function Gets the messenger. 29
MessengerTrait::setMessenger public function Sets the messenger.
PluginBase::$configuration protected property Configuration information passed into the plugin. 1
PluginBase::$definition public property Plugins's definition
PluginBase::$displayHandler public property The display object this plugin is for.
PluginBase::$options public property Options for this plugin will be held here.
PluginBase::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
PluginBase::$usesOptions protected property Denotes whether the plugin has an additional options form. 8
PluginBase::$view public property The top object of a view. 1
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::destroy public function Clears a plugin. Overrides ViewsPluginInterface::destroy 2
PluginBase::doFilterByDefinedOptions protected function Do the work to filter out stored options depending on the defined options.
PluginBase::filterByDefinedOptions public function Filter out stored options depending on the defined options. Overrides ViewsPluginInterface::filterByDefinedOptions
PluginBase::getAvailableGlobalTokens public function Returns an array of available token replacements. Overrides ViewsPluginInterface::getAvailableGlobalTokens
PluginBase::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition 3
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::getProvider public function Returns the plugin provider. Overrides ViewsPluginInterface::getProvider
PluginBase::globalTokenForm public function Adds elements for available core tokens to a form. Overrides ViewsPluginInterface::globalTokenForm
PluginBase::globalTokenReplace public function Returns a string with any core tokens replaced. Overrides ViewsPluginInterface::globalTokenReplace
PluginBase::INCLUDE_ENTITY constant Include entity row languages when listing languages.
PluginBase::INCLUDE_NEGOTIATED constant Include negotiated languages when listing languages.
PluginBase::listLanguages protected function Makes an array of languages, optionally including special languages.
PluginBase::pluginTitle public function Return the human readable name of the display. Overrides ViewsPluginInterface::pluginTitle
PluginBase::preRenderAddFieldsetMarkup public static function Moves form elements into fieldsets for presentation purposes. Overrides ViewsPluginInterface::preRenderAddFieldsetMarkup
PluginBase::preRenderFlattenData public static function Flattens the structure of form elements. Overrides ViewsPluginInterface::preRenderFlattenData
PluginBase::queryLanguageSubstitutions public static function Returns substitutions for Views queries for languages.
PluginBase::setOptionDefaults protected function Fills up the options of the plugin with defaults.
PluginBase::summaryTitle public function Returns the summary of the settings in the display. Overrides ViewsPluginInterface::summaryTitle 6
PluginBase::trustedCallbacks public static function Lists the trusted callbacks provided by the implementing class. Overrides TrustedCallbackInterface::trustedCallbacks 6
PluginBase::unpackOptions public function Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away. Overrides ViewsPluginInterface::unpackOptions
PluginBase::usesOptions public function Returns the usesOptions property. Overrides ViewsPluginInterface::usesOptions 8
PluginBase::validateOptionsForm public function Validate the options form. Overrides ViewsPluginInterface::validateOptionsForm 15
PluginBase::viewsTokenReplace protected function Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin. 1
PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT constant Query string to indicate the site default language.
RedirectDestinationTrait::$redirectDestination protected property The redirect destination service. 1
RedirectDestinationTrait::getDestinationArray protected function Prepares a 'destination' URL query parameter for use with \Drupal\Core\Url.
RedirectDestinationTrait::getRedirectDestination protected function Returns the redirect destination service.
RedirectDestinationTrait::setRedirectDestination public function Sets the redirect destination service.
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.
TrustedCallbackInterface::THROW_EXCEPTION constant Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION constant Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING constant Untrusted callbacks trigger E_USER_WARNING errors.
UncacheableFieldHandlerTrait::doRender protected function Actually renders the field markup.
UncacheableFieldHandlerTrait::getFieldTokenPlaceholder abstract protected function
UncacheableFieldHandlerTrait::postRender public function
UncacheableFieldHandlerTrait::render public function
ViewsBulkOperationsBulkForm::$actionManager protected property Views Bulk Operations action manager.
ViewsBulkOperationsBulkForm::$actionProcessor protected property Views Bulk Operations action processor.
ViewsBulkOperationsBulkForm::$actions protected property An array of actions that can be executed.
ViewsBulkOperationsBulkForm::$bulkOptions protected property An array of bulk form options.
ViewsBulkOperationsBulkForm::$currentUser protected property The current user object.
ViewsBulkOperationsBulkForm::$tempStoreData protected property Tempstore data.
ViewsBulkOperationsBulkForm::$tempStoreFactory protected property User private temporary storage factory.
ViewsBulkOperationsBulkForm::$userTempStore protected property The current user temporary storage.
ViewsBulkOperationsBulkForm::$viewData protected property Object that gets the current view data.
ViewsBulkOperationsBulkForm::buildOptionsForm public function Default options form that provides the label widget that all fields should have. Overrides FieldPluginBase::buildOptionsForm
ViewsBulkOperationsBulkForm::calculateEntityBulkFormKey public static function Calculates a bulk form key.
ViewsBulkOperationsBulkForm::clickSortable public function Determines if this field is click sortable. Overrides FieldPluginBase::clickSortable
ViewsBulkOperationsBulkForm::create public static function Creates an instance of the plugin. Overrides PluginBase::create
ViewsBulkOperationsBulkForm::defineOptions protected function Information about options for all kinds of purposes will be held here. @code 'option_name' => array( Overrides FieldPluginBase::defineOptions
ViewsBulkOperationsBulkForm::drupalSetMessage protected function Wraps drupal_set_message().
ViewsBulkOperationsBulkForm::getBulkOptions protected function Returns the available operations for this form.
ViewsBulkOperationsBulkForm::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyInterface::getCacheContexts
ViewsBulkOperationsBulkForm::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyInterface::getCacheMaxAge
ViewsBulkOperationsBulkForm::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyInterface::getCacheTags
ViewsBulkOperationsBulkForm::getEntity public function Gets the entity matching the current row and relationship. Overrides FieldPluginBase::getEntity
ViewsBulkOperationsBulkForm::getValue public function Gets the value that's supposed to be rendered. Overrides UncacheableFieldHandlerTrait::getValue
ViewsBulkOperationsBulkForm::init public function Overrides Drupal\views\Plugin\views\HandlerBase::init(). Overrides FieldPluginBase::init
ViewsBulkOperationsBulkForm::isConfigurable protected function Check if an action is configurable. Overrides PluginBase::isConfigurable
ViewsBulkOperationsBulkForm::preRender public function Runs before any fields are rendered. Overrides FieldPluginBase::preRender
ViewsBulkOperationsBulkForm::query public function Called to add the field to a query. Overrides FieldPluginBase::query
ViewsBulkOperationsBulkForm::submitOptionsForm public function Performs some cleanup tasks on the options array before saving it. Overrides FieldPluginBase::submitOptionsForm
ViewsBulkOperationsBulkForm::viewsForm public function Form constructor for the bulk form.
ViewsBulkOperationsBulkForm::viewsFormAjax public static function AJAX callback for the views form.
ViewsBulkOperationsBulkForm::viewsFormSubmit public function Submit handler for the bulk form.
ViewsBulkOperationsBulkForm::viewsFormValidate public function
ViewsBulkOperationsBulkForm::__construct public function Constructs a new BulkForm object. Overrides HandlerBase::__construct