You are here

Home » API reference » Drupal 8 » ArgumentPluginBase.php

abstract class ArgumentPluginBase in Drupal 8

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

Base class for argument (contextual filter) handler plugins.

The basic argument works for very simple arguments such as nid and uid

Definition terms for this handler:

  • name field: The field to use for the name to use in the summary, which is the displayed output. For example, for the node: nid argument, the argument itself is the nid, but node.title is displayed.
  • name table: The table to use for the name, should it not be in the same table as the argument.
  • empty field name: For arguments that can have no value, such as taxonomy which can have "no term", this is the string which will be displayed for this lack of value. Be sure to use $this->t().
  • validate type: A little used string to allow an argument to restrict which validator is available to just one. Use the validator ID. This probably should not be used at all, and may disappear or change.
  • numeric: If set to TRUE this field is numeric and will use %d instead of %s in queries.

Hierarchy

Expanded class hierarchy of ArgumentPluginBase

Related topics

Views argument handlers
Handler plugins for Views contextual filters.
9 files declare their use of ArgumentPluginBase
ArgumentDefaultPluginBase.php in core/modules/views/src/Plugin/views/argument_default/ArgumentDefaultPluginBase.php
ArgumentValidateTest.php in core/modules/user/tests/src/Kernel/Views/ArgumentValidateTest.php
ArgumentValidatorPluginBase.php in core/modules/views/src/Plugin/views/argument_validator/ArgumentValidatorPluginBase.php
Entity.php in core/modules/views/src/Plugin/views/argument_validator/Entity.php
IndexTidDepth.php in core/modules/taxonomy/src/Plugin/views/argument/IndexTidDepth.php

... See full list

File

core/modules/views/src/Plugin/views/argument/ArgumentPluginBase.php, line 56

Namespace

Drupal\views\Plugin\views\argument
View source 
abstract class ArgumentPluginBase extends HandlerBase implements CacheableDependencyInterface {
  public $validator = NULL;
  public $argument = NULL;
  public $value = NULL;

  /**
   * The table to use for the name, should it not be in the same table as the argument.
   * @var string
   */
  public $name_table;

  /**
   * The field to use for the name to use in the summary, which is
   * the displayed output. For example, for the node: nid argument,
   * the argument itself is the nid, but node.title is displayed.
   * @var string
   */
  public $name_field;

  /**
   * Overrides Drupal\views\Plugin\views\HandlerBase:init().
   */
  public function init(ViewExecutable $view, DisplayPluginBase $display, array &$options = NULL) {
    parent::init($view, $display, $options);
    if (!empty($this->definition['name field'])) {
      $this->name_field = $this->definition['name field'];
    }
    if (!empty($this->definition['name table'])) {
      $this->name_table = $this->definition['name table'];
    }
  }
  public function isException($arg = NULL) {
    if (!isset($arg)) {
      $arg = isset($this->argument) ? $this->argument : NULL;
    }
    return !empty($this->options['exception']['value']) && $this->options['exception']['value'] === $arg;
  }
  public function exceptionTitle() {

    // If title overriding is off for the exception, return the normal title.
    if (empty($this->options['exception']['title_enable'])) {
      return $this
        ->getTitle();
    }
    return $this->options['exception']['title'];
  }

  /**
   * Determine if the argument needs a style plugin.
   *
   * @return bool
   */
  public function needsStylePlugin() {
    $info = $this
      ->defaultActions($this->options['default_action']);
    $validate_info = $this
      ->defaultActions($this->options['validate']['fail']);
    return !empty($info['style plugin']) || !empty($validate_info['style plugin']);
  }
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['default_action'] = [
      'default' => 'ignore',
    ];
    $options['exception'] = [
      'contains' => [
        'value' => [
          'default' => 'all',
        ],
        'title_enable' => [
          'default' => FALSE,
        ],
        'title' => [
          'default' => 'All',
        ],
      ],
    ];
    $options['title_enable'] = [
      'default' => FALSE,
    ];
    $options['title'] = [
      'default' => '',
    ];
    $options['default_argument_type'] = [
      'default' => 'fixed',
    ];
    $options['default_argument_options'] = [
      'default' => [],
    ];
    $options['default_argument_skip_url'] = [
      'default' => FALSE,
    ];
    $options['summary_options'] = [
      'default' => [],
    ];
    $options['summary'] = [
      'contains' => [
        'sort_order' => [
          'default' => 'asc',
        ],
        'number_of_records' => [
          'default' => 0,
        ],
        'format' => [
          'default' => 'default_summary',
        ],
      ],
    ];
    $options['specify_validation'] = [
      'default' => FALSE,
    ];
    $options['validate'] = [
      'contains' => [
        'type' => [
          'default' => 'none',
        ],
        'fail' => [
          'default' => 'not found',
        ],
      ],
    ];
    $options['validate_options'] = [
      'default' => [],
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public static function trustedCallbacks() {
    $callbacks = parent::trustedCallbacks();
    $callbacks[] = 'preRenderMoveArgumentOptions';
    return $callbacks;
  }
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    $argument_text = $this->view->display_handler
      ->getArgumentText();
    $form['#pre_render'][] = [
      get_class($this),
      'preRenderMoveArgumentOptions',
    ];
    $form['description'] = [
      '#markup' => $argument_text['description'],
      '#theme_wrappers' => [
        'container',
      ],
      '#attributes' => [
        'class' => [
          'description',
        ],
      ],
    ];
    $form['no_argument'] = [
      '#type' => 'details',
      '#title' => $argument_text['filter value not present'],
      '#open' => TRUE,
    ];

    // Everything in the details is floated, so the last element needs to
    // clear those floats.
    $form['no_argument']['clearfix'] = [
      '#weight' => 1000,
      '#markup' => '<div class="clearfix"></div>',
    ];
    $form['default_action'] = [
      '#title' => $this
        ->t('Default actions'),
      '#title_display' => 'invisible',
      '#type' => 'radios',
      '#process' => [
        [
          $this,
          'processContainerRadios',
        ],
      ],
      '#default_value' => $this->options['default_action'],
      '#fieldset' => 'no_argument',
    ];
    $form['exception'] = [
      '#type' => 'details',
      '#title' => $this
        ->t('Exceptions'),
      '#fieldset' => 'no_argument',
    ];
    $form['exception']['value'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Exception value'),
      '#size' => 20,
      '#default_value' => $this->options['exception']['value'],
      '#description' => $this
        ->t('If this value is received, the filter will be ignored; i.e, "all values"'),
    ];
    $form['exception']['title_enable'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Override title'),
      '#default_value' => $this->options['exception']['title_enable'],
    ];
    $form['exception']['title'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Override title'),
      '#title_display' => 'invisible',
      '#size' => 20,
      '#default_value' => $this->options['exception']['title'],
      '#description' => $this
        ->t('Override the view and other argument titles. You may use Twig syntax in this field as well as the "arguments" and "raw_arguments" arrays.'),
      '#states' => [
        'visible' => [
          ':input[name="options[exception][title_enable]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
    $options = [];
    $defaults = $this
      ->defaultActions();
    $validate_options = [];
    foreach ($defaults as $id => $info) {
      $options[$id] = $info['title'];
      if (empty($info['default only'])) {
        $validate_options[$id] = $info['title'];
      }
      if (!empty($info['form method'])) {
        $this
          ->{$info['form method']}($form, $form_state);
      }
    }
    $form['default_action']['#options'] = $options;
    $form['argument_present'] = [
      '#type' => 'details',
      '#title' => $argument_text['filter value present'],
      '#open' => TRUE,
    ];
    $form['title_enable'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Override title'),
      '#default_value' => $this->options['title_enable'],
      '#fieldset' => 'argument_present',
    ];
    $form['title'] = [
      '#type' => 'textfield',
      '#title' => $this
        ->t('Provide title'),
      '#title_display' => 'invisible',
      '#default_value' => $this->options['title'],
      '#description' => $this
        ->t('Override the view and other argument titles. You may use Twig syntax in this field.'),
      '#states' => [
        'visible' => [
          ':input[name="options[title_enable]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
      '#fieldset' => 'argument_present',
    ];
    $output = $this
      ->getTokenHelp();
    $form['token_help'] = [
      '#type' => 'details',
      '#title' => $this
        ->t('Replacement patterns'),
      '#value' => $output,
      '#states' => [
        'visible' => [
          [
            ':input[name="options[title_enable]"]' => [
              'checked' => TRUE,
            ],
          ],
          [
            ':input[name="options[exception][title_enable]"]' => [
              'checked' => TRUE,
            ],
          ],
        ],
      ],
    ];
    $form['specify_validation'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Specify validation criteria'),
      '#default_value' => $this->options['specify_validation'],
      '#fieldset' => 'argument_present',
    ];
    $form['validate'] = [
      '#type' => 'container',
      '#fieldset' => 'argument_present',
    ];

    // Validator options include derivatives with :. These are sanitized for js
    // and reverted on submission.
    $form['validate']['type'] = [
      '#type' => 'select',
      '#title' => $this
        ->t('Validator'),
      '#default_value' => static::encodeValidatorId($this->options['validate']['type']),
      '#states' => [
        'visible' => [
          ':input[name="options[specify_validation]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
    $plugins = Views::pluginManager('argument_validator')
      ->getDefinitions();
    foreach ($plugins as $id => $info) {
      if (!empty($info['no_ui'])) {
        continue;
      }
      $valid = TRUE;
      if (!empty($info['type'])) {
        $valid = FALSE;
        if (empty($this->definition['validate type'])) {
          continue;
        }
        foreach ((array) $info['type'] as $type) {
          if ($type == $this->definition['validate type']) {
            $valid = TRUE;
            break;
          }
        }
      }

      // If we decide this validator is ok, add it to the list.
      if ($valid) {
        $plugin = $this
          ->getPlugin('argument_validator', $id);
        if ($plugin) {
          if ($plugin
            ->access() || $this->options['validate']['type'] == $id) {

            // Sanitize ID for js.
            $sanitized_id = static::encodeValidatorId($id);
            $form['validate']['options'][$sanitized_id] = [
              '#prefix' => '<div id="edit-options-validate-options-' . $sanitized_id . '-wrapper">',
              '#suffix' => '</div>',
              '#type' => 'item',
              // Even if the plugin has no options add the key to the form_state.
              // trick it into checking input to make #process run.
              '#input' => TRUE,
              '#states' => [
                'visible' => [
                  ':input[name="options[specify_validation]"]' => [
                    'checked' => TRUE,
                  ],
                  ':input[name="options[validate][type]"]' => [
                    'value' => $sanitized_id,
                  ],
                ],
              ],
              '#id' => 'edit-options-validate-options-' . $sanitized_id,
              '#default_value' => [],
            ];
            $plugin
              ->buildOptionsForm($form['validate']['options'][$sanitized_id], $form_state);
            $validate_types[$sanitized_id] = $info['title'];
          }
        }
      }
    }
    asort($validate_types);
    $form['validate']['type']['#options'] = $validate_types;
    $form['validate']['fail'] = [
      '#type' => 'select',
      '#title' => $this
        ->t('Action to take if filter value does not validate'),
      '#default_value' => $this->options['validate']['fail'],
      '#options' => $validate_options,
      '#states' => [
        'visible' => [
          ':input[name="options[specify_validation]"]' => [
            'checked' => TRUE,
          ],
        ],
      ],
      '#fieldset' => 'argument_present',
    ];
  }

  /**
   * Provide token help information for the argument.
   *
   * @return array
   *   A render array.
   */
  protected function getTokenHelp() {
    $output = [];
    foreach ($this->view->display_handler
      ->getHandlers('argument') as $arg => $handler) {

      /** @var \Drupal\views\Plugin\views\argument\ArgumentPluginBase $handler */
      $options[(string) t('Arguments')]["{{ arguments.{$arg} }}"] = $this
        ->t('@argument title', [
        '@argument' => $handler
          ->adminLabel(),
      ]);
      $options[(string) t('Arguments')]["{{ raw_arguments.{$arg} }}"] = $this
        ->t('@argument input', [
        '@argument' => $handler
          ->adminLabel(),
      ]);
    }

    // We have some options, so make a list.
    if (!empty($options)) {
      $output[] = [
        '#markup' => '<p>' . $this
          ->t("The following replacement tokens are available for this argument.") . '</p>',
      ];
      foreach (array_keys($options) as $type) {
        if (!empty($options[$type])) {
          $items = [];
          foreach ($options[$type] as $key => $value) {
            $items[] = $key . ' == ' . $value;
          }
          $item_list = [
            '#theme' => 'item_list',
            '#items' => $items,
          ];
          $output[] = $item_list;
        }
      }
    }
    return $output;
  }
  public function validateOptionsForm(&$form, FormStateInterface $form_state) {
    $option_values =& $form_state
      ->getValue('options');
    if (empty($option_values)) {
      return;
    }

    // Let the plugins do validation.
    $default_id = $option_values['default_argument_type'];
    $plugin = $this
      ->getPlugin('argument_default', $default_id);
    if ($plugin) {
      $plugin
        ->validateOptionsForm($form['argument_default'][$default_id], $form_state, $option_values['argument_default'][$default_id]);
    }

    // summary plugin
    $summary_id = $option_values['summary']['format'];
    $plugin = $this
      ->getPlugin('style', $summary_id);
    if ($plugin) {
      $plugin
        ->validateOptionsForm($form['summary']['options'][$summary_id], $form_state, $option_values['summary']['options'][$summary_id]);
    }
    $sanitized_id = $option_values['validate']['type'];

    // Correct ID for js sanitized version.
    $validate_id = static::decodeValidatorId($sanitized_id);
    $plugin = $this
      ->getPlugin('argument_validator', $validate_id);
    if ($plugin) {
      $plugin
        ->validateOptionsForm($form['validate']['options'][$default_id], $form_state, $option_values['validate']['options'][$sanitized_id]);
    }
  }
  public function submitOptionsForm(&$form, FormStateInterface $form_state) {
    $option_values =& $form_state
      ->getValue('options');
    if (empty($option_values)) {
      return;
    }

    // Let the plugins make submit modifications if necessary.
    $default_id = $option_values['default_argument_type'];
    $plugin = $this
      ->getPlugin('argument_default', $default_id);
    if ($plugin) {
      $options =& $option_values['argument_default'][$default_id];
      $plugin
        ->submitOptionsForm($form['argument_default'][$default_id], $form_state, $options);

      // Copy the now submitted options to their final resting place so they get saved.
      $option_values['default_argument_options'] = $options;
    }

    // summary plugin
    $summary_id = $option_values['summary']['format'];
    $plugin = $this
      ->getPlugin('style', $summary_id);
    if ($plugin) {
      $options =& $option_values['summary']['options'][$summary_id];
      $plugin
        ->submitOptionsForm($form['summary']['options'][$summary_id], $form_state, $options);

      // Copy the now submitted options to their final resting place so they get saved.
      $option_values['summary_options'] = $options;
    }

    // If the 'Specify validation criteria' checkbox is not checked, reset the
    // validation options.
    if (empty($option_values['specify_validation'])) {
      $option_values['validate']['type'] = 'none';

      // We need to keep the empty array of options for the 'None' plugin as
      // it will be needed later.
      $option_values['validate']['options'] = [
        'none' => [],
      ];
      $option_values['validate']['fail'] = 'not found';
    }
    $sanitized_id = $option_values['validate']['type'];

    // Correct ID for js sanitized version.
    $option_values['validate']['type'] = $validate_id = static::decodeValidatorId($sanitized_id);
    $plugin = $this
      ->getPlugin('argument_validator', $validate_id);
    if ($plugin) {
      $options =& $option_values['validate']['options'][$sanitized_id];
      $plugin
        ->submitOptionsForm($form['validate']['options'][$sanitized_id], $form_state, $options);

      // Copy the now submitted options to their final resting place so they get saved.
      $option_values['validate_options'] = $options;
    }

    // Clear out the content of title if it's not enabled.
    if (empty($option_values['title_enable'])) {
      $option_values['title'] = '';
    }
  }

  /**
   * Provide a list of default behaviors for this argument if the argument
   * is not present.
   *
   * Override this method to provide additional (or fewer) default behaviors.
   */
  protected function defaultActions($which = NULL) {
    $defaults = [
      'ignore' => [
        'title' => $this
          ->t('Display all results for the specified field'),
        'method' => 'defaultIgnore',
      ],
      'default' => [
        'title' => $this
          ->t('Provide default value'),
        'method' => 'defaultDefault',
        'form method' => 'defaultArgumentForm',
        'has default argument' => TRUE,
        // This can only be used for missing argument, not validation failure.
        'default only' => TRUE,
      ],
      'not found' => [
        'title' => $this
          ->t('Hide view'),
        'method' => 'defaultNotFound',
        // This is a hard fail condition.
        'hard fail' => TRUE,
      ],
      'summary' => [
        'title' => $this
          ->t('Display a summary'),
        'method' => 'defaultSummary',
        'form method' => 'defaultSummaryForm',
        'style plugin' => TRUE,
      ],
      'empty' => [
        'title' => $this
          ->t('Display contents of "No results found"'),
        'method' => 'defaultEmpty',
      ],
      'access denied' => [
        'title' => $this
          ->t('Display "Access Denied"'),
        'method' => 'defaultAccessDenied',
      ],
    ];
    if ($this->view->display_handler
      ->hasPath()) {
      $defaults['not found']['title'] = $this
        ->t('Show "Page not found"');
    }
    if ($which) {
      if (!empty($defaults[$which])) {
        return $defaults[$which];
      }
    }
    else {
      return $defaults;
    }
  }

  /**
   * Provide a form for selecting the default argument when the
   * default action is set to provide default argument.
   */
  public function defaultArgumentForm(&$form, FormStateInterface $form_state) {
    $plugins = Views::pluginManager('argument_default')
      ->getDefinitions();
    $options = [];
    $form['default_argument_skip_url'] = [
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Skip default argument for view URL'),
      '#default_value' => $this->options['default_argument_skip_url'],
      '#description' => $this
        ->t('Select whether to include this default argument when constructing the URL for this view. Skipping default arguments is useful e.g. in the case of feeds.'),
    ];
    $form['default_argument_type'] = [
      '#prefix' => '<div id="edit-options-default-argument-type-wrapper">',
      '#suffix' => '</div>',
      '#type' => 'select',
      '#id' => 'edit-options-default-argument-type',
      '#title' => $this
        ->t('Type'),
      '#default_value' => $this->options['default_argument_type'],
      '#states' => [
        'visible' => [
          ':input[name="options[default_action]"]' => [
            'value' => 'default',
          ],
        ],
      ],
      // Views custom key, moves this element to the appropriate container
      // under the radio button.
      '#argument_option' => 'default',
    ];
    foreach ($plugins as $id => $info) {
      if (!empty($info['no_ui'])) {
        continue;
      }
      $plugin = $this
        ->getPlugin('argument_default', $id);
      if ($plugin) {
        if ($plugin
          ->access() || $this->options['default_argument_type'] == $id) {
          $form['argument_default']['#argument_option'] = 'default';
          $form['argument_default'][$id] = [
            '#prefix' => '<div id="edit-options-argument-default-options-' . $id . '-wrapper">',
            '#suffix' => '</div>',
            '#id' => 'edit-options-argument-default-options-' . $id,
            '#type' => 'item',
            // Even if the plugin has no options add the key to the form_state.
            '#input' => TRUE,
            '#states' => [
              'visible' => [
                ':input[name="options[default_action]"]' => [
                  'value' => 'default',
                ],
                ':input[name="options[default_argument_type]"]' => [
                  'value' => $id,
                ],
              ],
            ],
            '#default_value' => [],
          ];
          $options[$id] = $info['title'];
          $plugin
            ->buildOptionsForm($form['argument_default'][$id], $form_state);
        }
      }
    }
    asort($options);
    $form['default_argument_type']['#options'] = $options;
  }

  /**
   * Provide a form for selecting further summary options when the
   * default action is set to display one.
   */
  public function defaultSummaryForm(&$form, FormStateInterface $form_state) {
    $style_plugins = Views::pluginManager('style')
      ->getDefinitions();
    $summary_plugins = [];
    $format_options = [];
    foreach ($style_plugins as $key => $plugin) {
      if (isset($plugin['display_types']) && in_array('summary', $plugin['display_types'])) {
        $summary_plugins[$key] = $plugin;
        $format_options[$key] = $plugin['title'];
      }
    }
    $form['summary'] = [
      // Views custom key, moves this element to the appropriate container
      // under the radio button.
      '#argument_option' => 'summary',
    ];
    $form['summary']['sort_order'] = [
      '#type' => 'radios',
      '#title' => $this
        ->t('Sort order'),
      '#options' => [
        'asc' => $this
          ->t('Ascending'),
        'desc' => $this
          ->t('Descending'),
      ],
      '#default_value' => $this->options['summary']['sort_order'],
      '#states' => [
        'visible' => [
          ':input[name="options[default_action]"]' => [
            'value' => 'summary',
          ],
        ],
      ],
    ];
    $form['summary']['number_of_records'] = [
      '#type' => 'radios',
      '#title' => $this
        ->t('Sort by'),
      '#default_value' => $this->options['summary']['number_of_records'],
      '#options' => [
        0 => $this
          ->getSortName(),
        1 => $this
          ->t('Number of records'),
      ],
      '#states' => [
        'visible' => [
          ':input[name="options[default_action]"]' => [
            'value' => 'summary',
          ],
        ],
      ],
    ];
    $form['summary']['format'] = [
      '#type' => 'radios',
      '#title' => $this
        ->t('Format'),
      '#options' => $format_options,
      '#default_value' => $this->options['summary']['format'],
      '#states' => [
        'visible' => [
          ':input[name="options[default_action]"]' => [
            'value' => 'summary',
          ],
        ],
      ],
    ];
    foreach ($summary_plugins as $id => $info) {
      $plugin = $this
        ->getPlugin('style', $id);
      if (!$plugin
        ->usesOptions()) {
        continue;
      }
      if ($plugin) {
        $form['summary']['options'][$id] = [
          '#prefix' => '<div id="edit-options-summary-options-' . $id . '-wrapper">',
          '#suffix' => '</div>',
          '#id' => 'edit-options-summary-options-' . $id,
          '#type' => 'item',
          // Trick it into checking input to make #process run.
          '#input' => TRUE,
          '#states' => [
            'visible' => [
              ':input[name="options[default_action]"]' => [
                'value' => 'summary',
              ],
              ':input[name="options[summary][format]"]' => [
                'value' => $id,
              ],
            ],
          ],
          '#default_value' => [],
        ];
        $options[$id] = $info['title'];
        $plugin
          ->buildOptionsForm($form['summary']['options'][$id], $form_state);
      }
    }
  }

  /**
   * Handle the default action, which means our argument wasn't present.
   *
   * Override this method only with extreme care.
   *
   * @return
   *   A boolean value; if TRUE, continue building this view. If FALSE,
   *   building the view will be aborted here.
   */
  public function defaultAction($info = NULL) {
    if (!isset($info)) {
      $info = $this
        ->defaultActions($this->options['default_action']);
    }
    if (!$info) {
      return FALSE;
    }
    if (!empty($info['method args'])) {
      return call_user_func_array([
        &$this,
        $info['method'],
      ], $info['method args']);
    }
    else {
      return $this
        ->{$info['method']}();
    }
  }

  /**
   * How to act if validation fails.
   */
  public function validateFail() {
    $info = $this
      ->defaultActions($this->options['validate']['fail']);
    return $this
      ->defaultAction($info);
  }

  /**
   * Default action: ignore.
   *
   * If an argument was expected and was not given, in this case, simply
   * ignore the argument entirely.
   */
  public function defaultIgnore() {
    return TRUE;
  }

  /**
   * Default action: not found.
   *
   * If an argument was expected and was not given, in this case, report
   * the view as 'not found' or hide it.
   */
  protected function defaultNotFound() {

    // Set a failure condition and let the display manager handle it.
    $this->view->build_info['fail'] = TRUE;
    return FALSE;
  }

  /**
   * Default action: access denied.
   *
   * If an argument was expected and was not given, in this case, report
   * the view as 'access denied'.
   */
  public function defaultAccessDenied() {
    $this->view->build_info['denied'] = TRUE;
    return FALSE;
  }

  /**
   * Default action: empty
   *
   * If an argument was expected and was not given, in this case, display
   * the view's empty text
   */
  public function defaultEmpty() {

    // We return with no query; this will force the empty text.
    $this->view->built = TRUE;
    $this->view->executed = TRUE;
    $this->view->result = [];
    return FALSE;
  }

  /**
   * This just returns true. The view argument builder will know where
   * to find the argument from.
   */
  protected function defaultDefault() {
    return TRUE;
  }

  /**
   * Determine if the argument is set to provide a default argument.
   */
  public function hasDefaultArgument() {
    $info = $this
      ->defaultActions($this->options['default_action']);
    return !empty($info['has default argument']);
  }

  /**
   * Get a default argument, if available.
   */
  public function getDefaultArgument() {
    $plugin = $this
      ->getPlugin('argument_default');
    if ($plugin) {
      return $plugin
        ->getArgument();
    }
  }

  /**
   * Process the summary arguments for display.
   *
   * For example, the validation plugin may want to alter an argument for use in
   * the URL.
   */
  public function processSummaryArguments(&$args) {
    if ($this->options['validate']['type'] != 'none') {
      if (isset($this->validator) || ($this->validator = $this
        ->getPlugin('argument_validator'))) {
        $this->validator
          ->processSummaryArguments($args);
      }
    }
  }

  /**
   * Default action: summary.
   *
   * If an argument was expected and was not given, in this case, display
   * a summary query.
   */
  protected function defaultSummary() {
    $this->view->build_info['summary'] = TRUE;
    $this->view->build_info['summary_level'] = $this->options['id'];

    // Change the display style to the summary style for this
    // argument.
    $this->view->style_plugin = Views::pluginManager("style")
      ->createInstance($this->options['summary']['format']);
    $this->view->style_plugin
      ->init($this->view, $this->displayHandler, $this->options['summary_options']);

    // Clear out the normal primary field and whatever else may have
    // been added and let the summary do the work.
    $this->query
      ->clearFields();
    $this
      ->summaryQuery();
    $by = $this->options['summary']['number_of_records'] ? 'num_records' : NULL;
    $this
      ->summarySort($this->options['summary']['sort_order'], $by);

    // Summaries have their own sorting and fields, so tell the View not
    // to build these.
    $this->view->build_sort = FALSE;
    return TRUE;
  }

  /**
   * Build the info for the summary query.
   *
   * This must:
   * - addGroupBy: group on this field in order to create summaries.
   * - addField: add a 'num_nodes' field for the count. Usually it will
   *   be a count on $view->base_field
   * - setCountField: Reset the count field so we get the right paging.
   *
   * @return
   *   The alias used to get the number of records (count) for this entry.
   */
  protected function summaryQuery() {
    $this
      ->ensureMyTable();

    // Add the field.
    $this->base_alias = $this->query
      ->addField($this->tableAlias, $this->realField);
    $this
      ->summaryNameField();
    return $this
      ->summaryBasics();
  }

  /**
   * Add the name field, which is the field displayed in summary queries.
   * This is often used when the argument is numeric.
   */
  protected function summaryNameField() {

    // Add the 'name' field. For example, if this is a uid argument, the
    // name field would be 'name' (i.e, the username).
    if (isset($this->name_table)) {

      // if the alias is different then we're probably added, not ensured,
      // so look up the join and add it instead.
      if ($this->tableAlias != $this->name_table) {
        $j = HandlerBase::getTableJoin($this->name_table, $this->table);
        if ($j) {
          $join = clone $j;
          $join->leftTable = $this->tableAlias;
          $this->name_table_alias = $this->query
            ->addTable($this->name_table, $this->relationship, $join);
        }
      }
      else {
        $this->name_table_alias = $this->query
          ->ensureTable($this->name_table, $this->relationship);
      }
    }
    else {
      $this->name_table_alias = $this->tableAlias;
    }
    if (isset($this->name_field)) {
      $this->name_alias = $this->query
        ->addField($this->name_table_alias, $this->name_field);
    }
    else {
      $this->name_alias = $this->base_alias;
    }
  }

  /**
   * Some basic summary behavior that doesn't need to be repeated as much as
   * code that goes into summaryQuery()
   */
  public function summaryBasics($count_field = TRUE) {

    // Add the number of nodes counter
    $distinct = $this->view->display_handler
      ->getOption('distinct') && empty($this->query->no_distinct);
    $count_alias = $this->query
      ->addField($this->view->storage
      ->get('base_table'), $this->view->storage
      ->get('base_field'), 'num_records', [
      'count' => TRUE,
      'distinct' => $distinct,
    ]);
    $this->query
      ->addGroupBy($this->name_alias);
    if ($count_field) {
      $this->query
        ->setCountField($this->tableAlias, $this->realField);
    }
    $this->count_alias = $count_alias;
  }

  /**
   * Sorts the summary based upon the user's selection. The base variant of
   * this is usually adequate.
   *
   * @param $order
   *   The order selected in the UI.
   */
  public function summarySort($order, $by = NULL) {
    $this->query
      ->addOrderBy(NULL, NULL, $order, !empty($by) ? $by : $this->name_alias);
  }

  /**
   * Provide the argument to use to link from the summary to the next level;
   * this will be called once per row of a summary, and used as part of
   * $view->getUrl().
   *
   * @param $data
   *   The query results for the row.
   */
  public function summaryArgument($data) {
    return $data->{$this->base_alias};
  }

  /**
   * Provides the name to use for the summary. By default this is just
   * the name field.
   *
   * @param $data
   *   The query results for the row.
   */
  public function summaryName($data) {
    $value = $data->{$this->name_alias};
    if (empty($value) && !empty($this->definition['empty field name'])) {
      $value = $this->definition['empty field name'];
    }
    return $value;
  }

  /**
   * Set up the query for this argument.
   *
   * The argument sent may be found at $this->argument.
   */
  public function query($group_by = FALSE) {
    $this
      ->ensureMyTable();
    $this->query
      ->addWhere(0, "{$this->tableAlias}.{$this->realField}", $this->argument);
  }

  /**
   * Get the title this argument will assign the view, given the argument.
   *
   * This usually needs to be overridden to provide a proper title.
   */
  public function title() {
    return $this->argument;
  }

  /**
   * Called by the view object to get the title. This may be set by a
   * validator so we don't necessarily call through to title().
   */
  public function getTitle() {
    if (isset($this->validated_title)) {
      return $this->validated_title;
    }
    else {
      return $this
        ->title();
    }
  }

  /**
   * Validate that this argument works. By default, all arguments are valid.
   */
  public function validateArgument($arg) {

    // By using % in URLs, arguments could be validated twice; this eases
    // that pain.
    if (isset($this->argument_validated)) {
      return $this->argument_validated;
    }
    if ($this
      ->isException($arg)) {
      return $this->argument_validated = TRUE;
    }
    $plugin = $this
      ->getPlugin('argument_validator');
    return $this->argument_validated = $plugin
      ->validateArgument($arg);
  }

  /**
   * Called by the menu system to validate an argument.
   *
   * This checks to see if this is a 'soft fail', which means that if the
   * argument fails to validate, but there is an action to take anyway,
   * then validation cannot actually fail.
   */
  public function validateMenuArgument($arg) {
    $validate_info = $this
      ->defaultActions($this->options['validate']['fail']);
    if (empty($validate_info['hard fail'])) {
      return TRUE;
    }
    $rc = $this
      ->validateArgument($arg);

    // If the validator has changed the validate fail condition to a
    // soft fail, deal with that:
    $validate_info = $this
      ->defaultActions($this->options['validate']['fail']);
    if (empty($validate_info['hard fail'])) {
      return TRUE;
    }
    return $rc;
  }

  /**
   * Set the input for this argument
   *
   * @return TRUE if it successfully validates; FALSE if it does not.
   */
  public function setArgument($arg) {
    $this->argument = $arg;
    return $this
      ->validateArgument($arg);
  }

  /**
   * Get the value of this argument.
   */
  public function getValue() {

    // If we already processed this argument, we're done.
    if (isset($this->argument)) {
      return $this->argument;
    }

    // Otherwise, we have to pretend to process ourselves to find the value.
    $value = NULL;

    // Find the position of this argument within the view.
    $position = 0;
    foreach ($this->view->argument as $id => $argument) {
      if ($id == $this->options['id']) {
        break;
      }
      $position++;
    }
    $arg = isset($this->view->args[$position]) ? $this->view->args[$position] : NULL;
    $this->position = $position;

    // Clone ourselves so that we don't break things when we're really
    // processing the arguments.
    $argument = clone $this;
    if (!isset($arg) && $argument
      ->hasDefaultArgument()) {
      $arg = $argument
        ->getDefaultArgument();

      // remember that this argument was computed, not passed on the URL.
      $this->is_default = TRUE;
    }

    // Set the argument, which will also validate that the argument can be set.
    if ($argument
      ->setArgument($arg)) {
      $value = $argument->argument;
    }
    unset($argument);
    return $value;
  }

  /**
   * Get the display or row plugin, if it exists.
   */
  public function getPlugin($type = 'argument_default', $name = NULL) {
    $options = [];
    switch ($type) {
      case 'argument_default':
        if (!isset($this->options['default_argument_type'])) {
          return;
        }
        $plugin_name = $this->options['default_argument_type'];
        $options_name = 'default_argument_options';
        break;
      case 'argument_validator':
        if (!isset($this->options['validate']['type'])) {
          return;
        }
        $plugin_name = $this->options['validate']['type'];
        $options_name = 'validate_options';
        break;
      case 'style':
        if (!isset($this->options['summary']['format'])) {
          return;
        }
        $plugin_name = $this->options['summary']['format'];
        $options_name = 'summary_options';
    }
    if (!$name) {
      $name = $plugin_name;
    }

    // we only fetch the options if we're fetching the plugin actually
    // in use.
    if ($name == $plugin_name) {
      $options = isset($this->options[$options_name]) ? $this->options[$options_name] : [];
    }
    $plugin = Views::pluginManager($type)
      ->createInstance($name);
    if ($plugin) {
      $plugin
        ->init($this->view, $this->displayHandler, $options);
      if ($type !== 'style') {

        // It's an argument_default/argument_validate plugin, so set the argument.
        $plugin
          ->setArgument($this);
      }
      return $plugin;
    }
  }

  /**
   * Return a description of how the argument would normally be sorted.
   *
   * Subclasses should override this to specify what the default sort order of
   * their argument is (e.g. alphabetical, numeric, date).
   */
  public function getSortName() {
    return $this
      ->t('Default sort', [], [
      'context' => 'Sort order',
    ]);
  }

  /**
   * Custom form radios process function.
   *
   * Roll out a single radios element to a list of radios, using the options
   * array as index. While doing that, create a container element underneath
   * each option, which contains the settings related to that option.
   *
   * @see \Drupal\Core\Render\Element\Radios::processRadios()
   */
  public static function processContainerRadios($element) {
    if (count($element['#options']) > 0) {
      foreach ($element['#options'] as $key => $choice) {
        $element += [
          $key => [],
        ];

        // Generate the parents as the autogenerator does, so we will have a
        // unique id for each radio button.
        $parents_for_id = array_merge($element['#parents'], [
          $key,
        ]);
        $element[$key] += [
          '#type' => 'radio',
          '#title' => $choice,
          // The key is sanitized in drupal_attributes() during output from the
          // theme function.
          '#return_value' => $key,
          '#default_value' => isset($element['#default_value']) ? $element['#default_value'] : NULL,
          '#attributes' => $element['#attributes'],
          '#parents' => $element['#parents'],
          '#id' => Html::getUniqueId('edit-' . implode('-', $parents_for_id)),
          '#ajax' => isset($element['#ajax']) ? $element['#ajax'] : NULL,
        ];
        $element[$key . '_options'] = [
          '#type' => 'container',
          '#attributes' => [
            'class' => [
              'views-admin-dependent',
            ],
          ],
        ];
      }
    }
    return $element;
  }

  /**
   * Moves argument options into their place.
   *
   * When configuring the default argument behavior, almost each of the radio
   * buttons has its own fieldset shown below it when the radio button is
   * clicked. That fieldset is created through a custom form process callback.
   * Each element that has #argument_option defined and pointing to a default
   * behavior gets moved to the appropriate fieldset.
   * So if #argument_option is specified as 'default', the element is moved
   * to the 'default_options' fieldset.
   */
  public static function preRenderMoveArgumentOptions($form) {
    foreach (Element::children($form) as $key) {
      $element = $form[$key];
      if (!empty($element['#argument_option'])) {
        $container_name = $element['#argument_option'] . '_options';
        if (isset($form['no_argument']['default_action'][$container_name])) {
          $form['no_argument']['default_action'][$container_name][$key] = $element;
        }

        // Remove the original element this duplicates.
        unset($form[$key]);
      }
    }
    return $form;
  }

  /**
   * Sanitize validator options including derivatives with : for js.
   *
   * Reason and alternative: https://www.drupal.org/node/2035345.
   *
   * @param string $id
   *   The identifier to be sanitized.
   *
   * @return string
   *   The sanitized identifier.
   *
   * @see decodeValidatorId()
   */
  public static function encodeValidatorId($id) {
    return str_replace(':', '---', $id);
  }

  /**
   * Revert sanitized validator options.
   *
   * @param string $id
   *   The sanitized identifier to be reverted.
   *
   * @return string
   *   The original identifier.
   */
  public static function decodeValidatorId($id) {
    return str_replace('---', ':', $id);
  }

  /**
   * Splits an argument into value and operator properties on this instance.
   *
   * @param bool $force_int
   *   Enforce that values should be numeric.
   */
  protected function unpackArgumentValue($force_int = FALSE) {
    $break = static::breakString($this->argument, $force_int);
    $this->value = $break->value;
    $this->operator = $break->operator;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheMaxAge() {
    $max_age = Cache::PERMANENT;

    // Asks all subplugins (argument defaults, argument validator and styles).
    if (($plugin = $this
      ->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
      $max_age = Cache::mergeMaxAges($max_age, $plugin
        ->getCacheMaxAge());
    }
    if (($plugin = $this
      ->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
      $max_age = Cache::mergeMaxAges($max_age, $plugin
        ->getCacheMaxAge());
    }

    // Summaries use style plugins.
    if (($plugin = $this
      ->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
      $max_age = Cache::mergeMaxAges($max_age, $plugin
        ->getCacheMaxAge());
    }
    return $max_age;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheContexts() {
    $contexts = [];

    // By definition arguments depends on the URL.
    // @todo Once contexts are properly injected into block views we could pull
    //   the information from there.
    $contexts[] = 'url';

    // Asks all subplugins (argument defaults, argument validator and styles).
    if (($plugin = $this
      ->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
      $contexts = Cache::mergeContexts($contexts, $plugin
        ->getCacheContexts());
    }
    if (($plugin = $this
      ->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
      $contexts = Cache::mergeContexts($contexts, $plugin
        ->getCacheContexts());
    }
    if (($plugin = $this
      ->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
      $contexts = Cache::mergeContexts($contexts, $plugin
        ->getCacheContexts());
    }
    return $contexts;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheTags() {
    $tags = [];

    // Asks all subplugins (argument defaults, argument validator and styles).
    if (($plugin = $this
      ->getPlugin('argument_default')) && $plugin instanceof CacheableDependencyInterface) {
      $tags = Cache::mergeTags($tags, $plugin
        ->getCacheTags());
    }
    if (($plugin = $this
      ->getPlugin('argument_validator')) && $plugin instanceof CacheableDependencyInterface) {
      $tags = Cache::mergeTags($tags, $plugin
        ->getCacheTags());
    }
    if (($plugin = $this
      ->getPlugin('style')) && $plugin instanceof CacheableDependencyInterface) {
      $tags = Cache::mergeTags($tags, $plugin
        ->getCacheTags());
    }
    return $tags;
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    $dependencies = [];
    if (($argument_default = $this
      ->getPlugin('argument_default')) && $argument_default instanceof DependentPluginInterface) {
      $dependencies = NestedArray::mergeDeep($dependencies, $argument_default
        ->calculateDependencies());
    }
    if (($argument_validator = $this
      ->getPlugin('argument_validator')) && $argument_validator instanceof DependentPluginInterface) {
      $dependencies = NestedArray::mergeDeep($dependencies, $argument_validator
        ->calculateDependencies());
    }
    if (($style = $this
      ->getPlugin('style')) && $style instanceof DependentPluginInterface) {
      $dependencies = NestedArray::mergeDeep($dependencies, $style
        ->calculateDependencies());
    }
    return $dependencies;
  }

  /**
   * Returns a context definition for this argument.
   *
   * @return \Drupal\Core\Plugin\Context\ContextDefinitionInterface|null
   *   A context definition that represents the argument or NULL if that is
   *   not possible.
   */
  public function getContextDefinition() {
    return $this
      ->getPlugin('argument_validator')
      ->getContextDefinition();
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ArgumentPluginBase::$argument public property
ArgumentPluginBase::$name_field public property The field to use for the name to use in the summary, which is the displayed output. For example, for the node: nid argument, the argument itself is the nid, but node.title is displayed.
ArgumentPluginBase::$name_table public property The table to use for the name, should it not be in the same table as the argument.
ArgumentPluginBase::$validator public property
ArgumentPluginBase::$value public property 1
ArgumentPluginBase::buildOptionsForm public function Provide a form to edit options for this plugin. Overrides HandlerBase::buildOptionsForm 6
ArgumentPluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides HandlerBase::calculateDependencies
ArgumentPluginBase::decodeValidatorId public static function Revert sanitized validator options.
ArgumentPluginBase::defaultAccessDenied public function Default action: access denied.
ArgumentPluginBase::defaultAction public function Handle the default action, which means our argument wasn't present.
ArgumentPluginBase::defaultActions protected function Provide a list of default behaviors for this argument if the argument is not present. 3
ArgumentPluginBase::defaultArgumentForm public function Provide a form for selecting the default argument when the default action is set to provide default argument. 1
ArgumentPluginBase::defaultDefault protected function This just returns true. The view argument builder will know where to find the argument from.
ArgumentPluginBase::defaultEmpty public function Default action: empty
ArgumentPluginBase::defaultIgnore public function Default action: ignore.
ArgumentPluginBase::defaultNotFound protected function Default action: not found.
ArgumentPluginBase::defaultSummary protected function Default action: summary.
ArgumentPluginBase::defaultSummaryForm public function Provide a form for selecting further summary options when the default action is set to display one.
ArgumentPluginBase::defineOptions protected function Information about options for all kinds of purposes will be held here. Overrides HandlerBase::defineOptions 5
ArgumentPluginBase::encodeValidatorId public static function Sanitize validator options including derivatives with : for js.
ArgumentPluginBase::exceptionTitle public function
ArgumentPluginBase::getCacheContexts public function The cache contexts associated with this object. Overrides CacheableDependencyInterface::getCacheContexts
ArgumentPluginBase::getCacheMaxAge public function The maximum age for which this object may be cached. Overrides CacheableDependencyInterface::getCacheMaxAge
ArgumentPluginBase::getCacheTags public function The cache tags associated with this object. Overrides CacheableDependencyInterface::getCacheTags
ArgumentPluginBase::getContextDefinition public function Returns a context definition for this argument. 2
ArgumentPluginBase::getDefaultArgument public function Get a default argument, if available. 1
ArgumentPluginBase::getPlugin public function Get the display or row plugin, if it exists.
ArgumentPluginBase::getSortName public function Return a description of how the argument would normally be sorted. 5
ArgumentPluginBase::getTitle public function Called by the view object to get the title. This may be set by a validator so we don't necessarily call through to title().
ArgumentPluginBase::getTokenHelp protected function Provide token help information for the argument.
ArgumentPluginBase::getValue public function Get the value of this argument.
ArgumentPluginBase::hasDefaultArgument public function Determine if the argument is set to provide a default argument.
ArgumentPluginBase::init public function Overrides Drupal\views\Plugin\views\HandlerBase:init(). Overrides HandlerBase::init 5
ArgumentPluginBase::isException public function
ArgumentPluginBase::needsStylePlugin public function Determine if the argument needs a style plugin.
ArgumentPluginBase::preRenderMoveArgumentOptions public static function Moves argument options into their place.
ArgumentPluginBase::processContainerRadios public static function Custom form radios process function.
ArgumentPluginBase::processSummaryArguments public function Process the summary arguments for display.
ArgumentPluginBase::query public function Set up the query for this argument. Overrides HandlerBase::query 10
ArgumentPluginBase::setArgument public function Set the input for this argument
ArgumentPluginBase::submitOptionsForm public function Handle any special handling on the validate form. Overrides PluginBase::submitOptionsForm
ArgumentPluginBase::summaryArgument public function Provide the argument to use to link from the summary to the next level; this will be called once per row of a summary, and used as part of $view->getUrl(). 4
ArgumentPluginBase::summaryBasics public function Some basic summary behavior that doesn't need to be repeated as much as code that goes into summaryQuery()
ArgumentPluginBase::summaryName public function Provides the name to use for the summary. By default this is just the name field. 8
ArgumentPluginBase::summaryNameField protected function Add the name field, which is the field displayed in summary queries. This is often used when the argument is numeric.
ArgumentPluginBase::summaryQuery protected function Build the info for the summary query. 3
ArgumentPluginBase::summarySort public function Sorts the summary based upon the user's selection. The base variant of this is usually adequate.
ArgumentPluginBase::title public function Get the title this argument will assign the view, given the argument. 10
ArgumentPluginBase::trustedCallbacks public static function Lists the trusted callbacks provided by the implementing class. Overrides PluginBase::trustedCallbacks
ArgumentPluginBase::unpackArgumentValue protected function Splits an argument into value and operator properties on this instance.
ArgumentPluginBase::validateArgument public function Validate that this argument works. By default, all arguments are valid.
ArgumentPluginBase::validateFail public function How to act if validation fails.
ArgumentPluginBase::validateMenuArgument public function Called by the menu system to validate an argument.
ArgumentPluginBase::validateOptionsForm public function Validate the options form. Overrides PluginBase::validateOptionsForm
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
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::adminLabel public function Return a string representing this handler's name in the UI. Overrides ViewsHandlerInterface::adminLabel 4
HandlerBase::adminSummary public function Provide text for the administrative summary. Overrides ViewsHandlerInterface::adminSummary 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::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.
HandlerBase::__construct public function Constructs a Handler object. Overrides PluginBase::__construct 44
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::$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::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::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::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::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::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.
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.