You are here

Home » API reference » Drupal 8 » ExposedFormPluginBase.php

abstract class ExposedFormPluginBase in Drupal 8

Same name and namespace in other branches
  1. 9 core/modules/views/src/Plugin/views/exposed_form/ExposedFormPluginBase.php \Drupal\views\Plugin\views\exposed_form\ExposedFormPluginBase

Base class for Views exposed filter form plugins.

Hierarchy

Expanded class hierarchy of ExposedFormPluginBase

Related topics

Views exposed form plugins
Plugins that handle validation, submission, and rendering of exposed forms.

File

core/modules/views/src/Plugin/views/exposed_form/ExposedFormPluginBase.php, line 16

Namespace

Drupal\views\Plugin\views\exposed_form
View source 
abstract class ExposedFormPluginBase extends PluginBase implements CacheableDependencyInterface, ExposedFormPluginInterface {

  /**
   * {@inheritdoc}
   */
  protected $usesOptions = TRUE;

  /**
   * {@inheritdoc}
   */
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['submit_button'] = [
      'default' => $this
        ->t('Apply'),
    ];
    $options['reset_button'] = [
      'default' => FALSE,
    ];
    $options['reset_button_label'] = [
      'default' => $this
        ->t('Reset'),
    ];
    $options['exposed_sorts_label'] = [
      'default' => $this
        ->t('Sort by'),
    ];
    $options['expose_sort_order'] = [
      'default' => TRUE,
    ];
    $options['sort_asc_label'] = [
      'default' => $this
        ->t('Asc'),
    ];
    $options['sort_desc_label'] = [
      'default' => $this
        ->t('Desc'),
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    $form['submit_button'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Submit button text'),
      '#default_value' => $this->options['submit_button'],
      '#required' => TRUE,
    ];
    $form['reset_button'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Include reset button (resets all applied exposed filters)'),
      '#default_value' => $this->options['reset_button'],
    ];
    $form['reset_button_label'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Reset button label'),
      '#description' => $this
        ->t('Text to display in the reset button of the exposed form.'),
      '#default_value' => $this->options['reset_button_label'],
      '#required' => TRUE,
      '#states' => [
        'invisible' => [
          'input[name="exposed_form_options[reset_button]"]' => [
            'checked' => FALSE,
          ],
        ],
      ],
    ];
    $form['exposed_sorts_label'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Exposed sorts label'),
      '#default_value' => $this->options['exposed_sorts_label'],
      '#required' => TRUE,
    ];
    $form['expose_sort_order'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Allow people to choose the sort order'),
      '#description' => $this
        ->t('If sort order is not exposed, the sort criteria settings for each sort will determine its order.'),
      '#default_value' => $this->options['expose_sort_order'],
    ];
    $form['sort_asc_label'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Label for ascending sort'),
      '#default_value' => $this->options['sort_asc_label'],
      '#required' => TRUE,
      '#states' => [
        'visible' => [
          'input[name="exposed_form_options[expose_sort_order]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
    $form['sort_desc_label'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Label for descending sort'),
      '#default_value' => $this->options['sort_desc_label'],
      '#required' => TRUE,
      '#states' => [
        'visible' => [
          'input[name="exposed_form_options[expose_sort_order]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function renderExposedForm($block = FALSE) {

    // Deal with any exposed filters we may have, before building.
    $form_state = (new FormState())
      ->setStorage([
      'view' => $this->view,
      'display' => &$this->view->display_handler->display,
      'rerender' => TRUE,
    ])
      ->setMethod('get')
      ->setAlwaysProcess()
      ->disableRedirect();

    // Some types of displays (eg. attachments) may wish to use the exposed
    // filters of their parent displays instead of showing an additional
    // exposed filter form for the attachment as well as that for the parent.
    if (!$this->view->display_handler
      ->displaysExposed() || !$block && $this->view->display_handler
      ->getOption('exposed_block')) {
      $form_state
        ->set('rerender', NULL);
    }
    if (!empty($this->ajax)) {
      $form_state
        ->set('ajax', TRUE);
    }
    $form = \Drupal::formBuilder()
      ->buildForm('\\Drupal\\views\\Form\\ViewsExposedForm', $form_state);
    $errors = $form_state
      ->getErrors();

    // If the exposed form had errors, do not build the view.
    if (!empty($errors)) {
      $this->view->build_info['abort'] = TRUE;
    }
    if (!$this->view->display_handler
      ->displaysExposed() || !$block && $this->view->display_handler
      ->getOption('exposed_block')) {
      return [];
    }
    else {
      return $form;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function query() {
    $view = $this->view;
    $exposed_data = isset($view->exposed_data) ? $view->exposed_data : [];
    $sort_by = isset($exposed_data['sort_by']) ? $exposed_data['sort_by'] : NULL;
    if (!empty($sort_by)) {

      // Make sure the original order of sorts is preserved
      // (e.g. a sticky sort is often first)
      if (isset($view->sort[$sort_by])) {
        $view->query->orderby = [];
        foreach ($view->sort as $key => $sort) {
          if (!$sort
            ->isExposed()) {
            $sort
              ->query();
          }
          elseif ($key == $sort_by) {
            if (isset($exposed_data['sort_order']) && in_array($exposed_data['sort_order'], [
              'ASC',
              'DESC',
            ])) {
              $sort->options['order'] = $exposed_data['sort_order'];
            }
            $sort
              ->setRelationship();
            $sort
              ->query();
          }
        }
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function preRender($values) {
  }

  /**
   * {@inheritdoc}
   */
  public function postRender(&$output) {
  }

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

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

  /**
   * {@inheritdoc}
   */
  public function exposedFormAlter(&$form, FormStateInterface $form_state) {
    if (!empty($this->options['submit_button'])) {
      $form['actions']['submit']['#value'] = $this->options['submit_button'];
    }

    // Check if there is exposed sorts for this view
    $exposed_sorts = [];
    foreach ($this->view->sort as $id => $handler) {
      if ($handler
        ->canExpose() && $handler
        ->isExposed()) {
        $exposed_sorts[$id] = $handler->options['expose']['label'];
      }
    }
    if (count($exposed_sorts)) {
      $form['sort_by'] = [
        '#type' => 'select',
        '#options' => $exposed_sorts,
        '#title' => $this->options['exposed_sorts_label'],
      ];
      $sort_order = [
        'ASC' => $this->options['sort_asc_label'],
        'DESC' => $this->options['sort_desc_label'],
      ];
      $user_input = $form_state
        ->getUserInput();
      if (isset($user_input['sort_by']) && isset($this->view->sort[$user_input['sort_by']])) {
        $default_sort_order = $this->view->sort[$user_input['sort_by']]->options['order'];
      }
      else {
        $first_sort = reset($this->view->sort);
        $default_sort_order = $first_sort->options['order'];
      }
      if (!isset($user_input['sort_by'])) {
        $keys = array_keys($exposed_sorts);
        $user_input['sort_by'] = array_shift($keys);
        $form_state
          ->setUserInput($user_input);
      }
      if ($this->options['expose_sort_order']) {
        $form['sort_order'] = [
          '#type' => 'select',
          '#options' => $sort_order,
          '#title' => $this
            ->t('Order', [], [
            'context' => 'Sort order',
          ]),
          '#default_value' => $default_sort_order,
        ];
      }
    }
    if (!empty($this->options['reset_button'])) {
      $form['actions']['reset'] = [
        '#value' => $this->options['reset_button_label'],
        '#type' => 'submit',
        '#weight' => 10,
      ];

      // Get an array of exposed filters, keyed by identifier option.
      $exposed_filters = [];
      foreach ($this->view->filter as $id => $handler) {
        if ($handler
          ->canExpose() && $handler
          ->isExposed() && !empty($handler->options['expose']['identifier'])) {
          $exposed_filters[$handler->options['expose']['identifier']] = $id;
        }
      }
      $all_exposed = array_merge($exposed_sorts, $exposed_filters);

      // Set the access to FALSE if there is no exposed input.
      if (!array_intersect_key($all_exposed, $this->view
        ->getExposedInput())) {
        $form['actions']['reset']['#access'] = FALSE;
      }
    }
    $pager = $this->view->display_handler
      ->getPlugin('pager');
    if ($pager) {
      $pager
        ->exposedFormAlter($form, $form_state);
      $form_state
        ->set('pager_plugin', $pager);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function exposedFormValidate(&$form, FormStateInterface $form_state) {
    if ($pager_plugin = $form_state
      ->get('pager_plugin')) {
      $pager_plugin
        ->exposedFormValidate($form, $form_state);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function exposedFormSubmit(&$form, FormStateInterface $form_state, &$exclude) {
    if (!$form_state
      ->isValueEmpty('op') && $form_state
      ->getValue('op') == $this->options['reset_button_label']) {
      $this
        ->resetForm($form, $form_state);
    }
    if ($pager_plugin = $form_state
      ->get('pager_plugin')) {
      $pager_plugin
        ->exposedFormSubmit($form, $form_state, $exclude);
      $exclude[] = 'pager_plugin';
    }
  }

  /**
   * Resets all the states of the exposed form.
   *
   * This method is called when the "Reset" button is triggered. Clears
   * user inputs, stored session, and the form state.
   *
   * @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 resetForm(&$form, FormStateInterface $form_state) {

    // _SESSION is not defined for users who are not logged in.
    // If filters are not overridden, store the 'remember' settings on the
    // default display. If they are, store them on this display. This way,
    // multiple displays in the same view can share the same filters and
    // remember settings.
    $display_id = $this->view->display_handler
      ->isDefaulted('filters') ? 'default' : $this->view->current_display;
    if (isset($_SESSION['views'][$this->view->storage
      ->id()][$display_id])) {
      unset($_SESSION['views'][$this->view->storage
        ->id()][$display_id]);
    }

    // Set the form to allow redirect.
    if (empty($this->view->live_preview) && !\Drupal::request()
      ->isXmlHttpRequest()) {
      $form_state
        ->disableRedirect(FALSE);
    }
    else {
      $form_state
        ->setRebuild();
      $this->view->exposed_data = [];
    }
    $form_state
      ->setRedirect('<current>');
    $form_state
      ->setValues([]);
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheMaxAge() {
    return Cache::PERMANENT;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheContexts() {
    $contexts = [];
    if ($this->options['expose_sort_order']) {

      // The sort order query arg is just important in case there is a exposed
      // sort order.
      $has_exposed_sort_handler = FALSE;

      /** @var \Drupal\views\Plugin\views\sort\SortPluginBase $sort_handler */
      foreach ($this->displayHandler
        ->getHandlers('sort') as $sort_handler) {
        if ($sort_handler
          ->isExposed()) {
          $has_exposed_sort_handler = TRUE;
        }
      }
      if ($has_exposed_sort_handler) {
        $contexts[] = 'url.query_args:sort_order';
      }
    }

    // Merge in cache contexts for all exposed filters to prevent display of
    // cached forms.
    foreach ($this->displayHandler
      ->getHandlers('filter') as $filter_handler) {
      if ($filter_handler
        ->isExposed()) {
        $contexts = Cache::mergeContexts($contexts, $filter_handler
          ->getCacheContexts());
      }
    }
    return $contexts;
  }

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

}

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
ExposedFormPluginBase::$usesOptions protected property Denotes whether the plugin has an additional options form. Overrides PluginBase::$usesOptions
ExposedFormPluginBase::buildOptionsForm public function Provide a form to edit options for this plugin. Overrides PluginBase::buildOptionsForm 1
ExposedFormPluginBase::defineOptions protected function Information about options for all kinds of purposes will be held here. Overrides PluginBase::defineOptions 1
ExposedFormPluginBase::exposedFormAlter public function Alters the exposed form. Overrides ExposedFormPluginInterface::exposedFormAlter
ExposedFormPluginBase::exposedFormSubmit public function Submits the exposed form. Overrides ExposedFormPluginInterface::exposedFormSubmit
ExposedFormPluginBase::exposedFormValidate public function Validates the exposed form submission. Overrides ExposedFormPluginInterface::exposedFormValidate
ExposedFormPluginBase::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyInterface::getCacheContexts
ExposedFormPluginBase::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyInterface::getCacheMaxAge
ExposedFormPluginBase::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyInterface::getCacheTags
ExposedFormPluginBase::postExecute public function Runs after the view has been executed. Overrides ExposedFormPluginInterface::postExecute
ExposedFormPluginBase::postRender public function Runs after the view has been rendered. Overrides ExposedFormPluginInterface::postRender
ExposedFormPluginBase::preExecute public function Runs before the view has been executed. Overrides ExposedFormPluginInterface::preExecute
ExposedFormPluginBase::preRender public function Runs before the view is rendered. Overrides ExposedFormPluginInterface::preRender 1
ExposedFormPluginBase::query public function Add anything to the query that we might need to. Overrides PluginBase::query 1
ExposedFormPluginBase::renderExposedForm public function Renders the exposed form. Overrides ExposedFormPluginInterface::renderExposedForm
ExposedFormPluginBase::resetForm public function Resets all the states of the exposed 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::$renderer protected property Stores the render API renderer. 3
PluginBase::$view public property The top object of a view. 1
PluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies 14
PluginBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create 62
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::getRenderer protected function Returns the render API renderer. 1
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::init public function Initialize the plugin. Overrides ViewsPluginInterface::init 8
PluginBase::isConfigurable public function Determines if the plugin is configurable.
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::submitOptionsForm public function Handle any special handling on the validate form. Overrides ViewsPluginInterface::submitOptionsForm 16
PluginBase::summaryTitle public function Returns the summary of the settings in the display. Overrides ViewsPluginInterface::summaryTitle 6
PluginBase::themeFunctions public function Provide a full list of possible theme templates used by this style. Overrides ViewsPluginInterface::themeFunctions 1
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::validate public function Validate that the plugin is correct and can be saved. Overrides ViewsPluginInterface::validate 6
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.
PluginBase::__construct public function Constructs a PluginBase object. Overrides PluginBase::__construct
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.